Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 | repos/asio/asio/include/asio/local | repos/asio/asio/include/asio/local/detail/endpoint.hpp | //
// local/detail/endpoint.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
// Derived from a public domain implementation written by Daniel Casimiro.
//
// 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)
//
#ifndef ASIO_LOCAL_DETAIL_ENDPOINT_HPP
#define ASIO_LOCAL_DETAIL_ENDPOINT_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#if defined(ASIO_HAS_LOCAL_SOCKETS)
#include <cstddef>
#include <string>
#include "asio/detail/socket_types.hpp"
#include "asio/detail/string_view.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
namespace local {
namespace detail {
// Helper class for implementing a UNIX domain endpoint.
class endpoint
{
public:
// Default constructor.
ASIO_DECL endpoint();
// Construct an endpoint using the specified path name.
ASIO_DECL endpoint(const char* path_name);
// Construct an endpoint using the specified path name.
ASIO_DECL endpoint(const std::string& path_name);
#if defined(ASIO_HAS_STRING_VIEW)
// Construct an endpoint using the specified path name.
ASIO_DECL endpoint(string_view path_name);
#endif // defined(ASIO_HAS_STRING_VIEW)
// Copy constructor.
endpoint(const endpoint& other)
: data_(other.data_),
path_length_(other.path_length_)
{
}
// Assign from another endpoint.
endpoint& operator=(const endpoint& other)
{
data_ = other.data_;
path_length_ = other.path_length_;
return *this;
}
// Get the underlying endpoint in the native type.
asio::detail::socket_addr_type* data()
{
return &data_.base;
}
// Get the underlying endpoint in the native type.
const asio::detail::socket_addr_type* data() const
{
return &data_.base;
}
// Get the underlying size of the endpoint in the native type.
std::size_t size() const
{
return path_length_
+ offsetof(asio::detail::sockaddr_un_type, sun_path);
}
// Set the underlying size of the endpoint in the native type.
ASIO_DECL void resize(std::size_t size);
// Get the capacity of the endpoint in the native type.
std::size_t capacity() const
{
return sizeof(asio::detail::sockaddr_un_type);
}
// Get the path associated with the endpoint.
ASIO_DECL std::string path() const;
// Set the path associated with the endpoint.
ASIO_DECL void path(const char* p);
// Set the path associated with the endpoint.
ASIO_DECL void path(const std::string& p);
// Compare two endpoints for equality.
ASIO_DECL friend bool operator==(
const endpoint& e1, const endpoint& e2);
// Compare endpoints for ordering.
ASIO_DECL friend bool operator<(
const endpoint& e1, const endpoint& e2);
private:
// The underlying UNIX socket address.
union data_union
{
asio::detail::socket_addr_type base;
asio::detail::sockaddr_un_type local;
} data_;
// The length of the path associated with the endpoint.
std::size_t path_length_;
// Initialise with a specified path.
ASIO_DECL void init(const char* path, std::size_t path_length);
};
} // namespace detail
} // namespace local
} // namespace asio
#include "asio/detail/pop_options.hpp"
#if defined(ASIO_HEADER_ONLY)
# include "asio/local/detail/impl/endpoint.ipp"
#endif // defined(ASIO_HEADER_ONLY)
#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
#endif // ASIO_LOCAL_DETAIL_ENDPOINT_HPP
|
0 | repos/asio/asio/include/asio/local/detail | repos/asio/asio/include/asio/local/detail/impl/endpoint.ipp | //
// local/detail/impl/endpoint.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
// Derived from a public domain implementation written by Daniel Casimiro.
//
// 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)
//
#ifndef ASIO_LOCAL_DETAIL_IMPL_ENDPOINT_IPP
#define ASIO_LOCAL_DETAIL_IMPL_ENDPOINT_IPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#if defined(ASIO_HAS_LOCAL_SOCKETS)
#include <cstring>
#include "asio/detail/socket_ops.hpp"
#include "asio/detail/throw_error.hpp"
#include "asio/error.hpp"
#include "asio/local/detail/endpoint.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
namespace local {
namespace detail {
endpoint::endpoint()
{
init("", 0);
}
endpoint::endpoint(const char* path_name)
{
using namespace std; // For strlen.
init(path_name, strlen(path_name));
}
endpoint::endpoint(const std::string& path_name)
{
init(path_name.data(), path_name.length());
}
#if defined(ASIO_HAS_STRING_VIEW)
endpoint::endpoint(string_view path_name)
{
init(path_name.data(), path_name.length());
}
#endif // defined(ASIO_HAS_STRING_VIEW)
void endpoint::resize(std::size_t new_size)
{
if (new_size > sizeof(asio::detail::sockaddr_un_type))
{
asio::error_code ec(asio::error::invalid_argument);
asio::detail::throw_error(ec);
}
else if (new_size == 0)
{
path_length_ = 0;
}
else
{
path_length_ = new_size
- offsetof(asio::detail::sockaddr_un_type, sun_path);
// The path returned by the operating system may be NUL-terminated.
if (path_length_ > 0 && data_.local.sun_path[path_length_ - 1] == 0)
--path_length_;
}
}
std::string endpoint::path() const
{
return std::string(data_.local.sun_path, path_length_);
}
void endpoint::path(const char* p)
{
using namespace std; // For strlen.
init(p, strlen(p));
}
void endpoint::path(const std::string& p)
{
init(p.data(), p.length());
}
bool operator==(const endpoint& e1, const endpoint& e2)
{
return e1.path() == e2.path();
}
bool operator<(const endpoint& e1, const endpoint& e2)
{
return e1.path() < e2.path();
}
void endpoint::init(const char* path_name, std::size_t path_length)
{
if (path_length > sizeof(data_.local.sun_path) - 1)
{
// The buffer is not large enough to store this address.
asio::error_code ec(asio::error::name_too_long);
asio::detail::throw_error(ec);
}
using namespace std; // For memset and memcpy.
memset(&data_.local, 0, sizeof(asio::detail::sockaddr_un_type));
data_.local.sun_family = AF_UNIX;
if (path_length > 0)
memcpy(data_.local.sun_path, path_name, path_length);
path_length_ = path_length;
}
} // namespace detail
} // namespace local
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
#endif // ASIO_LOCAL_DETAIL_IMPL_ENDPOINT_IPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/require_concept_member.hpp | //
// traits/require_concept_member.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_REQUIRE_CONCEPT_MEMBER_HPP
#define ASIO_TRAITS_REQUIRE_CONCEPT_MEMBER_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
# define ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT 1
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename Property, typename = void>
struct require_concept_member_default;
template <typename T, typename Property, typename = void>
struct require_concept_member;
} // namespace traits
namespace detail {
struct no_require_concept_member
{
static constexpr bool is_valid = false;
static constexpr bool is_noexcept = false;
};
#if defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT)
template <typename T, typename Property, typename = void>
struct require_concept_member_trait : no_require_concept_member
{
};
template <typename T, typename Property>
struct require_concept_member_trait<T, Property,
void_t<
decltype(declval<T>().require_concept(declval<Property>()))
>>
{
static constexpr bool is_valid = true;
using result_type = decltype(
declval<T>().require_concept(declval<Property>()));
static constexpr bool is_noexcept =
noexcept(declval<T>().require_concept(declval<Property>()));
};
#else // defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT)
template <typename T, typename Property, typename = void>
struct require_concept_member_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<Property, decay_t<Property>>::value,
no_require_concept_member,
traits::require_concept_member<
decay_t<T>,
decay_t<Property>>
>
{
};
#endif // defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT)
} // namespace detail
namespace traits {
template <typename T, typename Property, typename>
struct require_concept_member_default :
detail::require_concept_member_trait<T, Property>
{
};
template <typename T, typename Property, typename>
struct require_concept_member :
require_concept_member_default<T, Property>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_REQUIRE_CONCEPT_MEMBER_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/equality_comparable.hpp | //
// traits/equality_comparable.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_EQUALITY_COMPARABLE_HPP
#define ASIO_TRAITS_EQUALITY_COMPARABLE_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
# define ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT 1
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
namespace asio {
namespace traits {
template <typename T, typename = void>
struct equality_comparable_default;
template <typename T, typename = void>
struct equality_comparable;
} // namespace traits
namespace detail {
struct no_equality_comparable
{
static constexpr bool is_valid = false;
static constexpr bool is_noexcept = false;
};
#if defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
template <typename T, typename = void>
struct equality_comparable_trait : no_equality_comparable
{
};
template <typename T>
struct equality_comparable_trait<T,
void_t<
decltype(
static_cast<void>(
static_cast<bool>(declval<const T>() == declval<const T>())
),
static_cast<void>(
static_cast<bool>(declval<const T>() != declval<const T>())
)
)
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
noexcept(declval<const T>() == declval<const T>())
&& noexcept(declval<const T>() != declval<const T>());
};
#else // defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
template <typename T, typename = void>
struct equality_comparable_trait :
conditional_t<
is_same<T, decay_t<T>>::value,
no_equality_comparable,
traits::equality_comparable<decay_t<T>>
>
{
};
#endif // defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
} // namespace detail
namespace traits {
template <typename T, typename>
struct equality_comparable_default : detail::equality_comparable_trait<T>
{
};
template <typename T, typename>
struct equality_comparable : equality_comparable_default<T>
{
};
} // namespace traits
} // namespace asio
#endif // ASIO_TRAITS_EQUALITY_COMPARABLE_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/require_concept_free.hpp | //
// traits/require_concept_free.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_REQUIRE_CONCEPT_FREE_HPP
#define ASIO_TRAITS_REQUIRE_CONCEPT_FREE_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
# define ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_FREE_TRAIT 1
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename Property, typename = void>
struct require_concept_free_default;
template <typename T, typename Property, typename = void>
struct require_concept_free;
} // namespace traits
namespace detail {
struct no_require_concept_free
{
static constexpr bool is_valid = false;
static constexpr bool is_noexcept = false;
};
#if defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_FREE_TRAIT)
template <typename T, typename Property, typename = void>
struct require_concept_free_trait : no_require_concept_free
{
};
template <typename T, typename Property>
struct require_concept_free_trait<T, Property,
void_t<
decltype(require_concept(declval<T>(), declval<Property>()))
>>
{
static constexpr bool is_valid = true;
using result_type = decltype(
require_concept(declval<T>(), declval<Property>()));
static constexpr bool is_noexcept =
noexcept(require_concept(declval<T>(), declval<Property>()));
};
#else // defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_FREE_TRAIT)
template <typename T, typename Property, typename = void>
struct require_concept_free_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<Property, decay_t<Property>>::value,
no_require_concept_free,
traits::require_concept_free<
decay_t<T>,
decay_t<Property>>
>
{
};
#endif // defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_FREE_TRAIT)
} // namespace detail
namespace traits {
template <typename T, typename Property, typename>
struct require_concept_free_default :
detail::require_concept_free_trait<T, Property>
{
};
template <typename T, typename Property, typename>
struct require_concept_free :
require_concept_free_default<T, Property>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_REQUIRE_CONCEPT_FREE_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/query_static_constexpr_member.hpp | //
// traits/query_static_constexpr_member.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_QUERY_STATIC_CONSTEXPR_MEMBER_HPP
#define ASIO_TRAITS_QUERY_STATIC_CONSTEXPR_MEMBER_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#if defined(ASIO_HAS_CONSTANT_EXPRESSION_SFINAE) \
&& defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
# define ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT 1
#endif // defined(ASIO_HAS_CONSTANT_EXPRESSION_SFINAE)
// && defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename Property, typename = void>
struct query_static_constexpr_member_default;
template <typename T, typename Property, typename = void>
struct query_static_constexpr_member;
} // namespace traits
namespace detail {
struct no_query_static_constexpr_member
{
static constexpr bool is_valid = false;
};
template <typename T, typename Property, typename = void>
struct query_static_constexpr_member_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<Property, decay_t<Property>>::value,
no_query_static_constexpr_member,
traits::query_static_constexpr_member<
decay_t<T>,
decay_t<Property>>
>
{
};
#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
template <typename T, typename Property>
struct query_static_constexpr_member_trait<T, Property,
enable_if_t<
(static_cast<void>(T::query(Property{})), true)
>>
{
static constexpr bool is_valid = true;
using result_type = decltype(T::query(Property{}));
static constexpr bool is_noexcept = noexcept(T::query(Property{}));
static constexpr result_type value() noexcept(is_noexcept)
{
return T::query(Property{});
}
};
#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
} // namespace detail
namespace traits {
template <typename T, typename Property, typename>
struct query_static_constexpr_member_default :
detail::query_static_constexpr_member_trait<T, Property>
{
};
template <typename T, typename Property, typename>
struct query_static_constexpr_member :
query_static_constexpr_member_default<T, Property>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_QUERY_STATIC_CONSTEXPR_MEMBER_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/execute_member.hpp | //
// traits/execute_member.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_EXECUTE_MEMBER_HPP
#define ASIO_TRAITS_EXECUTE_MEMBER_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
# define ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT 1
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename F, typename = void>
struct execute_member_default;
template <typename T, typename F, typename = void>
struct execute_member;
} // namespace traits
namespace detail {
struct no_execute_member
{
static constexpr bool is_valid = false;
static constexpr bool is_noexcept = false;
};
#if defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
template <typename T, typename F, typename = void>
struct execute_member_trait : no_execute_member
{
};
template <typename T, typename F>
struct execute_member_trait<T, F,
void_t<
decltype(declval<T>().execute(declval<F>()))
>>
{
static constexpr bool is_valid = true;
using result_type = decltype(
declval<T>().execute(declval<F>()));
static constexpr bool is_noexcept =
noexcept(declval<T>().execute(declval<F>()));
};
#else // defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
template <typename T, typename F, typename = void>
struct execute_member_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<F, decay_t<F>>::value,
no_execute_member,
traits::execute_member<
decay_t<T>,
decay_t<F>>
>
{
};
#endif // defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
} // namespace detail
namespace traits {
template <typename T, typename F, typename>
struct execute_member_default :
detail::execute_member_trait<T, F>
{
};
template <typename T, typename F, typename>
struct execute_member :
execute_member_default<T, F>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_EXECUTE_MEMBER_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/require_free.hpp | //
// traits/require_free.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_REQUIRE_FREE_HPP
#define ASIO_TRAITS_REQUIRE_FREE_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
# define ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT 1
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename Property, typename = void>
struct require_free_default;
template <typename T, typename Property, typename = void>
struct require_free;
} // namespace traits
namespace detail {
struct no_require_free
{
static constexpr bool is_valid = false;
static constexpr bool is_noexcept = false;
};
#if defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
template <typename T, typename Property, typename = void>
struct require_free_trait : no_require_free
{
};
template <typename T, typename Property>
struct require_free_trait<T, Property,
void_t<
decltype(require(declval<T>(), declval<Property>()))
>>
{
static constexpr bool is_valid = true;
using result_type = decltype(
require(declval<T>(), declval<Property>()));
static constexpr bool is_noexcept =
noexcept(require(declval<T>(), declval<Property>()));
};
#else // defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
template <typename T, typename Property, typename = void>
struct require_free_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<Property, decay_t<Property>>::value,
no_require_free,
traits::require_free<
decay_t<T>,
decay_t<Property>>
>
{
};
#endif // defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
} // namespace detail
namespace traits {
template <typename T, typename Property, typename>
struct require_free_default :
detail::require_free_trait<T, Property>
{
};
template <typename T, typename Property, typename>
struct require_free :
require_free_default<T, Property>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_REQUIRE_FREE_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/static_query.hpp | //
// traits/static_query.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_STATIC_QUERY_HPP
#define ASIO_TRAITS_STATIC_QUERY_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#if defined(ASIO_HAS_VARIABLE_TEMPLATES) \
&& defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
# define ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT 1
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
// && defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename Property, typename = void>
struct static_query_default;
template <typename T, typename Property, typename = void>
struct static_query;
} // namespace traits
namespace detail {
struct no_static_query
{
static constexpr bool is_valid = false;
static constexpr bool is_noexcept = false;
};
template <typename T, typename Property, typename = void>
struct static_query_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<Property, decay_t<Property>>::value,
no_static_query,
traits::static_query<
decay_t<T>,
decay_t<Property>>
>
{
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
template <typename T, typename Property>
struct static_query_trait<T, Property,
void_t<
decltype(decay_t<Property>::template static_query_v<T>)
>>
{
static constexpr bool is_valid = true;
using result_type = decltype(
decay_t<Property>::template static_query_v<T>);
static constexpr bool is_noexcept =
noexcept(decay_t<Property>::template static_query_v<T>);
static constexpr result_type value() noexcept(is_noexcept)
{
return decay_t<Property>::template static_query_v<T>;
}
};
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
} // namespace detail
namespace traits {
template <typename T, typename Property, typename>
struct static_query_default : detail::static_query_trait<T, Property>
{
};
template <typename T, typename Property, typename>
struct static_query : static_query_default<T, Property>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_STATIC_QUERY_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/static_require.hpp | //
// traits/static_require.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_STATIC_REQUIRE_HPP
#define ASIO_TRAITS_STATIC_REQUIRE_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/traits/static_query.hpp"
#define ASIO_HAS_DEDUCED_STATIC_REQUIRE_TRAIT 1
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename Property, typename = void>
struct static_require_default;
template <typename T, typename Property, typename = void>
struct static_require;
} // namespace traits
namespace detail {
struct no_static_require
{
static constexpr bool is_valid = false;
};
template <typename T, typename Property, typename = void>
struct static_require_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<Property, decay_t<Property>>::value,
no_static_require,
traits::static_require<
decay_t<T>,
decay_t<Property>>
>
{
};
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
template <typename T, typename Property>
struct static_require_trait<T, Property,
enable_if_t<
decay_t<Property>::value() == traits::static_query<T, Property>::value()
>>
{
static constexpr bool is_valid = true;
};
#else // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
false_type static_require_test(...);
template <typename T, typename Property>
true_type static_require_test(T*, Property*,
enable_if_t<
Property::value() == traits::static_query<T, Property>::value()
>* = 0);
template <typename T, typename Property>
struct has_static_require
{
static constexpr bool value =
decltype((static_require_test)(
static_cast<T*>(0), static_cast<Property*>(0)))::value;
};
template <typename T, typename Property>
struct static_require_trait<T, Property,
enable_if_t<
has_static_require<decay_t<T>,
decay_t<Property>>::value
>>
{
static constexpr bool is_valid = true;
};
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
} // namespace detail
namespace traits {
template <typename T, typename Property, typename>
struct static_require_default : detail::static_require_trait<T, Property>
{
};
template <typename T, typename Property, typename>
struct static_require : static_require_default<T, Property>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_STATIC_REQUIRE_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/static_require_concept.hpp | //
// traits/static_require_concept.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_STATIC_REQUIRE_CONCEPT_HPP
#define ASIO_TRAITS_STATIC_REQUIRE_CONCEPT_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/traits/static_query.hpp"
#define ASIO_HAS_DEDUCED_STATIC_REQUIRE_CONCEPT_TRAIT 1
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename Property, typename = void>
struct static_require_concept_default;
template <typename T, typename Property, typename = void>
struct static_require_concept;
} // namespace traits
namespace detail {
struct no_static_require_concept
{
static constexpr bool is_valid = false;
};
template <typename T, typename Property, typename = void>
struct static_require_concept_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<Property, decay_t<Property>>::value,
no_static_require_concept,
traits::static_require_concept<
decay_t<T>,
decay_t<Property>>
>
{
};
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
template <typename T, typename Property>
struct static_require_concept_trait<T, Property,
enable_if_t<
decay_t<Property>::value() == traits::static_query<T, Property>::value()
>>
{
static constexpr bool is_valid = true;
};
#else // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
false_type static_require_concept_test(...);
template <typename T, typename Property>
true_type static_require_concept_test(T*, Property*,
enable_if_t<
Property::value() == traits::static_query<T, Property>::value()
>* = 0);
template <typename T, typename Property>
struct has_static_require_concept
{
static constexpr bool value =
decltype((static_require_concept_test)(
static_cast<T*>(0), static_cast<Property*>(0)))::value;
};
template <typename T, typename Property>
struct static_require_concept_trait<T, Property,
enable_if_t<
has_static_require_concept<decay_t<T>,
decay_t<Property>>::value
>>
{
static constexpr bool is_valid = true;
};
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
} // namespace detail
namespace traits {
template <typename T, typename Property, typename>
struct static_require_concept_default :
detail::static_require_concept_trait<T, Property>
{
};
template <typename T, typename Property, typename>
struct static_require_concept : static_require_concept_default<T, Property>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_STATIC_REQUIRE_CONCEPT_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/require_member.hpp | //
// traits/require_member.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_REQUIRE_MEMBER_HPP
#define ASIO_TRAITS_REQUIRE_MEMBER_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
# define ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT 1
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename Property, typename = void>
struct require_member_default;
template <typename T, typename Property, typename = void>
struct require_member;
} // namespace traits
namespace detail {
struct no_require_member
{
static constexpr bool is_valid = false;
static constexpr bool is_noexcept = false;
};
#if defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
template <typename T, typename Property, typename = void>
struct require_member_trait : no_require_member
{
};
template <typename T, typename Property>
struct require_member_trait<T, Property,
void_t<
decltype(declval<T>().require(declval<Property>()))
>>
{
static constexpr bool is_valid = true;
using result_type = decltype(
declval<T>().require(declval<Property>()));
static constexpr bool is_noexcept =
noexcept(declval<T>().require(declval<Property>()));
};
#else // defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
template <typename T, typename Property, typename = void>
struct require_member_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<Property, decay_t<Property>>::value,
no_require_member,
traits::require_member<
decay_t<T>,
decay_t<Property>>
>
{
};
#endif // defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
} // namespace detail
namespace traits {
template <typename T, typename Property, typename>
struct require_member_default :
detail::require_member_trait<T, Property>
{
};
template <typename T, typename Property, typename>
struct require_member :
require_member_default<T, Property>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_REQUIRE_MEMBER_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/query_member.hpp | //
// traits/query_member.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_QUERY_MEMBER_HPP
#define ASIO_TRAITS_QUERY_MEMBER_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
# define ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT 1
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename Property, typename = void>
struct query_member_default;
template <typename T, typename Property, typename = void>
struct query_member;
} // namespace traits
namespace detail {
struct no_query_member
{
static constexpr bool is_valid = false;
static constexpr bool is_noexcept = false;
};
#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
template <typename T, typename Property, typename = void>
struct query_member_trait : no_query_member
{
};
template <typename T, typename Property>
struct query_member_trait<T, Property,
void_t<
decltype(declval<T>().query(declval<Property>()))
>>
{
static constexpr bool is_valid = true;
using result_type = decltype(
declval<T>().query(declval<Property>()));
static constexpr bool is_noexcept =
noexcept(declval<T>().query(declval<Property>()));
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
template <typename T, typename Property, typename = void>
struct query_member_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<Property, decay_t<Property>>::value,
no_query_member,
traits::query_member<
decay_t<T>,
decay_t<Property>>
>
{
};
#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
} // namespace detail
namespace traits {
template <typename T, typename Property, typename>
struct query_member_default :
detail::query_member_trait<T, Property>
{
};
template <typename T, typename Property, typename>
struct query_member :
query_member_default<T, Property>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_QUERY_MEMBER_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/prefer_free.hpp | //
// traits/prefer_free.hpp
// ~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_PREFER_FREE_HPP
#define ASIO_TRAITS_PREFER_FREE_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
# define ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT 1
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename Property, typename = void>
struct prefer_free_default;
template <typename T, typename Property, typename = void>
struct prefer_free;
} // namespace traits
namespace detail {
struct no_prefer_free
{
static constexpr bool is_valid = false;
static constexpr bool is_noexcept = false;
};
#if defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
template <typename T, typename Property, typename = void>
struct prefer_free_trait : no_prefer_free
{
};
template <typename T, typename Property>
struct prefer_free_trait<T, Property,
void_t<
decltype(prefer(declval<T>(), declval<Property>()))
>>
{
static constexpr bool is_valid = true;
using result_type = decltype(
prefer(declval<T>(), declval<Property>()));
static constexpr bool is_noexcept =
noexcept(prefer(declval<T>(), declval<Property>()));
};
#else // defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
template <typename T, typename Property, typename = void>
struct prefer_free_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<Property, decay_t<Property>>::value,
no_prefer_free,
traits::prefer_free<
decay_t<T>,
decay_t<Property>>
>
{
};
#endif // defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
} // namespace detail
namespace traits {
template <typename T, typename Property, typename>
struct prefer_free_default :
detail::prefer_free_trait<T, Property>
{
};
template <typename T, typename Property, typename>
struct prefer_free :
prefer_free_default<T, Property>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_PREFER_FREE_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/prefer_member.hpp | //
// traits/prefer_member.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_PREFER_MEMBER_HPP
#define ASIO_TRAITS_PREFER_MEMBER_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
# define ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT 1
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename Property, typename = void>
struct prefer_member_default;
template <typename T, typename Property, typename = void>
struct prefer_member;
} // namespace traits
namespace detail {
struct no_prefer_member
{
static constexpr bool is_valid = false;
static constexpr bool is_noexcept = false;
};
#if defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
template <typename T, typename Property, typename = void>
struct prefer_member_trait : no_prefer_member
{
};
template <typename T, typename Property>
struct prefer_member_trait<T, Property,
void_t<
decltype(declval<T>().prefer(declval<Property>()))
>>
{
static constexpr bool is_valid = true;
using result_type = decltype(
declval<T>().prefer(declval<Property>()));
static constexpr bool is_noexcept =
noexcept(declval<T>().prefer(declval<Property>()));
};
#else // defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
template <typename T, typename Property, typename = void>
struct prefer_member_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<Property, decay_t<Property>>::value,
no_prefer_member,
traits::prefer_member<
decay_t<T>,
decay_t<Property>>
>
{
};
#endif // defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
} // namespace detail
namespace traits {
template <typename T, typename Property, typename>
struct prefer_member_default :
detail::prefer_member_trait<T, Property>
{
};
template <typename T, typename Property, typename>
struct prefer_member :
prefer_member_default<T, Property>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_PREFER_MEMBER_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/traits/query_free.hpp | //
// traits/query_free.hpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_TRAITS_QUERY_FREE_HPP
#define ASIO_TRAITS_QUERY_FREE_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
# define ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT 1
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
#include "asio/detail/push_options.hpp"
namespace asio {
namespace traits {
template <typename T, typename Property, typename = void>
struct query_free_default;
template <typename T, typename Property, typename = void>
struct query_free;
} // namespace traits
namespace detail {
struct no_query_free
{
static constexpr bool is_valid = false;
static constexpr bool is_noexcept = false;
};
#if defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
template <typename T, typename Property, typename = void>
struct query_free_trait : no_query_free
{
};
template <typename T, typename Property>
struct query_free_trait<T, Property,
void_t<
decltype(query(declval<T>(), declval<Property>()))
>>
{
static constexpr bool is_valid = true;
using result_type = decltype(
query(declval<T>(), declval<Property>()));
static constexpr bool is_noexcept =
noexcept(query(declval<T>(), declval<Property>()));
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
template <typename T, typename Property, typename = void>
struct query_free_trait :
conditional_t<
is_same<T, decay_t<T>>::value
&& is_same<Property, decay_t<Property>>::value,
no_query_free,
traits::query_free<
decay_t<T>,
decay_t<Property>>
>
{
};
#endif // defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
} // namespace detail
namespace traits {
template <typename T, typename Property, typename>
struct query_free_default :
detail::query_free_trait<T, Property>
{
};
template <typename T, typename Property, typename>
struct query_free :
query_free_default<T, Property>
{
};
} // namespace traits
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_TRAITS_QUERY_FREE_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/prefer_only.hpp | //
// execution/prefer_only.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_PREFER_ONLY_HPP
#define ASIO_EXECUTION_PREFER_ONLY_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/is_applicable_property.hpp"
#include "asio/prefer.hpp"
#include "asio/query.hpp"
#include "asio/traits/static_query.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
#if defined(GENERATING_DOCUMENTATION)
namespace execution {
/// A property adapter that is used with the polymorphic executor wrapper
/// to mark properties as preferable, but not requirable.
template <typename Property>
struct prefer_only
{
/// The prefer_only adapter applies to the same types as the nested property.
template <typename T>
static constexpr bool is_applicable_property_v =
is_applicable_property<T, Property>::value;
/// The context_t property cannot be required.
static constexpr bool is_requirable = false;
/// The context_t property can be preferred, it the underlying property can
/// be preferred.
/**
* @c true if @c Property::is_preferable is @c true, otherwise @c false.
*/
static constexpr bool is_preferable = automatically_determined;
/// The type returned by queries against an @c any_executor.
typedef typename Property::polymorphic_query_result_type
polymorphic_query_result_type;
};
} // namespace execution
#else // defined(GENERATING_DOCUMENTATION)
namespace execution {
namespace detail {
template <typename InnerProperty, typename = void>
struct prefer_only_is_preferable
{
static constexpr bool is_preferable = false;
};
template <typename InnerProperty>
struct prefer_only_is_preferable<InnerProperty,
enable_if_t<
InnerProperty::is_preferable
>
>
{
static constexpr bool is_preferable = true;
};
template <typename InnerProperty, typename = void>
struct prefer_only_polymorphic_query_result_type
{
};
template <typename InnerProperty>
struct prefer_only_polymorphic_query_result_type<InnerProperty,
void_t<
typename InnerProperty::polymorphic_query_result_type
>
>
{
typedef typename InnerProperty::polymorphic_query_result_type
polymorphic_query_result_type;
};
template <typename InnerProperty, typename = void>
struct prefer_only_property
{
InnerProperty property;
prefer_only_property(const InnerProperty& p)
: property(p)
{
}
};
#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
template <typename InnerProperty>
struct prefer_only_property<InnerProperty,
void_t<
decltype(asio::declval<const InnerProperty>().value())
>
>
{
InnerProperty property;
prefer_only_property(const InnerProperty& p)
: property(p)
{
}
constexpr auto value() const
noexcept(noexcept(asio::declval<const InnerProperty>().value()))
-> decltype(asio::declval<const InnerProperty>().value())
{
return property.value();
}
};
#else // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
struct prefer_only_memfns_base
{
void value();
};
template <typename T>
struct prefer_only_memfns_derived
: T, prefer_only_memfns_base
{
};
template <typename T, T>
struct prefer_only_memfns_check
{
};
template <typename>
char (&prefer_only_value_memfn_helper(...))[2];
template <typename T>
char prefer_only_value_memfn_helper(
prefer_only_memfns_check<
void (prefer_only_memfns_base::*)(),
&prefer_only_memfns_derived<T>::value>*);
template <typename InnerProperty>
struct prefer_only_property<InnerProperty,
enable_if_t<
sizeof(prefer_only_value_memfn_helper<InnerProperty>(0)) != 1
&& !is_same<typename InnerProperty::polymorphic_query_result_type,
void>::value
>
>
{
InnerProperty property;
prefer_only_property(const InnerProperty& p)
: property(p)
{
}
constexpr typename InnerProperty::polymorphic_query_result_type
value() const
{
return property.value();
}
};
#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
} // namespace detail
template <typename InnerProperty>
struct prefer_only :
detail::prefer_only_is_preferable<InnerProperty>,
detail::prefer_only_polymorphic_query_result_type<InnerProperty>,
detail::prefer_only_property<InnerProperty>
{
static constexpr bool is_requirable = false;
constexpr prefer_only(const InnerProperty& p)
: detail::prefer_only_property<InnerProperty>(p)
{
}
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr
typename traits::static_query<T, InnerProperty>::result_type
static_query()
noexcept(traits::static_query<T, InnerProperty>::is_noexcept)
{
return traits::static_query<T, InnerProperty>::value();
}
template <typename E, typename T = decltype(prefer_only::static_query<E>())>
static constexpr const T static_query_v
= prefer_only::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename Executor, typename Property>
friend constexpr
prefer_result_t<const Executor&, const InnerProperty&>
prefer(const Executor& ex, const prefer_only<Property>& p,
enable_if_t<
is_same<Property, InnerProperty>::value
>* = 0,
enable_if_t<
can_prefer<const Executor&, const InnerProperty&>::value
>* = 0)
#if !defined(ASIO_MSVC) \
&& !defined(__clang__) // Clang crashes if noexcept is used here.
noexcept(is_nothrow_prefer<const Executor&, const InnerProperty&>::value)
#endif // !defined(ASIO_MSVC)
// && !defined(__clang__)
{
return asio::prefer(ex, p.property);
}
template <typename Executor, typename Property>
friend constexpr
query_result_t<const Executor&, const InnerProperty&>
query(const Executor& ex, const prefer_only<Property>& p,
enable_if_t<
is_same<Property, InnerProperty>::value
>* = 0,
enable_if_t<
can_query<const Executor&, const InnerProperty&>::value
>* = 0)
#if !defined(ASIO_MSVC) \
&& !defined(__clang__) // Clang crashes if noexcept is used here.
noexcept(is_nothrow_query<const Executor&, const InnerProperty&>::value)
#endif // !defined(ASIO_MSVC)
// && !defined(__clang__)
{
return asio::query(ex, p.property);
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename InnerProperty> template <typename E, typename T>
const T prefer_only<InnerProperty>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace execution
template <typename T, typename InnerProperty>
struct is_applicable_property<T, execution::prefer_only<InnerProperty>>
: is_applicable_property<T, InnerProperty>
{
};
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
|| !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T, typename InnerProperty>
struct static_query<T, execution::prefer_only<InnerProperty>> :
static_query<T, const InnerProperty&>
{
};
#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
#if !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
template <typename T, typename InnerProperty>
struct prefer_free_default<T, execution::prefer_only<InnerProperty>,
enable_if_t<
can_prefer<const T&, const InnerProperty&>::value
>
>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_prefer<const T&, const InnerProperty&>::value;
typedef prefer_result_t<const T&, const InnerProperty&> result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
template <typename T, typename InnerProperty>
struct query_free<T, execution::prefer_only<InnerProperty>,
enable_if_t<
can_query<const T&, const InnerProperty&>::value
>
>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<const T&, const InnerProperty&>::value;
typedef query_result_t<const T&, const InnerProperty&> result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
} // namespace traits
#endif // defined(GENERATING_DOCUMENTATION)
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_PREFER_ONLY_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/invocable_archetype.hpp | //
// execution/invocable_archetype.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_INVOCABLE_ARCHETYPE_HPP
#define ASIO_EXECUTION_INVOCABLE_ARCHETYPE_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
namespace execution {
/// An archetypal function object used for determining adherence to the
/// execution::executor concept.
struct invocable_archetype
{
/// Function call operator.
template <typename... Args>
void operator()(Args&&...)
{
}
};
} // namespace execution
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_INVOCABLE_ARCHETYPE_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/bad_executor.hpp | //
// execution/bad_executor.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_BAD_EXECUTOR_HPP
#define ASIO_EXECUTION_BAD_EXECUTOR_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include <exception>
#include "asio/detail/push_options.hpp"
namespace asio {
namespace execution {
/// Exception thrown when trying to access an empty polymorphic executor.
class bad_executor
: public std::exception
{
public:
/// Constructor.
ASIO_DECL bad_executor() noexcept;
/// Obtain message associated with exception.
ASIO_DECL virtual const char* what() const noexcept;
};
} // namespace execution
} // namespace asio
#include "asio/detail/pop_options.hpp"
#if defined(ASIO_HEADER_ONLY)
# include "asio/execution/impl/bad_executor.ipp"
#endif // defined(ASIO_HEADER_ONLY)
#endif // ASIO_EXECUTION_BAD_EXECUTOR_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/relationship.hpp | //
// execution/relationship.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_RELATIONSHIP_HPP
#define ASIO_EXECUTION_RELATIONSHIP_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/execution/executor.hpp"
#include "asio/is_applicable_property.hpp"
#include "asio/query.hpp"
#include "asio/traits/query_free.hpp"
#include "asio/traits/query_member.hpp"
#include "asio/traits/query_static_constexpr_member.hpp"
#include "asio/traits/static_query.hpp"
#include "asio/traits/static_require.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
#if defined(GENERATING_DOCUMENTATION)
namespace execution {
/// A property to describe whether submitted tasks represent continuations of
/// the calling context.
struct relationship_t
{
/// The relationship_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The top-level relationship_t property cannot be required.
static constexpr bool is_requirable = false;
/// The top-level relationship_t property cannot be preferred.
static constexpr bool is_preferable = false;
/// The type returned by queries against an @c any_executor.
typedef relationship_t polymorphic_query_result_type;
/// A sub-property that indicates that the executor does not represent a
/// continuation of the calling context.
struct fork_t
{
/// The relationship_t::fork_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The relationship_t::fork_t property can be required.
static constexpr bool is_requirable = true;
/// The relationship_t::fork_t property can be preferred.
static constexpr bool is_preferable = true;
/// The type returned by queries against an @c any_executor.
typedef relationship_t polymorphic_query_result_type;
/// Default constructor.
constexpr fork_t();
/// Get the value associated with a property object.
/**
* @returns fork_t();
*/
static constexpr relationship_t value();
};
/// A sub-property that indicates that the executor represents a continuation
/// of the calling context.
struct continuation_t
{
/// The relationship_t::continuation_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The relationship_t::continuation_t property can be required.
static constexpr bool is_requirable = true;
/// The relationship_t::continuation_t property can be preferred.
static constexpr bool is_preferable = true;
/// The type returned by queries against an @c any_executor.
typedef relationship_t polymorphic_query_result_type;
/// Default constructor.
constexpr continuation_t();
/// Get the value associated with a property object.
/**
* @returns continuation_t();
*/
static constexpr relationship_t value();
};
/// A special value used for accessing the relationship_t::fork_t property.
static constexpr fork_t fork;
/// A special value used for accessing the relationship_t::continuation_t
/// property.
static constexpr continuation_t continuation;
/// Default constructor.
constexpr relationship_t();
/// Construct from a sub-property value.
constexpr relationship_t(fork_t);
/// Construct from a sub-property value.
constexpr relationship_t(continuation_t);
/// Compare property values for equality.
friend constexpr bool operator==(
const relationship_t& a, const relationship_t& b) noexcept;
/// Compare property values for inequality.
friend constexpr bool operator!=(
const relationship_t& a, const relationship_t& b) noexcept;
};
/// A special value used for accessing the relationship_t property.
constexpr relationship_t relationship;
} // namespace execution
#else // defined(GENERATING_DOCUMENTATION)
namespace execution {
namespace detail {
namespace relationship {
template <int I> struct fork_t;
template <int I> struct continuation_t;
} // namespace relationship
template <int I = 0>
struct relationship_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = false;
static constexpr bool is_preferable = false;
typedef relationship_t polymorphic_query_result_type;
typedef detail::relationship::fork_t<I> fork_t;
typedef detail::relationship::continuation_t<I> continuation_t;
constexpr relationship_t()
: value_(-1)
{
}
constexpr relationship_t(fork_t)
: value_(0)
{
}
constexpr relationship_t(continuation_t)
: value_(1)
{
}
template <typename T>
struct proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
struct type
{
template <typename P>
auto query(P&& p) const
noexcept(
noexcept(
declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
)
)
-> decltype(
declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
);
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
};
template <typename T>
struct static_proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
struct type
{
template <typename P>
static constexpr auto query(P&& p)
noexcept(
noexcept(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
)
-> decltype(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
{
return T::query(static_cast<P&&>(p));
}
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
};
template <typename T>
struct query_member :
traits::query_member<typename proxy<T>::type, relationship_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename static_proxy<T>::type, relationship_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr
typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename T>
static constexpr
typename traits::static_query<T, fork_t>::result_type
static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
traits::static_query<T, fork_t>::is_valid
>* = 0) noexcept
{
return traits::static_query<T, fork_t>::value();
}
template <typename T>
static constexpr
typename traits::static_query<T, continuation_t>::result_type
static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
!traits::static_query<T, fork_t>::is_valid
>* = 0,
enable_if_t<
traits::static_query<T, continuation_t>::is_valid
>* = 0) noexcept
{
return traits::static_query<T, continuation_t>::value();
}
template <typename E,
typename T = decltype(relationship_t::static_query<E>())>
static constexpr const T static_query_v
= relationship_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
friend constexpr bool operator==(
const relationship_t& a, const relationship_t& b)
{
return a.value_ == b.value_;
}
friend constexpr bool operator!=(
const relationship_t& a, const relationship_t& b)
{
return a.value_ != b.value_;
}
struct convertible_from_relationship_t
{
constexpr convertible_from_relationship_t(relationship_t)
{
}
};
template <typename Executor>
friend constexpr relationship_t query(
const Executor& ex, convertible_from_relationship_t,
enable_if_t<
can_query<const Executor&, fork_t>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(is_nothrow_query<const Executor&, relationship_t<>::fork_t>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, fork_t>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, fork_t());
}
template <typename Executor>
friend constexpr relationship_t query(
const Executor& ex, convertible_from_relationship_t,
enable_if_t<
!can_query<const Executor&, fork_t>::value
>* = 0,
enable_if_t<
can_query<const Executor&, continuation_t>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(is_nothrow_query<const Executor&,
relationship_t<>::continuation_t>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, continuation_t>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, continuation_t());
}
ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(fork_t, fork);
ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(continuation_t, continuation);
private:
int value_;
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T relationship_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I>
const typename relationship_t<I>::fork_t relationship_t<I>::fork;
template <int I>
const typename relationship_t<I>::continuation_t
relationship_t<I>::continuation;
namespace relationship {
template <int I = 0>
struct fork_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = true;
typedef relationship_t<I> polymorphic_query_result_type;
constexpr fork_t()
{
}
template <typename T>
struct query_member :
traits::query_member<
typename relationship_t<I>::template proxy<T>::type, fork_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename relationship_t<I>::template static_proxy<T>::type, fork_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename T>
static constexpr fork_t static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
!traits::query_free<T, fork_t>::is_valid
>* = 0,
enable_if_t<
!can_query<T, continuation_t<I>>::value
>* = 0) noexcept
{
return fork_t();
}
template <typename E, typename T = decltype(fork_t::static_query<E>())>
static constexpr const T static_query_v
= fork_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
static constexpr relationship_t<I> value()
{
return fork_t();
}
friend constexpr bool operator==(const fork_t&, const fork_t&)
{
return true;
}
friend constexpr bool operator!=(const fork_t&, const fork_t&)
{
return false;
}
friend constexpr bool operator==(const fork_t&, const continuation_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const fork_t&, const continuation_t<I>&)
{
return true;
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T fork_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I = 0>
struct continuation_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = true;
typedef relationship_t<I> polymorphic_query_result_type;
constexpr continuation_t()
{
}
template <typename T>
struct query_member :
traits::query_member<
typename relationship_t<I>::template proxy<T>::type, continuation_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename relationship_t<I>::template static_proxy<T>::type,
continuation_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename E,
typename T = decltype(continuation_t::static_query<E>())>
static constexpr const T static_query_v
= continuation_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
static constexpr relationship_t<I> value()
{
return continuation_t();
}
friend constexpr bool operator==(const continuation_t&, const continuation_t&)
{
return true;
}
friend constexpr bool operator!=(const continuation_t&, const continuation_t&)
{
return false;
}
friend constexpr bool operator==(const continuation_t&, const fork_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const continuation_t&, const fork_t<I>&)
{
return true;
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T continuation_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace relationship
} // namespace detail
typedef detail::relationship_t<> relationship_t;
ASIO_INLINE_VARIABLE constexpr relationship_t relationship;
} // namespace execution
#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
struct is_applicable_property<T, execution::relationship_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
template <typename T>
struct is_applicable_property<T, execution::relationship_t::fork_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
template <typename T>
struct is_applicable_property<T, execution::relationship_t::continuation_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
template <typename T>
struct query_free_default<T, execution::relationship_t,
enable_if_t<
can_query<T, execution::relationship_t::fork_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<T, execution::relationship_t::fork_t>::value;
typedef execution::relationship_t result_type;
};
template <typename T>
struct query_free_default<T, execution::relationship_t,
enable_if_t<
!can_query<T, execution::relationship_t::fork_t>::value
&& can_query<T, execution::relationship_t::continuation_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<T, execution::relationship_t::continuation_t>::value;
typedef execution::relationship_t result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
|| !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
struct static_query<T, execution::relationship_t,
enable_if_t<
execution::detail::relationship_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::relationship_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::relationship_t<0>::
query_static_constexpr_member<T>::value();
}
};
template <typename T>
struct static_query<T, execution::relationship_t,
enable_if_t<
!execution::detail::relationship_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::relationship_t<0>::
query_member<T>::is_valid
&& traits::static_query<T,
execution::relationship_t::fork_t>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename traits::static_query<T,
execution::relationship_t::fork_t>::result_type result_type;
static constexpr result_type value()
{
return traits::static_query<T,
execution::relationship_t::fork_t>::value();
}
};
template <typename T>
struct static_query<T, execution::relationship_t,
enable_if_t<
!execution::detail::relationship_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::relationship_t<0>::
query_member<T>::is_valid
&& !traits::static_query<T,
execution::relationship_t::fork_t>::is_valid
&& traits::static_query<T,
execution::relationship_t::continuation_t>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename traits::static_query<T,
execution::relationship_t::continuation_t>::result_type result_type;
static constexpr result_type value()
{
return traits::static_query<T,
execution::relationship_t::continuation_t>::value();
}
};
template <typename T>
struct static_query<T, execution::relationship_t::fork_t,
enable_if_t<
execution::detail::relationship::fork_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::relationship::fork_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::relationship::fork_t<0>::
query_static_constexpr_member<T>::value();
}
};
template <typename T>
struct static_query<T, execution::relationship_t::fork_t,
enable_if_t<
!execution::detail::relationship::fork_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::relationship::fork_t<0>::
query_member<T>::is_valid
&& !traits::query_free<T,
execution::relationship_t::fork_t>::is_valid
&& !can_query<T, execution::relationship_t::continuation_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::relationship_t::fork_t result_type;
static constexpr result_type value()
{
return result_type();
}
};
template <typename T>
struct static_query<T, execution::relationship_t::continuation_t,
enable_if_t<
execution::detail::relationship::continuation_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::relationship::continuation_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::relationship::continuation_t<0>::
query_static_constexpr_member<T>::value();
}
};
#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace traits
#endif // defined(GENERATING_DOCUMENTATION)
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_RELATIONSHIP_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/context_as.hpp | //
// execution/context_as.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_CONTEXT_AS_HPP
#define ASIO_EXECUTION_CONTEXT_AS_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/execution/context.hpp"
#include "asio/execution/executor.hpp"
#include "asio/is_applicable_property.hpp"
#include "asio/query.hpp"
#include "asio/traits/query_static_constexpr_member.hpp"
#include "asio/traits/static_query.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
#if defined(GENERATING_DOCUMENTATION)
namespace execution {
/// A property that is used to obtain the execution context that is associated
/// with an executor.
template <typename U>
struct context_as_t
{
/// The context_as_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The context_t property cannot be required.
static constexpr bool is_requirable = false;
/// The context_t property cannot be preferred.
static constexpr bool is_preferable = false;
/// The type returned by queries against an @c any_executor.
typedef T polymorphic_query_result_type;
};
/// A special value used for accessing the context_as_t property.
template <typename U>
constexpr context_as_t context_as;
} // namespace execution
#else // defined(GENERATING_DOCUMENTATION)
namespace execution {
template <typename T>
struct context_as_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename U>
static constexpr bool is_applicable_property_v = is_executor<U>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = false;
static constexpr bool is_preferable = false;
typedef T polymorphic_query_result_type;
constexpr context_as_t()
{
}
constexpr context_as_t(context_t)
{
}
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename E>
static constexpr
typename context_t::query_static_constexpr_member<E>::result_type
static_query()
noexcept(context_t::query_static_constexpr_member<E>::is_noexcept)
{
return context_t::query_static_constexpr_member<E>::value();
}
template <typename E, typename U = decltype(context_as_t::static_query<E>())>
static constexpr const U static_query_v
= context_as_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename Executor, typename U>
friend constexpr U query(
const Executor& ex, const context_as_t<U>&,
enable_if_t<
is_same<T, U>::value
>* = 0,
enable_if_t<
can_query<const Executor&, const context_t&>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(is_nothrow_query<const Executor&, const context_t&>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, const context_t&>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, context);
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T> template <typename E, typename U>
const U context_as_t<T>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
#if defined(ASIO_HAS_VARIABLE_TEMPLATES) \
|| defined(GENERATING_DOCUMENTATION)
template <typename T>
constexpr context_as_t<T> context_as{};
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
// || defined(GENERATING_DOCUMENTATION)
} // namespace execution
#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T, typename U>
struct is_applicable_property<T, execution::context_as_t<U>>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
|| !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T, typename U>
struct static_query<T, execution::context_as_t<U>,
enable_if_t<
static_query<T, execution::context_t>::is_valid
>> : static_query<T, execution::context_t>
{
};
#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
template <typename T, typename U>
struct query_free<T, execution::context_as_t<U>,
enable_if_t<
can_query<const T&, const execution::context_t&>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<const T&, const execution::context_t&>::value;
typedef U result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
} // namespace traits
#endif // defined(GENERATING_DOCUMENTATION)
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_CONTEXT_AS_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/any_executor.hpp | //
// execution/any_executor.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_ANY_EXECUTOR_HPP
#define ASIO_EXECUTION_ANY_EXECUTOR_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include <new>
#include <typeinfo>
#include "asio/detail/assert.hpp"
#include "asio/detail/atomic_count.hpp"
#include "asio/detail/cstddef.hpp"
#include "asio/detail/executor_function.hpp"
#include "asio/detail/memory.hpp"
#include "asio/detail/non_const_lvalue.hpp"
#include "asio/detail/scoped_ptr.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/detail/throw_exception.hpp"
#include "asio/execution/bad_executor.hpp"
#include "asio/execution/blocking.hpp"
#include "asio/execution/executor.hpp"
#include "asio/prefer.hpp"
#include "asio/query.hpp"
#include "asio/require.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
#if defined(GENERATING_DOCUMENTATION)
namespace execution {
/// Polymorphic executor wrapper.
template <typename... SupportableProperties>
class any_executor
{
public:
/// Default constructor.
any_executor() noexcept;
/// Construct in an empty state. Equivalent effects to default constructor.
any_executor(nullptr_t) noexcept;
/// Copy constructor.
any_executor(const any_executor& e) noexcept;
/// Move constructor.
any_executor(any_executor&& e) noexcept;
/// Construct to point to the same target as another any_executor.
template <class... OtherSupportableProperties>
any_executor(any_executor<OtherSupportableProperties...> e);
/// Construct to point to the same target as another any_executor.
template <class... OtherSupportableProperties>
any_executor(std::nothrow_t,
any_executor<OtherSupportableProperties...> e) noexcept;
/// Construct to point to the same target as another any_executor.
any_executor(std::nothrow_t, const any_executor& e) noexcept;
/// Construct to point to the same target as another any_executor.
any_executor(std::nothrow_t, any_executor&& e) noexcept;
/// Construct a polymorphic wrapper for the specified executor.
template <typename Executor>
any_executor(Executor e);
/// Construct a polymorphic wrapper for the specified executor.
template <typename Executor>
any_executor(std::nothrow_t, Executor e) noexcept;
/// Assignment operator.
any_executor& operator=(const any_executor& e) noexcept;
/// Move assignment operator.
any_executor& operator=(any_executor&& e) noexcept;
/// Assignment operator that sets the polymorphic wrapper to the empty state.
any_executor& operator=(nullptr_t);
/// Assignment operator to create a polymorphic wrapper for the specified
/// executor.
template <typename Executor>
any_executor& operator=(Executor e);
/// Destructor.
~any_executor();
/// Swap targets with another polymorphic wrapper.
void swap(any_executor& other) noexcept;
/// Obtain a polymorphic wrapper with the specified property.
/**
* Do not call this function directly. It is intended for use with the
* asio::require and asio::prefer customisation points.
*
* For example:
* @code execution::any_executor<execution::blocking_t::possibly_t> ex = ...;
* auto ex2 = asio::requre(ex, execution::blocking.possibly); @endcode
*/
template <typename Property>
any_executor require(Property) const;
/// Obtain a polymorphic wrapper with the specified property.
/**
* Do not call this function directly. It is intended for use with the
* asio::prefer customisation point.
*
* For example:
* @code execution::any_executor<execution::blocking_t::possibly_t> ex = ...;
* auto ex2 = asio::prefer(ex, execution::blocking.possibly); @endcode
*/
template <typename Property>
any_executor prefer(Property) const;
/// Obtain the value associated with the specified property.
/**
* Do not call this function directly. It is intended for use with the
* asio::query customisation point.
*
* For example:
* @code execution::any_executor<execution::occupancy_t> ex = ...;
* size_t n = asio::query(ex, execution::occupancy); @endcode
*/
template <typename Property>
typename Property::polymorphic_query_result_type query(Property) const;
/// Execute the function on the target executor.
/**
* Throws asio::bad_executor if the polymorphic wrapper has no target.
*/
template <typename Function>
void execute(Function&& f) const;
/// Obtain the underlying execution context.
/**
* This function is provided for backward compatibility. It is automatically
* defined when the @c SupportableProperties... list includes a property of
* type <tt>execution::context_as<U></tt>, for some type <tt>U</tt>.
*/
automatically_determined context() const;
/// Determine whether the wrapper has a target executor.
/**
* @returns @c true if the polymorphic wrapper has a target executor,
* otherwise false.
*/
explicit operator bool() const noexcept;
/// Get the type of the target executor.
const type_info& target_type() const noexcept;
/// Get a pointer to the target executor.
template <typename Executor> Executor* target() noexcept;
/// Get a pointer to the target executor.
template <typename Executor> const Executor* target() const noexcept;
};
/// Equality operator.
/**
* @relates any_executor
*/
template <typename... SupportableProperties>
bool operator==(const any_executor<SupportableProperties...>& a,
const any_executor<SupportableProperties...>& b) noexcept;
/// Equality operator.
/**
* @relates any_executor
*/
template <typename... SupportableProperties>
bool operator==(const any_executor<SupportableProperties...>& a,
nullptr_t) noexcept;
/// Equality operator.
/**
* @relates any_executor
*/
template <typename... SupportableProperties>
bool operator==(nullptr_t,
const any_executor<SupportableProperties...>& b) noexcept;
/// Inequality operator.
/**
* @relates any_executor
*/
template <typename... SupportableProperties>
bool operator!=(const any_executor<SupportableProperties...>& a,
const any_executor<SupportableProperties...>& b) noexcept;
/// Inequality operator.
/**
* @relates any_executor
*/
template <typename... SupportableProperties>
bool operator!=(const any_executor<SupportableProperties...>& a,
nullptr_t) noexcept;
/// Inequality operator.
/**
* @relates any_executor
*/
template <typename... SupportableProperties>
bool operator!=(nullptr_t,
const any_executor<SupportableProperties...>& b) noexcept;
} // namespace execution
#else // defined(GENERATING_DOCUMENTATION)
namespace execution {
#if !defined(ASIO_EXECUTION_ANY_EXECUTOR_FWD_DECL)
#define ASIO_EXECUTION_ANY_EXECUTOR_FWD_DECL
template <typename... SupportableProperties>
class any_executor;
#endif // !defined(ASIO_EXECUTION_ANY_EXECUTOR_FWD_DECL)
template <typename U>
struct context_as_t;
namespace detail {
// Traits used to detect whether a property is requirable or preferable, taking
// into account that T::is_requirable or T::is_preferable may not not be well
// formed.
template <typename T, typename = void>
struct is_requirable : false_type {};
template <typename T>
struct is_requirable<T, enable_if_t<T::is_requirable>> : true_type {};
template <typename T, typename = void>
struct is_preferable : false_type {};
template <typename T>
struct is_preferable<T, enable_if_t<T::is_preferable>> : true_type {};
// Trait used to detect context_as property, for backward compatibility.
template <typename T>
struct is_context_as : false_type {};
template <typename U>
struct is_context_as<context_as_t<U>> : true_type {};
// Helper template to:
// - Check if a target can supply the supportable properties.
// - Find the first convertible-from-T property in the list.
template <std::size_t I, typename Props>
struct supportable_properties;
template <std::size_t I, typename Prop>
struct supportable_properties<I, void(Prop)>
{
template <typename T>
struct is_valid_target : integral_constant<bool,
(
is_requirable<Prop>::value
? can_require<T, Prop>::value
: true
)
&&
(
is_preferable<Prop>::value
? can_prefer<T, Prop>::value
: true
)
&&
(
!is_requirable<Prop>::value && !is_preferable<Prop>::value
? can_query<T, Prop>::value
: true
)
>
{
};
struct found
{
static constexpr bool value = true;
typedef Prop type;
typedef typename Prop::polymorphic_query_result_type query_result_type;
static constexpr std::size_t index = I;
};
struct not_found
{
static constexpr bool value = false;
};
template <typename T>
struct find_convertible_property :
conditional_t<
is_same<T, Prop>::value || is_convertible<T, Prop>::value,
found,
not_found
> {};
template <typename T>
struct find_convertible_requirable_property :
conditional_t<
is_requirable<Prop>::value
&& (is_same<T, Prop>::value || is_convertible<T, Prop>::value),
found,
not_found
> {};
template <typename T>
struct find_convertible_preferable_property :
conditional_t<
is_preferable<Prop>::value
&& (is_same<T, Prop>::value || is_convertible<T, Prop>::value),
found,
not_found
> {};
struct find_context_as_property :
conditional_t<
is_context_as<Prop>::value,
found,
not_found
> {};
};
template <std::size_t I, typename Head, typename... Tail>
struct supportable_properties<I, void(Head, Tail...)>
{
template <typename T>
struct is_valid_target : integral_constant<bool,
(
supportable_properties<I,
void(Head)>::template is_valid_target<T>::value
&&
supportable_properties<I + 1,
void(Tail...)>::template is_valid_target<T>::value
)
>
{
};
template <typename T>
struct find_convertible_property :
conditional_t<
is_convertible<T, Head>::value,
typename supportable_properties<I, void(Head)>::found,
typename supportable_properties<I + 1,
void(Tail...)>::template find_convertible_property<T>
> {};
template <typename T>
struct find_convertible_requirable_property :
conditional_t<
is_requirable<Head>::value
&& is_convertible<T, Head>::value,
typename supportable_properties<I, void(Head)>::found,
typename supportable_properties<I + 1,
void(Tail...)>::template find_convertible_requirable_property<T>
> {};
template <typename T>
struct find_convertible_preferable_property :
conditional_t<
is_preferable<Head>::value
&& is_convertible<T, Head>::value,
typename supportable_properties<I, void(Head)>::found,
typename supportable_properties<I + 1,
void(Tail...)>::template find_convertible_preferable_property<T>
> {};
struct find_context_as_property :
conditional_t<
is_context_as<Head>::value,
typename supportable_properties<I, void(Head)>::found,
typename supportable_properties<I + 1,
void(Tail...)>::find_context_as_property
> {};
};
template <typename T, typename Props>
struct is_valid_target_executor :
conditional_t<
is_executor<T>::value,
typename supportable_properties<0, Props>::template is_valid_target<T>,
false_type
>
{
};
template <typename Props>
struct is_valid_target_executor<int, Props> : false_type
{
};
class shared_target_executor
{
public:
template <typename E>
shared_target_executor(E&& e, decay_t<E>*& target)
{
impl<decay_t<E>>* i =
new impl<decay_t<E>>(static_cast<E&&>(e));
target = &i->ex_;
impl_ = i;
}
template <typename E>
shared_target_executor(std::nothrow_t, E&& e, decay_t<E>*& target) noexcept
{
impl<decay_t<E>>* i =
new (std::nothrow) impl<decay_t<E>>(static_cast<E&&>(e));
target = i ? &i->ex_ : 0;
impl_ = i;
}
shared_target_executor(const shared_target_executor& other) noexcept
: impl_(other.impl_)
{
if (impl_)
asio::detail::ref_count_up(impl_->ref_count_);
}
shared_target_executor(shared_target_executor&& other) noexcept
: impl_(other.impl_)
{
other.impl_ = 0;
}
~shared_target_executor()
{
if (impl_)
if (asio::detail::ref_count_down(impl_->ref_count_))
delete impl_;
}
void* get() const noexcept
{
return impl_ ? impl_->get() : 0;
}
private:
shared_target_executor& operator=(
const shared_target_executor& other) = delete;
shared_target_executor& operator=(
shared_target_executor&& other) = delete;
struct impl_base
{
impl_base() : ref_count_(1) {}
virtual ~impl_base() {}
virtual void* get() = 0;
asio::detail::atomic_count ref_count_;
};
template <typename Executor>
struct impl : impl_base
{
impl(Executor ex) : ex_(static_cast<Executor&&>(ex)) {}
virtual void* get() { return &ex_; }
Executor ex_;
};
impl_base* impl_;
};
class any_executor_base
{
public:
any_executor_base() noexcept
: object_fns_(0),
target_(0),
target_fns_(0)
{
}
template <ASIO_EXECUTION_EXECUTOR Executor>
any_executor_base(Executor ex, false_type)
: target_fns_(target_fns_table<Executor>(
any_executor_base::query_blocking(ex,
can_query<const Executor&, const execution::blocking_t&>())
== execution::blocking.always))
{
any_executor_base::construct_object(ex,
integral_constant<bool,
sizeof(Executor) <= sizeof(object_type)
&& alignment_of<Executor>::value <= alignment_of<object_type>::value
>());
}
template <ASIO_EXECUTION_EXECUTOR Executor>
any_executor_base(std::nothrow_t, Executor ex, false_type) noexcept
: target_fns_(target_fns_table<Executor>(
any_executor_base::query_blocking(ex,
can_query<const Executor&, const execution::blocking_t&>())
== execution::blocking.always))
{
any_executor_base::construct_object(std::nothrow, ex,
integral_constant<bool,
sizeof(Executor) <= sizeof(object_type)
&& alignment_of<Executor>::value <= alignment_of<object_type>::value
>());
if (target_ == 0)
{
object_fns_ = 0;
target_fns_ = 0;
}
}
template <ASIO_EXECUTION_EXECUTOR Executor>
any_executor_base(Executor other, true_type)
: object_fns_(object_fns_table<shared_target_executor>()),
target_fns_(other.target_fns_)
{
Executor* p = 0;
new (&object_) shared_target_executor(
static_cast<Executor&&>(other), p);
target_ = p->template target<void>();
}
template <ASIO_EXECUTION_EXECUTOR Executor>
any_executor_base(std::nothrow_t,
Executor other, true_type) noexcept
: object_fns_(object_fns_table<shared_target_executor>()),
target_fns_(other.target_fns_)
{
Executor* p = 0;
new (&object_) shared_target_executor(
std::nothrow, static_cast<Executor&&>(other), p);
if (p)
target_ = p->template target<void>();
else
{
target_ = 0;
object_fns_ = 0;
target_fns_ = 0;
}
}
any_executor_base(const any_executor_base& other) noexcept
{
if (!!other)
{
object_fns_ = other.object_fns_;
target_fns_ = other.target_fns_;
object_fns_->copy(*this, other);
}
else
{
object_fns_ = 0;
target_ = 0;
target_fns_ = 0;
}
}
~any_executor_base() noexcept
{
if (!!*this)
object_fns_->destroy(*this);
}
any_executor_base& operator=(
const any_executor_base& other) noexcept
{
if (this != &other)
{
if (!!*this)
object_fns_->destroy(*this);
if (!!other)
{
object_fns_ = other.object_fns_;
target_fns_ = other.target_fns_;
object_fns_->copy(*this, other);
}
else
{
object_fns_ = 0;
target_ = 0;
target_fns_ = 0;
}
}
return *this;
}
any_executor_base& operator=(nullptr_t) noexcept
{
if (target_)
object_fns_->destroy(*this);
target_ = 0;
object_fns_ = 0;
target_fns_ = 0;
return *this;
}
any_executor_base(any_executor_base&& other) noexcept
{
if (other.target_)
{
object_fns_ = other.object_fns_;
target_fns_ = other.target_fns_;
other.object_fns_ = 0;
other.target_fns_ = 0;
object_fns_->move(*this, other);
other.target_ = 0;
}
else
{
object_fns_ = 0;
target_ = 0;
target_fns_ = 0;
}
}
any_executor_base& operator=(
any_executor_base&& other) noexcept
{
if (this != &other)
{
if (!!*this)
object_fns_->destroy(*this);
if (!!other)
{
object_fns_ = other.object_fns_;
target_fns_ = other.target_fns_;
other.object_fns_ = 0;
other.target_fns_ = 0;
object_fns_->move(*this, other);
other.target_ = 0;
}
else
{
object_fns_ = 0;
target_ = 0;
target_fns_ = 0;
}
}
return *this;
}
void swap(any_executor_base& other) noexcept
{
if (this != &other)
{
any_executor_base tmp(static_cast<any_executor_base&&>(other));
other = static_cast<any_executor_base&&>(*this);
*this = static_cast<any_executor_base&&>(tmp);
}
}
template <typename F>
void execute(F&& f) const
{
if (target_)
{
if (target_fns_->blocking_execute != 0)
{
asio::detail::non_const_lvalue<F> f2(f);
target_fns_->blocking_execute(*this, function_view(f2.value));
}
else
{
target_fns_->execute(*this,
function(static_cast<F&&>(f), std::allocator<void>()));
}
}
else
{
bad_executor ex;
asio::detail::throw_exception(ex);
}
}
template <typename Executor>
Executor* target()
{
return target_ && (is_same<Executor, void>::value
|| target_fns_->target_type() == target_type_ex<Executor>())
? static_cast<Executor*>(target_) : 0;
}
template <typename Executor>
const Executor* target() const
{
return target_ && (is_same<Executor, void>::value
|| target_fns_->target_type() == target_type_ex<Executor>())
? static_cast<const Executor*>(target_) : 0;
}
#if !defined(ASIO_NO_TYPEID)
const std::type_info& target_type() const
{
return target_ ? target_fns_->target_type() : typeid(void);
}
#else // !defined(ASIO_NO_TYPEID)
const void* target_type() const
{
return target_ ? target_fns_->target_type() : 0;
}
#endif // !defined(ASIO_NO_TYPEID)
struct unspecified_bool_type_t {};
typedef void (*unspecified_bool_type)(unspecified_bool_type_t);
static void unspecified_bool_true(unspecified_bool_type_t) {}
operator unspecified_bool_type() const noexcept
{
return target_ ? &any_executor_base::unspecified_bool_true : 0;
}
bool operator!() const noexcept
{
return target_ == 0;
}
protected:
bool equality_helper(const any_executor_base& other) const noexcept
{
if (target_ == other.target_)
return true;
if (target_ && !other.target_)
return false;
if (!target_ && other.target_)
return false;
if (target_fns_ != other.target_fns_)
return false;
return target_fns_->equal(*this, other);
}
template <typename Ex>
Ex& object()
{
return *static_cast<Ex*>(static_cast<void*>(&object_));
}
template <typename Ex>
const Ex& object() const
{
return *static_cast<const Ex*>(static_cast<const void*>(&object_));
}
struct object_fns
{
void (*destroy)(any_executor_base&);
void (*copy)(any_executor_base&, const any_executor_base&);
void (*move)(any_executor_base&, any_executor_base&);
const void* (*target)(const any_executor_base&);
};
static void destroy_shared(any_executor_base& ex)
{
typedef shared_target_executor type;
ex.object<type>().~type();
}
static void copy_shared(any_executor_base& ex1, const any_executor_base& ex2)
{
typedef shared_target_executor type;
new (&ex1.object_) type(ex2.object<type>());
ex1.target_ = ex2.target_;
}
static void move_shared(any_executor_base& ex1, any_executor_base& ex2)
{
typedef shared_target_executor type;
new (&ex1.object_) type(static_cast<type&&>(ex2.object<type>()));
ex1.target_ = ex2.target_;
ex2.object<type>().~type();
}
static const void* target_shared(const any_executor_base& ex)
{
typedef shared_target_executor type;
return ex.object<type>().get();
}
template <typename Obj>
static const object_fns* object_fns_table(
enable_if_t<
is_same<Obj, shared_target_executor>::value
>* = 0)
{
static const object_fns fns =
{
&any_executor_base::destroy_shared,
&any_executor_base::copy_shared,
&any_executor_base::move_shared,
&any_executor_base::target_shared
};
return &fns;
}
template <typename Obj>
static void destroy_object(any_executor_base& ex)
{
ex.object<Obj>().~Obj();
}
template <typename Obj>
static void copy_object(any_executor_base& ex1, const any_executor_base& ex2)
{
new (&ex1.object_) Obj(ex2.object<Obj>());
ex1.target_ = &ex1.object<Obj>();
}
template <typename Obj>
static void move_object(any_executor_base& ex1, any_executor_base& ex2)
{
new (&ex1.object_) Obj(static_cast<Obj&&>(ex2.object<Obj>()));
ex1.target_ = &ex1.object<Obj>();
ex2.object<Obj>().~Obj();
}
template <typename Obj>
static const void* target_object(const any_executor_base& ex)
{
return &ex.object<Obj>();
}
template <typename Obj>
static const object_fns* object_fns_table(
enable_if_t<
!is_same<Obj, void>::value
&& !is_same<Obj, shared_target_executor>::value
>* = 0)
{
static const object_fns fns =
{
&any_executor_base::destroy_object<Obj>,
&any_executor_base::copy_object<Obj>,
&any_executor_base::move_object<Obj>,
&any_executor_base::target_object<Obj>
};
return &fns;
}
typedef asio::detail::executor_function function;
typedef asio::detail::executor_function_view function_view;
struct target_fns
{
#if !defined(ASIO_NO_TYPEID)
const std::type_info& (*target_type)();
#else // !defined(ASIO_NO_TYPEID)
const void* (*target_type)();
#endif // !defined(ASIO_NO_TYPEID)
bool (*equal)(const any_executor_base&, const any_executor_base&);
void (*execute)(const any_executor_base&, function&&);
void (*blocking_execute)(const any_executor_base&, function_view);
};
#if !defined(ASIO_NO_TYPEID)
template <typename Ex>
static const std::type_info& target_type_ex()
{
return typeid(Ex);
}
#else // !defined(ASIO_NO_TYPEID)
template <typename Ex>
static const void* target_type_ex()
{
static int unique_id;
return &unique_id;
}
#endif // !defined(ASIO_NO_TYPEID)
template <typename Ex>
static bool equal_ex(const any_executor_base& ex1,
const any_executor_base& ex2)
{
const Ex* p1 = ex1.target<Ex>();
const Ex* p2 = ex2.target<Ex>();
ASIO_ASSUME(p1 != 0 && p2 != 0);
return *p1 == *p2;
}
template <typename Ex>
static void execute_ex(const any_executor_base& ex, function&& f)
{
const Ex* p = ex.target<Ex>();
ASIO_ASSUME(p != 0);
p->execute(static_cast<function&&>(f));
}
template <typename Ex>
static void blocking_execute_ex(const any_executor_base& ex, function_view f)
{
const Ex* p = ex.target<Ex>();
ASIO_ASSUME(p != 0);
p->execute(f);
}
template <typename Ex>
static const target_fns* target_fns_table(bool is_always_blocking,
enable_if_t<
!is_same<Ex, void>::value
>* = 0)
{
static const target_fns fns_with_execute =
{
&any_executor_base::target_type_ex<Ex>,
&any_executor_base::equal_ex<Ex>,
&any_executor_base::execute_ex<Ex>,
0
};
static const target_fns fns_with_blocking_execute =
{
&any_executor_base::target_type_ex<Ex>,
&any_executor_base::equal_ex<Ex>,
0,
&any_executor_base::blocking_execute_ex<Ex>
};
return is_always_blocking ? &fns_with_blocking_execute : &fns_with_execute;
}
#if defined(ASIO_MSVC)
# pragma warning (push)
# pragma warning (disable:4702)
#endif // defined(ASIO_MSVC)
static void query_fn_void(void*, const void*, const void*)
{
bad_executor ex;
asio::detail::throw_exception(ex);
}
template <typename Ex, class Prop>
static void query_fn_non_void(void*, const void* ex, const void* prop,
enable_if_t<
asio::can_query<const Ex&, const Prop&>::value
&& is_same<typename Prop::polymorphic_query_result_type, void>::value
>*)
{
asio::query(*static_cast<const Ex*>(ex),
*static_cast<const Prop*>(prop));
}
template <typename Ex, class Prop>
static void query_fn_non_void(void*, const void*, const void*,
enable_if_t<
!asio::can_query<const Ex&, const Prop&>::value
&& is_same<typename Prop::polymorphic_query_result_type, void>::value
>*)
{
}
template <typename Ex, class Prop>
static void query_fn_non_void(void* result, const void* ex, const void* prop,
enable_if_t<
asio::can_query<const Ex&, const Prop&>::value
&& !is_same<typename Prop::polymorphic_query_result_type, void>::value
&& is_reference<typename Prop::polymorphic_query_result_type>::value
>*)
{
*static_cast<remove_reference_t<
typename Prop::polymorphic_query_result_type>**>(result)
= &static_cast<typename Prop::polymorphic_query_result_type>(
asio::query(*static_cast<const Ex*>(ex),
*static_cast<const Prop*>(prop)));
}
template <typename Ex, class Prop>
static void query_fn_non_void(void*, const void*, const void*,
enable_if_t<
!asio::can_query<const Ex&, const Prop&>::value
&& !is_same<typename Prop::polymorphic_query_result_type, void>::value
&& is_reference<typename Prop::polymorphic_query_result_type>::value
>*)
{
std::terminate(); // Combination should not be possible.
}
template <typename Ex, class Prop>
static void query_fn_non_void(void* result, const void* ex, const void* prop,
enable_if_t<
asio::can_query<const Ex&, const Prop&>::value
&& !is_same<typename Prop::polymorphic_query_result_type, void>::value
&& is_scalar<typename Prop::polymorphic_query_result_type>::value
>*)
{
*static_cast<typename Prop::polymorphic_query_result_type*>(result)
= static_cast<typename Prop::polymorphic_query_result_type>(
asio::query(*static_cast<const Ex*>(ex),
*static_cast<const Prop*>(prop)));
}
template <typename Ex, class Prop>
static void query_fn_non_void(void* result, const void*, const void*,
enable_if_t<
!asio::can_query<const Ex&, const Prop&>::value
&& !is_same<typename Prop::polymorphic_query_result_type, void>::value
&& is_scalar<typename Prop::polymorphic_query_result_type>::value
>*)
{
*static_cast<typename Prop::polymorphic_query_result_type*>(result)
= typename Prop::polymorphic_query_result_type();
}
template <typename Ex, class Prop>
static void query_fn_non_void(void* result, const void* ex, const void* prop,
enable_if_t<
asio::can_query<const Ex&, const Prop&>::value
&& !is_same<typename Prop::polymorphic_query_result_type, void>::value
&& !is_reference<typename Prop::polymorphic_query_result_type>::value
&& !is_scalar<typename Prop::polymorphic_query_result_type>::value
>*)
{
*static_cast<typename Prop::polymorphic_query_result_type**>(result)
= new typename Prop::polymorphic_query_result_type(
asio::query(*static_cast<const Ex*>(ex),
*static_cast<const Prop*>(prop)));
}
template <typename Ex, class Prop>
static void query_fn_non_void(void* result, const void*, const void*, ...)
{
*static_cast<typename Prop::polymorphic_query_result_type**>(result)
= new typename Prop::polymorphic_query_result_type();
}
template <typename Ex, class Prop>
static void query_fn_impl(void* result, const void* ex, const void* prop,
enable_if_t<
is_same<Ex, void>::value
>*)
{
query_fn_void(result, ex, prop);
}
template <typename Ex, class Prop>
static void query_fn_impl(void* result, const void* ex, const void* prop,
enable_if_t<
!is_same<Ex, void>::value
>*)
{
query_fn_non_void<Ex, Prop>(result, ex, prop, 0);
}
template <typename Ex, class Prop>
static void query_fn(void* result, const void* ex, const void* prop)
{
query_fn_impl<Ex, Prop>(result, ex, prop, 0);
}
template <typename Poly, typename Ex, class Prop>
static Poly require_fn_impl(const void*, const void*,
enable_if_t<
is_same<Ex, void>::value
>*)
{
bad_executor ex;
asio::detail::throw_exception(ex);
return Poly();
}
template <typename Poly, typename Ex, class Prop>
static Poly require_fn_impl(const void* ex, const void* prop,
enable_if_t<
!is_same<Ex, void>::value && Prop::is_requirable
>*)
{
return asio::require(*static_cast<const Ex*>(ex),
*static_cast<const Prop*>(prop));
}
template <typename Poly, typename Ex, class Prop>
static Poly require_fn_impl(const void*, const void*, ...)
{
return Poly();
}
template <typename Poly, typename Ex, class Prop>
static Poly require_fn(const void* ex, const void* prop)
{
return require_fn_impl<Poly, Ex, Prop>(ex, prop, 0);
}
template <typename Poly, typename Ex, class Prop>
static Poly prefer_fn_impl(const void*, const void*,
enable_if_t<
is_same<Ex, void>::value
>*)
{
bad_executor ex;
asio::detail::throw_exception(ex);
return Poly();
}
template <typename Poly, typename Ex, class Prop>
static Poly prefer_fn_impl(const void* ex, const void* prop,
enable_if_t<
!is_same<Ex, void>::value && Prop::is_preferable
>*)
{
return asio::prefer(*static_cast<const Ex*>(ex),
*static_cast<const Prop*>(prop));
}
template <typename Poly, typename Ex, class Prop>
static Poly prefer_fn_impl(const void*, const void*, ...)
{
return Poly();
}
template <typename Poly, typename Ex, class Prop>
static Poly prefer_fn(const void* ex, const void* prop)
{
return prefer_fn_impl<Poly, Ex, Prop>(ex, prop, 0);
}
template <typename Poly>
struct prop_fns
{
void (*query)(void*, const void*, const void*);
Poly (*require)(const void*, const void*);
Poly (*prefer)(const void*, const void*);
};
#if defined(ASIO_MSVC)
# pragma warning (pop)
#endif // defined(ASIO_MSVC)
private:
template <typename Executor>
static execution::blocking_t query_blocking(const Executor& ex, true_type)
{
return asio::query(ex, execution::blocking);
}
template <typename Executor>
static execution::blocking_t query_blocking(const Executor&, false_type)
{
return execution::blocking_t();
}
template <typename Executor>
void construct_object(Executor& ex, true_type)
{
object_fns_ = object_fns_table<Executor>();
target_ = new (&object_) Executor(static_cast<Executor&&>(ex));
}
template <typename Executor>
void construct_object(Executor& ex, false_type)
{
object_fns_ = object_fns_table<shared_target_executor>();
Executor* p = 0;
new (&object_) shared_target_executor(
static_cast<Executor&&>(ex), p);
target_ = p;
}
template <typename Executor>
void construct_object(std::nothrow_t,
Executor& ex, true_type) noexcept
{
object_fns_ = object_fns_table<Executor>();
target_ = new (&object_) Executor(static_cast<Executor&&>(ex));
}
template <typename Executor>
void construct_object(std::nothrow_t,
Executor& ex, false_type) noexcept
{
object_fns_ = object_fns_table<shared_target_executor>();
Executor* p = 0;
new (&object_) shared_target_executor(
std::nothrow, static_cast<Executor&&>(ex), p);
target_ = p;
}
/*private:*/public:
// template <typename...> friend class any_executor;
typedef aligned_storage<
sizeof(asio::detail::shared_ptr<void>) + sizeof(void*),
alignment_of<asio::detail::shared_ptr<void>>::value
>::type object_type;
object_type object_;
const object_fns* object_fns_;
void* target_;
const target_fns* target_fns_;
};
template <typename Derived, typename Property, typename = void>
struct any_executor_context
{
};
#if !defined(ASIO_NO_TS_EXECUTORS)
template <typename Derived, typename Property>
struct any_executor_context<Derived, Property, enable_if_t<Property::value>>
{
typename Property::query_result_type context() const
{
return static_cast<const Derived*>(this)->query(typename Property::type());
}
};
#endif // !defined(ASIO_NO_TS_EXECUTORS)
} // namespace detail
template <>
class any_executor<> : public detail::any_executor_base
{
public:
any_executor() noexcept
: detail::any_executor_base()
{
}
any_executor(nullptr_t) noexcept
: detail::any_executor_base()
{
}
template <typename Executor>
any_executor(Executor ex,
enable_if_t<
conditional_t<
!is_same<Executor, any_executor>::value
&& !is_base_of<detail::any_executor_base, Executor>::value,
is_executor<Executor>,
false_type
>::value
>* = 0)
: detail::any_executor_base(
static_cast<Executor&&>(ex), false_type())
{
}
template <typename Executor>
any_executor(std::nothrow_t, Executor ex,
enable_if_t<
conditional_t<
!is_same<Executor, any_executor>::value
&& !is_base_of<detail::any_executor_base, Executor>::value,
is_executor<Executor>,
false_type
>::value
>* = 0) noexcept
: detail::any_executor_base(std::nothrow,
static_cast<Executor&&>(ex), false_type())
{
}
template <typename... OtherSupportableProperties>
any_executor(any_executor<OtherSupportableProperties...> other)
: detail::any_executor_base(
static_cast<const detail::any_executor_base&>(other))
{
}
template <typename... OtherSupportableProperties>
any_executor(std::nothrow_t,
any_executor<OtherSupportableProperties...> other) noexcept
: detail::any_executor_base(
static_cast<const detail::any_executor_base&>(other))
{
}
any_executor(const any_executor& other) noexcept
: detail::any_executor_base(
static_cast<const detail::any_executor_base&>(other))
{
}
any_executor(std::nothrow_t, const any_executor& other) noexcept
: detail::any_executor_base(
static_cast<const detail::any_executor_base&>(other))
{
}
any_executor& operator=(const any_executor& other) noexcept
{
if (this != &other)
{
detail::any_executor_base::operator=(
static_cast<const detail::any_executor_base&>(other));
}
return *this;
}
any_executor& operator=(nullptr_t p) noexcept
{
detail::any_executor_base::operator=(p);
return *this;
}
any_executor(any_executor&& other) noexcept
: detail::any_executor_base(
static_cast<any_executor_base&&>(
static_cast<any_executor_base&>(other)))
{
}
any_executor(std::nothrow_t, any_executor&& other) noexcept
: detail::any_executor_base(
static_cast<any_executor_base&&>(
static_cast<any_executor_base&>(other)))
{
}
any_executor& operator=(any_executor&& other) noexcept
{
if (this != &other)
{
detail::any_executor_base::operator=(
static_cast<detail::any_executor_base&&>(
static_cast<detail::any_executor_base&>(other)));
}
return *this;
}
void swap(any_executor& other) noexcept
{
detail::any_executor_base::swap(
static_cast<detail::any_executor_base&>(other));
}
using detail::any_executor_base::execute;
using detail::any_executor_base::target;
using detail::any_executor_base::target_type;
using detail::any_executor_base::operator unspecified_bool_type;
using detail::any_executor_base::operator!;
bool equality_helper(const any_executor& other) const noexcept
{
return any_executor_base::equality_helper(other);
}
template <typename AnyExecutor1, typename AnyExecutor2>
friend enable_if_t<
is_base_of<any_executor, AnyExecutor1>::value
|| is_base_of<any_executor, AnyExecutor2>::value,
bool
> operator==(const AnyExecutor1& a,
const AnyExecutor2& b) noexcept
{
return static_cast<const any_executor&>(a).equality_helper(b);
}
template <typename AnyExecutor>
friend enable_if_t<
is_same<AnyExecutor, any_executor>::value,
bool
> operator==(const AnyExecutor& a, nullptr_t) noexcept
{
return !a;
}
template <typename AnyExecutor>
friend enable_if_t<
is_same<AnyExecutor, any_executor>::value,
bool
> operator==(nullptr_t, const AnyExecutor& b) noexcept
{
return !b;
}
template <typename AnyExecutor1, typename AnyExecutor2>
friend enable_if_t<
is_base_of<any_executor, AnyExecutor1>::value
|| is_base_of<any_executor, AnyExecutor2>::value,
bool
> operator!=(const AnyExecutor1& a,
const AnyExecutor2& b) noexcept
{
return !static_cast<const any_executor&>(a).equality_helper(b);
}
template <typename AnyExecutor>
friend enable_if_t<
is_same<AnyExecutor, any_executor>::value,
bool
> operator!=(const AnyExecutor& a, nullptr_t) noexcept
{
return !!a;
}
template <typename AnyExecutor>
friend enable_if_t<
is_same<AnyExecutor, any_executor>::value,
bool
> operator!=(nullptr_t, const AnyExecutor& b) noexcept
{
return !!b;
}
};
inline void swap(any_executor<>& a, any_executor<>& b) noexcept
{
return a.swap(b);
}
template <typename... SupportableProperties>
class any_executor :
public detail::any_executor_base,
public detail::any_executor_context<
any_executor<SupportableProperties...>,
typename detail::supportable_properties<
0, void(SupportableProperties...)>::find_context_as_property>
{
public:
any_executor() noexcept
: detail::any_executor_base(),
prop_fns_(prop_fns_table<void>())
{
}
any_executor(nullptr_t) noexcept
: detail::any_executor_base(),
prop_fns_(prop_fns_table<void>())
{
}
template <typename Executor>
any_executor(Executor ex,
enable_if_t<
conditional_t<
!is_same<Executor, any_executor>::value
&& !is_base_of<detail::any_executor_base, Executor>::value,
detail::is_valid_target_executor<
Executor, void(SupportableProperties...)>,
false_type
>::value
>* = 0)
: detail::any_executor_base(
static_cast<Executor&&>(ex), false_type()),
prop_fns_(prop_fns_table<Executor>())
{
}
template <typename Executor>
any_executor(std::nothrow_t, Executor ex,
enable_if_t<
conditional_t<
!is_same<Executor, any_executor>::value
&& !is_base_of<detail::any_executor_base, Executor>::value,
detail::is_valid_target_executor<
Executor, void(SupportableProperties...)>,
false_type
>::value
>* = 0) noexcept
: detail::any_executor_base(std::nothrow,
static_cast<Executor&&>(ex), false_type()),
prop_fns_(prop_fns_table<Executor>())
{
if (this->template target<void>() == 0)
prop_fns_ = prop_fns_table<void>();
}
template <typename... OtherSupportableProperties>
any_executor(any_executor<OtherSupportableProperties...> other,
enable_if_t<
conditional_t<
!is_same<
any_executor<OtherSupportableProperties...>,
any_executor
>::value,
typename detail::supportable_properties<
0, void(SupportableProperties...)>::template is_valid_target<
any_executor<OtherSupportableProperties...>>,
false_type
>::value
>* = 0)
: detail::any_executor_base(
static_cast<any_executor<OtherSupportableProperties...>&&>(other),
true_type()),
prop_fns_(prop_fns_table<any_executor<OtherSupportableProperties...>>())
{
}
template <typename... OtherSupportableProperties>
any_executor(std::nothrow_t,
any_executor<OtherSupportableProperties...> other,
enable_if_t<
conditional_t<
!is_same<
any_executor<OtherSupportableProperties...>,
any_executor
>::value,
typename detail::supportable_properties<
0, void(SupportableProperties...)>::template is_valid_target<
any_executor<OtherSupportableProperties...>>,
false_type
>::value
>* = 0) noexcept
: detail::any_executor_base(std::nothrow,
static_cast<any_executor<OtherSupportableProperties...>&&>(other),
true_type()),
prop_fns_(prop_fns_table<any_executor<OtherSupportableProperties...>>())
{
if (this->template target<void>() == 0)
prop_fns_ = prop_fns_table<void>();
}
any_executor(const any_executor& other) noexcept
: detail::any_executor_base(
static_cast<const detail::any_executor_base&>(other)),
prop_fns_(other.prop_fns_)
{
}
any_executor(std::nothrow_t, const any_executor& other) noexcept
: detail::any_executor_base(
static_cast<const detail::any_executor_base&>(other)),
prop_fns_(other.prop_fns_)
{
}
any_executor& operator=(const any_executor& other) noexcept
{
if (this != &other)
{
prop_fns_ = other.prop_fns_;
detail::any_executor_base::operator=(
static_cast<const detail::any_executor_base&>(other));
}
return *this;
}
any_executor& operator=(nullptr_t p) noexcept
{
prop_fns_ = prop_fns_table<void>();
detail::any_executor_base::operator=(p);
return *this;
}
any_executor(any_executor&& other) noexcept
: detail::any_executor_base(
static_cast<any_executor_base&&>(
static_cast<any_executor_base&>(other))),
prop_fns_(other.prop_fns_)
{
other.prop_fns_ = prop_fns_table<void>();
}
any_executor(std::nothrow_t, any_executor&& other) noexcept
: detail::any_executor_base(
static_cast<any_executor_base&&>(
static_cast<any_executor_base&>(other))),
prop_fns_(other.prop_fns_)
{
other.prop_fns_ = prop_fns_table<void>();
}
any_executor& operator=(any_executor&& other) noexcept
{
if (this != &other)
{
prop_fns_ = other.prop_fns_;
detail::any_executor_base::operator=(
static_cast<detail::any_executor_base&&>(
static_cast<detail::any_executor_base&>(other)));
}
return *this;
}
void swap(any_executor& other) noexcept
{
if (this != &other)
{
detail::any_executor_base::swap(
static_cast<detail::any_executor_base&>(other));
const prop_fns<any_executor>* tmp_prop_fns = other.prop_fns_;
other.prop_fns_ = prop_fns_;
prop_fns_ = tmp_prop_fns;
}
}
using detail::any_executor_base::execute;
using detail::any_executor_base::target;
using detail::any_executor_base::target_type;
using detail::any_executor_base::operator unspecified_bool_type;
using detail::any_executor_base::operator!;
bool equality_helper(const any_executor& other) const noexcept
{
return any_executor_base::equality_helper(other);
}
template <typename AnyExecutor1, typename AnyExecutor2>
friend enable_if_t<
is_base_of<any_executor, AnyExecutor1>::value
|| is_base_of<any_executor, AnyExecutor2>::value,
bool
> operator==(const AnyExecutor1& a,
const AnyExecutor2& b) noexcept
{
return static_cast<const any_executor&>(a).equality_helper(b);
}
template <typename AnyExecutor>
friend enable_if_t<
is_same<AnyExecutor, any_executor>::value,
bool
> operator==(const AnyExecutor& a, nullptr_t) noexcept
{
return !a;
}
template <typename AnyExecutor>
friend enable_if_t<
is_same<AnyExecutor, any_executor>::value,
bool
> operator==(nullptr_t, const AnyExecutor& b) noexcept
{
return !b;
}
template <typename AnyExecutor1, typename AnyExecutor2>
friend enable_if_t<
is_base_of<any_executor, AnyExecutor1>::value
|| is_base_of<any_executor, AnyExecutor2>::value,
bool
> operator!=(const AnyExecutor1& a,
const AnyExecutor2& b) noexcept
{
return !static_cast<const any_executor&>(a).equality_helper(b);
}
template <typename AnyExecutor>
friend enable_if_t<
is_same<AnyExecutor, any_executor>::value,
bool
> operator!=(const AnyExecutor& a, nullptr_t) noexcept
{
return !!a;
}
template <typename AnyExecutor>
friend enable_if_t<
is_same<AnyExecutor, any_executor>::value,
bool
> operator!=(nullptr_t, const AnyExecutor& b) noexcept
{
return !!b;
}
template <typename T>
struct find_convertible_property :
detail::supportable_properties<
0, void(SupportableProperties...)>::template
find_convertible_property<T> {};
template <typename Property>
void query(const Property& p,
enable_if_t<
is_same<
typename find_convertible_property<Property>::query_result_type,
void
>::value
>* = 0) const
{
if (!target_)
{
bad_executor ex;
asio::detail::throw_exception(ex);
}
typedef find_convertible_property<Property> found;
prop_fns_[found::index].query(0, object_fns_->target(*this),
&static_cast<const typename found::type&>(p));
}
template <typename Property>
typename find_convertible_property<Property>::query_result_type
query(const Property& p,
enable_if_t<
!is_same<
typename find_convertible_property<Property>::query_result_type,
void
>::value
&&
is_reference<
typename find_convertible_property<Property>::query_result_type
>::value
>* = 0) const
{
if (!target_)
{
bad_executor ex;
asio::detail::throw_exception(ex);
}
typedef find_convertible_property<Property> found;
remove_reference_t<typename found::query_result_type>* result = 0;
prop_fns_[found::index].query(&result, object_fns_->target(*this),
&static_cast<const typename found::type&>(p));
return *result;
}
template <typename Property>
typename find_convertible_property<Property>::query_result_type
query(const Property& p,
enable_if_t<
!is_same<
typename find_convertible_property<Property>::query_result_type,
void
>::value
&&
is_scalar<
typename find_convertible_property<Property>::query_result_type
>::value
>* = 0) const
{
if (!target_)
{
bad_executor ex;
asio::detail::throw_exception(ex);
}
typedef find_convertible_property<Property> found;
typename found::query_result_type result;
prop_fns_[found::index].query(&result, object_fns_->target(*this),
&static_cast<const typename found::type&>(p));
return result;
}
template <typename Property>
typename find_convertible_property<Property>::query_result_type
query(const Property& p,
enable_if_t<
!is_same<
typename find_convertible_property<Property>::query_result_type,
void
>::value
&&
!is_reference<
typename find_convertible_property<Property>::query_result_type
>::value
&&
!is_scalar<
typename find_convertible_property<Property>::query_result_type
>::value
>* = 0) const
{
if (!target_)
{
bad_executor ex;
asio::detail::throw_exception(ex);
}
typedef find_convertible_property<Property> found;
typename found::query_result_type* result;
prop_fns_[found::index].query(&result, object_fns_->target(*this),
&static_cast<const typename found::type&>(p));
return *asio::detail::scoped_ptr<
typename found::query_result_type>(result);
}
template <typename T>
struct find_convertible_requirable_property :
detail::supportable_properties<
0, void(SupportableProperties...)>::template
find_convertible_requirable_property<T> {};
template <typename Property>
any_executor require(const Property& p,
enable_if_t<
find_convertible_requirable_property<Property>::value
>* = 0) const
{
if (!target_)
{
bad_executor ex;
asio::detail::throw_exception(ex);
}
typedef find_convertible_requirable_property<Property> found;
return prop_fns_[found::index].require(object_fns_->target(*this),
&static_cast<const typename found::type&>(p));
}
template <typename T>
struct find_convertible_preferable_property :
detail::supportable_properties<
0, void(SupportableProperties...)>::template
find_convertible_preferable_property<T> {};
template <typename Property>
any_executor prefer(const Property& p,
enable_if_t<
find_convertible_preferable_property<Property>::value
>* = 0) const
{
if (!target_)
{
bad_executor ex;
asio::detail::throw_exception(ex);
}
typedef find_convertible_preferable_property<Property> found;
return prop_fns_[found::index].prefer(object_fns_->target(*this),
&static_cast<const typename found::type&>(p));
}
//private:
template <typename Ex>
static const prop_fns<any_executor>* prop_fns_table()
{
static const prop_fns<any_executor> fns[] =
{
{
&detail::any_executor_base::query_fn<
Ex, SupportableProperties>,
&detail::any_executor_base::require_fn<
any_executor, Ex, SupportableProperties>,
&detail::any_executor_base::prefer_fn<
any_executor, Ex, SupportableProperties>
}...
};
return fns;
}
const prop_fns<any_executor>* prop_fns_;
};
template <typename... SupportableProperties>
inline void swap(any_executor<SupportableProperties...>& a,
any_executor<SupportableProperties...>& b) noexcept
{
return a.swap(b);
}
} // namespace execution
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
template <typename... SupportableProperties>
struct equality_comparable<execution::any_executor<SupportableProperties...>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
};
#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
template <typename F, typename... SupportableProperties>
struct execute_member<execution::any_executor<SupportableProperties...>, F>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = false;
typedef void result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
template <typename Prop, typename... SupportableProperties>
struct query_member<
execution::any_executor<SupportableProperties...>, Prop,
enable_if_t<
execution::detail::supportable_properties<
0, void(SupportableProperties...)>::template
find_convertible_property<Prop>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = false;
typedef typename execution::detail::supportable_properties<
0, void(SupportableProperties...)>::template
find_convertible_property<Prop>::query_result_type result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
template <typename Prop, typename... SupportableProperties>
struct require_member<
execution::any_executor<SupportableProperties...>, Prop,
enable_if_t<
execution::detail::supportable_properties<
0, void(SupportableProperties...)>::template
find_convertible_requirable_property<Prop>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = false;
typedef execution::any_executor<SupportableProperties...> result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
template <typename Prop, typename... SupportableProperties>
struct prefer_member<
execution::any_executor<SupportableProperties...>, Prop,
enable_if_t<
execution::detail::supportable_properties<
0, void(SupportableProperties...)>::template
find_convertible_preferable_property<Prop>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = false;
typedef execution::any_executor<SupportableProperties...> result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
} // namespace traits
#endif // defined(GENERATING_DOCUMENTATION)
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_ANY_EXECUTOR_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/outstanding_work.hpp | //
// execution/outstanding_work.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_OUTSTANDING_WORK_HPP
#define ASIO_EXECUTION_OUTSTANDING_WORK_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/execution/executor.hpp"
#include "asio/is_applicable_property.hpp"
#include "asio/query.hpp"
#include "asio/traits/query_free.hpp"
#include "asio/traits/query_member.hpp"
#include "asio/traits/query_static_constexpr_member.hpp"
#include "asio/traits/static_query.hpp"
#include "asio/traits/static_require.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
#if defined(GENERATING_DOCUMENTATION)
namespace execution {
/// A property to describe whether task submission is likely in the future.
struct outstanding_work_t
{
/// The outstanding_work_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The top-level outstanding_work_t property cannot be required.
static constexpr bool is_requirable = false;
/// The top-level outstanding_work_t property cannot be preferred.
static constexpr bool is_preferable = false;
/// The type returned by queries against an @c any_executor.
typedef outstanding_work_t polymorphic_query_result_type;
/// A sub-property that indicates that the executor does not represent likely
/// future submission of a function object.
struct untracked_t
{
/// The outstanding_work_t::untracked_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The outstanding_work_t::untracked_t property can be required.
static constexpr bool is_requirable = true;
/// The outstanding_work_t::untracked_t property can be preferred.
static constexpr bool is_preferable = true;
/// The type returned by queries against an @c any_executor.
typedef outstanding_work_t polymorphic_query_result_type;
/// Default constructor.
constexpr untracked_t();
/// Get the value associated with a property object.
/**
* @returns untracked_t();
*/
static constexpr outstanding_work_t value();
};
/// A sub-property that indicates that the executor represents likely
/// future submission of a function object.
struct tracked_t
{
/// The outstanding_work_t::untracked_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The outstanding_work_t::tracked_t property can be required.
static constexpr bool is_requirable = true;
/// The outstanding_work_t::tracked_t property can be preferred.
static constexpr bool is_preferable = true;
/// The type returned by queries against an @c any_executor.
typedef outstanding_work_t polymorphic_query_result_type;
/// Default constructor.
constexpr tracked_t();
/// Get the value associated with a property object.
/**
* @returns tracked_t();
*/
static constexpr outstanding_work_t value();
};
/// A special value used for accessing the outstanding_work_t::untracked_t
/// property.
static constexpr untracked_t untracked;
/// A special value used for accessing the outstanding_work_t::tracked_t
/// property.
static constexpr tracked_t tracked;
/// Default constructor.
constexpr outstanding_work_t();
/// Construct from a sub-property value.
constexpr outstanding_work_t(untracked_t);
/// Construct from a sub-property value.
constexpr outstanding_work_t(tracked_t);
/// Compare property values for equality.
friend constexpr bool operator==(
const outstanding_work_t& a, const outstanding_work_t& b) noexcept;
/// Compare property values for inequality.
friend constexpr bool operator!=(
const outstanding_work_t& a, const outstanding_work_t& b) noexcept;
};
/// A special value used for accessing the outstanding_work_t property.
constexpr outstanding_work_t outstanding_work;
} // namespace execution
#else // defined(GENERATING_DOCUMENTATION)
namespace execution {
namespace detail {
namespace outstanding_work {
template <int I> struct untracked_t;
template <int I> struct tracked_t;
} // namespace outstanding_work
template <int I = 0>
struct outstanding_work_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = false;
static constexpr bool is_preferable = false;
typedef outstanding_work_t polymorphic_query_result_type;
typedef detail::outstanding_work::untracked_t<I> untracked_t;
typedef detail::outstanding_work::tracked_t<I> tracked_t;
constexpr outstanding_work_t()
: value_(-1)
{
}
constexpr outstanding_work_t(untracked_t)
: value_(0)
{
}
constexpr outstanding_work_t(tracked_t)
: value_(1)
{
}
template <typename T>
struct proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
struct type
{
template <typename P>
auto query(P&& p) const
noexcept(
noexcept(
declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
)
)
-> decltype(
declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
);
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
};
template <typename T>
struct static_proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
struct type
{
template <typename P>
static constexpr auto query(P&& p)
noexcept(
noexcept(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
)
-> decltype(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
{
return T::query(static_cast<P&&>(p));
}
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
};
template <typename T>
struct query_member :
traits::query_member<typename proxy<T>::type, outstanding_work_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename static_proxy<T>::type, outstanding_work_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr
typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename T>
static constexpr
typename traits::static_query<T, untracked_t>::result_type
static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
traits::static_query<T, untracked_t>::is_valid
>* = 0) noexcept
{
return traits::static_query<T, untracked_t>::value();
}
template <typename T>
static constexpr
typename traits::static_query<T, tracked_t>::result_type
static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
!traits::static_query<T, untracked_t>::is_valid
>* = 0,
enable_if_t<
traits::static_query<T, tracked_t>::is_valid
>* = 0) noexcept
{
return traits::static_query<T, tracked_t>::value();
}
template <typename E,
typename T = decltype(outstanding_work_t::static_query<E>())>
static constexpr const T static_query_v
= outstanding_work_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
friend constexpr bool operator==(
const outstanding_work_t& a, const outstanding_work_t& b)
{
return a.value_ == b.value_;
}
friend constexpr bool operator!=(
const outstanding_work_t& a, const outstanding_work_t& b)
{
return a.value_ != b.value_;
}
struct convertible_from_outstanding_work_t
{
constexpr convertible_from_outstanding_work_t(outstanding_work_t)
{
}
};
template <typename Executor>
friend constexpr outstanding_work_t query(
const Executor& ex, convertible_from_outstanding_work_t,
enable_if_t<
can_query<const Executor&, untracked_t>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(is_nothrow_query<const Executor&,
outstanding_work_t<>::untracked_t>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, untracked_t>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, untracked_t());
}
template <typename Executor>
friend constexpr outstanding_work_t query(
const Executor& ex, convertible_from_outstanding_work_t,
enable_if_t<
!can_query<const Executor&, untracked_t>::value
>* = 0,
enable_if_t<
can_query<const Executor&, tracked_t>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(is_nothrow_query<const Executor&,
outstanding_work_t<>::tracked_t>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, tracked_t>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, tracked_t());
}
ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(untracked_t, untracked);
ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(tracked_t, tracked);
private:
int value_;
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T outstanding_work_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I>
const typename outstanding_work_t<I>::untracked_t
outstanding_work_t<I>::untracked;
template <int I>
const typename outstanding_work_t<I>::tracked_t
outstanding_work_t<I>::tracked;
namespace outstanding_work {
template <int I = 0>
struct untracked_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = true;
typedef outstanding_work_t<I> polymorphic_query_result_type;
constexpr untracked_t()
{
}
template <typename T>
struct query_member :
traits::query_member<
typename outstanding_work_t<I>::template proxy<T>::type, untracked_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename outstanding_work_t<I>::template static_proxy<T>::type,
untracked_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr
typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename T>
static constexpr untracked_t static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
!traits::query_free<T, untracked_t>::is_valid
>* = 0,
enable_if_t<
!can_query<T, tracked_t<I>>::value
>* = 0) noexcept
{
return untracked_t();
}
template <typename E, typename T = decltype(untracked_t::static_query<E>())>
static constexpr const T static_query_v = untracked_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
static constexpr outstanding_work_t<I> value()
{
return untracked_t();
}
friend constexpr bool operator==(const untracked_t&, const untracked_t&)
{
return true;
}
friend constexpr bool operator!=(const untracked_t&, const untracked_t&)
{
return false;
}
friend constexpr bool operator==(const untracked_t&, const tracked_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const untracked_t&, const tracked_t<I>&)
{
return true;
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T untracked_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I = 0>
struct tracked_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = true;
typedef outstanding_work_t<I> polymorphic_query_result_type;
constexpr tracked_t()
{
}
template <typename T>
struct query_member :
traits::query_member<
typename outstanding_work_t<I>::template proxy<T>::type, tracked_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename outstanding_work_t<I>::template static_proxy<T>::type,
tracked_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr
typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename E, typename T = decltype(tracked_t::static_query<E>())>
static constexpr const T static_query_v = tracked_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
static constexpr outstanding_work_t<I> value()
{
return tracked_t();
}
friend constexpr bool operator==(const tracked_t&, const tracked_t&)
{
return true;
}
friend constexpr bool operator!=(const tracked_t&, const tracked_t&)
{
return false;
}
friend constexpr bool operator==(const tracked_t&, const untracked_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const tracked_t&, const untracked_t<I>&)
{
return true;
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T tracked_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace outstanding_work
} // namespace detail
typedef detail::outstanding_work_t<> outstanding_work_t;
ASIO_INLINE_VARIABLE constexpr outstanding_work_t outstanding_work;
} // namespace execution
#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
struct is_applicable_property<T, execution::outstanding_work_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
template <typename T>
struct is_applicable_property<T, execution::outstanding_work_t::untracked_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
template <typename T>
struct is_applicable_property<T, execution::outstanding_work_t::tracked_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
template <typename T>
struct query_free_default<T, execution::outstanding_work_t,
enable_if_t<
can_query<T, execution::outstanding_work_t::untracked_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<T, execution::outstanding_work_t::untracked_t>::value;
typedef execution::outstanding_work_t result_type;
};
template <typename T>
struct query_free_default<T, execution::outstanding_work_t,
enable_if_t<
!can_query<T, execution::outstanding_work_t::untracked_t>::value
&& can_query<T, execution::outstanding_work_t::tracked_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<T, execution::outstanding_work_t::tracked_t>::value;
typedef execution::outstanding_work_t result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
|| !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
struct static_query<T, execution::outstanding_work_t,
enable_if_t<
execution::detail::outstanding_work_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::outstanding_work_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::outstanding_work_t<0>::
query_static_constexpr_member<T>::value();
}
};
template <typename T>
struct static_query<T, execution::outstanding_work_t,
enable_if_t<
!execution::detail::outstanding_work_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::outstanding_work_t<0>::
query_member<T>::is_valid
&& traits::static_query<T,
execution::outstanding_work_t::untracked_t>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename traits::static_query<T,
execution::outstanding_work_t::untracked_t>::result_type result_type;
static constexpr result_type value()
{
return traits::static_query<T,
execution::outstanding_work_t::untracked_t>::value();
}
};
template <typename T>
struct static_query<T, execution::outstanding_work_t,
enable_if_t<
!execution::detail::outstanding_work_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::outstanding_work_t<0>::
query_member<T>::is_valid
&& !traits::static_query<T,
execution::outstanding_work_t::untracked_t>::is_valid
&& traits::static_query<T,
execution::outstanding_work_t::tracked_t>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename traits::static_query<T,
execution::outstanding_work_t::tracked_t>::result_type result_type;
static constexpr result_type value()
{
return traits::static_query<T,
execution::outstanding_work_t::tracked_t>::value();
}
};
template <typename T>
struct static_query<T, execution::outstanding_work_t::untracked_t,
enable_if_t<
execution::detail::outstanding_work::untracked_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::outstanding_work::untracked_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::outstanding_work::untracked_t<0>::
query_static_constexpr_member<T>::value();
}
};
template <typename T>
struct static_query<T, execution::outstanding_work_t::untracked_t,
enable_if_t<
!execution::detail::outstanding_work::untracked_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::outstanding_work::untracked_t<0>::
query_member<T>::is_valid
&& !traits::query_free<T,
execution::outstanding_work_t::untracked_t>::is_valid
&& !can_query<T, execution::outstanding_work_t::tracked_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::outstanding_work_t::untracked_t result_type;
static constexpr result_type value()
{
return result_type();
}
};
template <typename T>
struct static_query<T, execution::outstanding_work_t::tracked_t,
enable_if_t<
execution::detail::outstanding_work::tracked_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::outstanding_work::tracked_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::outstanding_work::tracked_t<0>::
query_static_constexpr_member<T>::value();
}
};
#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace traits
#endif // defined(GENERATING_DOCUMENTATION)
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_OUTSTANDING_WORK_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/occupancy.hpp | //
// execution/occupancy.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_OCCUPANCY_HPP
#define ASIO_EXECUTION_OCCUPANCY_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/execution/executor.hpp"
#include "asio/is_applicable_property.hpp"
#include "asio/traits/query_static_constexpr_member.hpp"
#include "asio/traits/static_query.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
#if defined(GENERATING_DOCUMENTATION)
namespace execution {
/// A property that gives an estimate of the number of execution agents that
/// should occupy the associated execution context.
struct occupancy_t
{
/// The occupancy_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The occupancy_t property cannot be required.
static constexpr bool is_requirable = false;
/// The occupancy_t property cannot be preferred.
static constexpr bool is_preferable = false;
/// The type returned by queries against an @c any_executor.
typedef std::size_t polymorphic_query_result_type;
};
/// A special value used for accessing the occupancy_t property.
constexpr occupancy_t occupancy;
} // namespace execution
#else // defined(GENERATING_DOCUMENTATION)
namespace execution {
namespace detail {
template <int I = 0>
struct occupancy_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = false;
static constexpr bool is_preferable = false;
typedef std::size_t polymorphic_query_result_type;
constexpr occupancy_t()
{
}
template <typename T>
struct static_proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
struct type
{
template <typename P>
static constexpr auto query(P&& p)
noexcept(
noexcept(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
)
-> decltype(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
{
return T::query(static_cast<P&&>(p));
}
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename static_proxy<T>::type, occupancy_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename E, typename T = decltype(occupancy_t::static_query<E>())>
static constexpr const T static_query_v = occupancy_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T occupancy_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace detail
typedef detail::occupancy_t<> occupancy_t;
ASIO_INLINE_VARIABLE constexpr occupancy_t occupancy;
} // namespace execution
#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
struct is_applicable_property<T, execution::occupancy_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
|| !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
struct static_query<T, execution::occupancy_t,
enable_if_t<
execution::detail::occupancy_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::occupancy_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::occupancy_t<0>::
query_static_constexpr_member<T>::value();
}
};
#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace traits
#endif // defined(GENERATING_DOCUMENTATION)
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_OCCUPANCY_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/allocator.hpp | //
// execution/allocator.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_ALLOCATOR_HPP
#define ASIO_EXECUTION_ALLOCATOR_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/execution/executor.hpp"
#include "asio/is_applicable_property.hpp"
#include "asio/traits/query_static_constexpr_member.hpp"
#include "asio/traits/static_query.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
#if defined(GENERATING_DOCUMENTATION)
namespace execution {
/// A property to describe which allocator an executor will use to allocate the
/// memory required to store a submitted function object.
template <typename ProtoAllocator>
struct allocator_t
{
/// The allocator_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The allocator_t property can be required.
static constexpr bool is_requirable = true;
/// The allocator_t property can be preferred.
static constexpr bool is_preferable = true;
/// Default constructor.
constexpr allocator_t();
/// Obtain the allocator stored in the allocator_t property object.
/**
* Present only if @c ProtoAllocator is non-void.
*/
constexpr ProtoAllocator value() const;
/// Create an allocator_t object with a different allocator.
/**
* Present only if @c ProtoAllocator is void.
*/
template <typename OtherAllocator>
allocator_t<OtherAllocator operator()(const OtherAllocator& a);
};
/// A special value used for accessing the allocator_t property.
constexpr allocator_t<void> allocator;
} // namespace execution
#else // defined(GENERATING_DOCUMENTATION)
namespace execution {
template <typename ProtoAllocator>
struct allocator_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = true;
template <typename T>
struct static_proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
struct type
{
template <typename P>
static constexpr auto query(P&& p)
noexcept(
noexcept(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
)
-> decltype(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
{
return T::query(static_cast<P&&>(p));
}
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename static_proxy<T>::type, allocator_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename E, typename T = decltype(allocator_t::static_query<E>())>
static constexpr const T static_query_v = allocator_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
constexpr ProtoAllocator value() const
{
return a_;
}
private:
friend struct allocator_t<void>;
explicit constexpr allocator_t(const ProtoAllocator& a)
: a_(a)
{
}
ProtoAllocator a_;
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename ProtoAllocator> template <typename E, typename T>
const T allocator_t<ProtoAllocator>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <>
struct allocator_t<void>
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = true;
constexpr allocator_t()
{
}
template <typename T>
struct static_proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
struct type
{
template <typename P>
static constexpr auto query(P&& p)
noexcept(
noexcept(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
)
-> decltype(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
{
return T::query(static_cast<P&&>(p));
}
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename static_proxy<T>::type, allocator_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename E, typename T = decltype(allocator_t::static_query<E>())>
static constexpr const T static_query_v = allocator_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename OtherProtoAllocator>
constexpr allocator_t<OtherProtoAllocator> operator()(
const OtherProtoAllocator& a) const
{
return allocator_t<OtherProtoAllocator>(a);
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename E, typename T>
const T allocator_t<void>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
ASIO_INLINE_VARIABLE constexpr allocator_t<void> allocator;
} // namespace execution
#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T, typename ProtoAllocator>
struct is_applicable_property<T, execution::allocator_t<ProtoAllocator>>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
|| !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T, typename ProtoAllocator>
struct static_query<T, execution::allocator_t<ProtoAllocator>,
enable_if_t<
execution::allocator_t<ProtoAllocator>::template
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::allocator_t<ProtoAllocator>::template
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::allocator_t<ProtoAllocator>::template
query_static_constexpr_member<T>::value();
}
};
#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace traits
#endif // defined(GENERATING_DOCUMENTATION)
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_ALLOCATOR_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/blocking_adaptation.hpp | //
// execution/blocking_adaptation.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_BLOCKING_ADAPTATION_HPP
#define ASIO_EXECUTION_BLOCKING_ADAPTATION_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/event.hpp"
#include "asio/detail/mutex.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/execution/executor.hpp"
#include "asio/is_applicable_property.hpp"
#include "asio/prefer.hpp"
#include "asio/query.hpp"
#include "asio/require.hpp"
#include "asio/traits/prefer_member.hpp"
#include "asio/traits/query_free.hpp"
#include "asio/traits/query_member.hpp"
#include "asio/traits/query_static_constexpr_member.hpp"
#include "asio/traits/require_member.hpp"
#include "asio/traits/static_query.hpp"
#include "asio/traits/static_require.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
#if defined(GENERATING_DOCUMENTATION)
namespace execution {
/// A property to describe whether automatic adaptation of an executor is
/// allowed in order to apply the blocking_adaptation_t::allowed_t property.
struct blocking_adaptation_t
{
/// The blocking_adaptation_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The top-level blocking_adaptation_t property cannot be required.
static constexpr bool is_requirable = false;
/// The top-level blocking_adaptation_t property cannot be preferred.
static constexpr bool is_preferable = false;
/// The type returned by queries against an @c any_executor.
typedef blocking_adaptation_t polymorphic_query_result_type;
/// A sub-property that indicates that automatic adaptation is not allowed.
struct disallowed_t
{
/// The blocking_adaptation_t::disallowed_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The blocking_adaptation_t::disallowed_t property can be required.
static constexpr bool is_requirable = true;
/// The blocking_adaptation_t::disallowed_t property can be preferred.
static constexpr bool is_preferable = true;
/// The type returned by queries against an @c any_executor.
typedef blocking_adaptation_t polymorphic_query_result_type;
/// Default constructor.
constexpr disallowed_t();
/// Get the value associated with a property object.
/**
* @returns disallowed_t();
*/
static constexpr blocking_adaptation_t value();
};
/// A sub-property that indicates that automatic adaptation is allowed.
struct allowed_t
{
/// The blocking_adaptation_t::allowed_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The blocking_adaptation_t::allowed_t property can be required.
static constexpr bool is_requirable = true;
/// The blocking_adaptation_t::allowed_t property can be preferred.
static constexpr bool is_preferable = false;
/// The type returned by queries against an @c any_executor.
typedef blocking_adaptation_t polymorphic_query_result_type;
/// Default constructor.
constexpr allowed_t();
/// Get the value associated with a property object.
/**
* @returns allowed_t();
*/
static constexpr blocking_adaptation_t value();
};
/// A special value used for accessing the blocking_adaptation_t::disallowed_t
/// property.
static constexpr disallowed_t disallowed;
/// A special value used for accessing the blocking_adaptation_t::allowed_t
/// property.
static constexpr allowed_t allowed;
/// Default constructor.
constexpr blocking_adaptation_t();
/// Construct from a sub-property value.
constexpr blocking_adaptation_t(disallowed_t);
/// Construct from a sub-property value.
constexpr blocking_adaptation_t(allowed_t);
/// Compare property values for equality.
friend constexpr bool operator==(
const blocking_adaptation_t& a, const blocking_adaptation_t& b) noexcept;
/// Compare property values for inequality.
friend constexpr bool operator!=(
const blocking_adaptation_t& a, const blocking_adaptation_t& b) noexcept;
};
/// A special value used for accessing the blocking_adaptation_t property.
constexpr blocking_adaptation_t blocking_adaptation;
} // namespace execution
#else // defined(GENERATING_DOCUMENTATION)
namespace execution {
namespace detail {
namespace blocking_adaptation {
template <int I> struct disallowed_t;
template <int I> struct allowed_t;
} // namespace blocking_adaptation
template <int I = 0>
struct blocking_adaptation_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = false;
static constexpr bool is_preferable = false;
typedef blocking_adaptation_t polymorphic_query_result_type;
typedef detail::blocking_adaptation::disallowed_t<I> disallowed_t;
typedef detail::blocking_adaptation::allowed_t<I> allowed_t;
constexpr blocking_adaptation_t()
: value_(-1)
{
}
constexpr blocking_adaptation_t(disallowed_t)
: value_(0)
{
}
constexpr blocking_adaptation_t(allowed_t)
: value_(1)
{
}
template <typename T>
struct proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
struct type
{
template <typename P>
auto query(P&& p) const
noexcept(
noexcept(
declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
)
)
-> decltype(
declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
);
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
};
template <typename T>
struct static_proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
struct type
{
template <typename P>
static constexpr auto query(P&& p)
noexcept(
noexcept(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
)
-> decltype(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
{
return T::query(static_cast<P&&>(p));
}
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
};
template <typename T>
struct query_member :
traits::query_member<typename proxy<T>::type, blocking_adaptation_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename static_proxy<T>::type, blocking_adaptation_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename T>
static constexpr
typename traits::static_query<T, disallowed_t>::result_type
static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
traits::static_query<T, disallowed_t>::is_valid
>* = 0) noexcept
{
return traits::static_query<T, disallowed_t>::value();
}
template <typename T>
static constexpr
typename traits::static_query<T, allowed_t>::result_type
static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
!traits::static_query<T, disallowed_t>::is_valid
>* = 0,
enable_if_t<
traits::static_query<T, allowed_t>::is_valid
>* = 0) noexcept
{
return traits::static_query<T, allowed_t>::value();
}
template <typename E,
typename T = decltype(blocking_adaptation_t::static_query<E>())>
static constexpr const T static_query_v
= blocking_adaptation_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
friend constexpr bool operator==(
const blocking_adaptation_t& a, const blocking_adaptation_t& b)
{
return a.value_ == b.value_;
}
friend constexpr bool operator!=(
const blocking_adaptation_t& a, const blocking_adaptation_t& b)
{
return a.value_ != b.value_;
}
struct convertible_from_blocking_adaptation_t
{
constexpr convertible_from_blocking_adaptation_t(
blocking_adaptation_t)
{
}
};
template <typename Executor>
friend constexpr blocking_adaptation_t query(
const Executor& ex, convertible_from_blocking_adaptation_t,
enable_if_t<
can_query<const Executor&, disallowed_t>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(is_nothrow_query<const Executor&,
blocking_adaptation_t<>::disallowed_t>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, disallowed_t>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, disallowed_t());
}
template <typename Executor>
friend constexpr blocking_adaptation_t query(
const Executor& ex, convertible_from_blocking_adaptation_t,
enable_if_t<
!can_query<const Executor&, disallowed_t>::value
>* = 0,
enable_if_t<
can_query<const Executor&, allowed_t>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(is_nothrow_query<const Executor&,
blocking_adaptation_t<>::allowed_t>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, allowed_t>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, allowed_t());
}
ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(disallowed_t, disallowed);
ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(allowed_t, allowed);
private:
int value_;
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T blocking_adaptation_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I>
const typename blocking_adaptation_t<I>::disallowed_t
blocking_adaptation_t<I>::disallowed;
template <int I>
const typename blocking_adaptation_t<I>::allowed_t
blocking_adaptation_t<I>::allowed;
namespace blocking_adaptation {
template <int I = 0>
struct disallowed_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = true;
typedef blocking_adaptation_t<I> polymorphic_query_result_type;
constexpr disallowed_t()
{
}
template <typename T>
struct query_member :
traits::query_member<
typename blocking_adaptation_t<I>::template proxy<T>::type,
disallowed_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename blocking_adaptation_t<I>::template static_proxy<T>::type,
disallowed_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr
typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename T>
static constexpr disallowed_t static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
!traits::query_free<T, disallowed_t>::is_valid
>* = 0,
enable_if_t<
!can_query<T, allowed_t<I>>::value
>* = 0) noexcept
{
return disallowed_t();
}
template <typename E, typename T = decltype(disallowed_t::static_query<E>())>
static constexpr const T static_query_v
= disallowed_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
static constexpr blocking_adaptation_t<I> value()
{
return disallowed_t();
}
friend constexpr bool operator==(const disallowed_t&, const disallowed_t&)
{
return true;
}
friend constexpr bool operator!=(const disallowed_t&, const disallowed_t&)
{
return false;
}
friend constexpr bool operator==(const disallowed_t&, const allowed_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const disallowed_t&, const allowed_t<I>&)
{
return true;
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T disallowed_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename Executor>
class adapter
{
public:
adapter(int, const Executor& e) noexcept
: executor_(e)
{
}
adapter(const adapter& other) noexcept
: executor_(other.executor_)
{
}
adapter(adapter&& other) noexcept
: executor_(static_cast<Executor&&>(other.executor_))
{
}
template <int I>
static constexpr allowed_t<I> query(blocking_adaptation_t<I>) noexcept
{
return allowed_t<I>();
}
template <int I>
static constexpr allowed_t<I> query(allowed_t<I>) noexcept
{
return allowed_t<I>();
}
template <int I>
static constexpr allowed_t<I> query(disallowed_t<I>) noexcept
{
return allowed_t<I>();
}
template <typename Property>
enable_if_t<
can_query<const Executor&, Property>::value,
query_result_t<const Executor&, Property>
> query(const Property& p) const
noexcept(is_nothrow_query<const Executor&, Property>::value)
{
return asio::query(executor_, p);
}
template <int I>
Executor require(disallowed_t<I>) const noexcept
{
return executor_;
}
template <typename Property>
enable_if_t<
can_require<const Executor&, Property>::value,
adapter<decay_t<require_result_t<const Executor&, Property>>>
> require(const Property& p) const
noexcept(is_nothrow_require<const Executor&, Property>::value)
{
return adapter<decay_t<require_result_t<const Executor&, Property>>>(
0, asio::require(executor_, p));
}
template <typename Property>
enable_if_t<
can_prefer<const Executor&, Property>::value,
adapter<decay_t<prefer_result_t<const Executor&, Property>>>
> prefer(const Property& p) const
noexcept(is_nothrow_prefer<const Executor&, Property>::value)
{
return adapter<decay_t<prefer_result_t<const Executor&, Property>>>(
0, asio::prefer(executor_, p));
}
template <typename Function>
enable_if_t<
traits::execute_member<const Executor&, Function>::is_valid
> execute(Function&& f) const
{
executor_.execute(static_cast<Function&&>(f));
}
friend bool operator==(const adapter& a, const adapter& b) noexcept
{
return a.executor_ == b.executor_;
}
friend bool operator!=(const adapter& a, const adapter& b) noexcept
{
return a.executor_ != b.executor_;
}
private:
Executor executor_;
};
template <int I = 0>
struct allowed_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = false;
typedef blocking_adaptation_t<I> polymorphic_query_result_type;
constexpr allowed_t()
{
}
template <typename T>
struct query_member :
traits::query_member<
typename blocking_adaptation_t<I>::template proxy<T>::type,
allowed_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename blocking_adaptation_t<I>::template static_proxy<T>::type,
allowed_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename E, typename T = decltype(allowed_t::static_query<E>())>
static constexpr const T static_query_v = allowed_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
static constexpr blocking_adaptation_t<I> value()
{
return allowed_t();
}
friend constexpr bool operator==(const allowed_t&, const allowed_t&)
{
return true;
}
friend constexpr bool operator!=(const allowed_t&, const allowed_t&)
{
return false;
}
friend constexpr bool operator==(const allowed_t&, const disallowed_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const allowed_t&, const disallowed_t<I>&)
{
return true;
}
template <typename Executor>
friend adapter<Executor> require(
const Executor& e, const allowed_t&,
enable_if_t<
is_executor<Executor>::value
>* = 0)
{
return adapter<Executor>(0, e);
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T allowed_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename Function>
class blocking_execute_state
{
public:
template <typename F>
blocking_execute_state(F&& f)
: func_(static_cast<F&&>(f)),
is_complete_(false)
{
}
template <typename Executor>
void execute_and_wait(Executor&& ex)
{
handler h = { this };
ex.execute(h);
asio::detail::mutex::scoped_lock lock(mutex_);
while (!is_complete_)
event_.wait(lock);
}
struct cleanup
{
~cleanup()
{
asio::detail::mutex::scoped_lock lock(state_->mutex_);
state_->is_complete_ = true;
state_->event_.unlock_and_signal_one_for_destruction(lock);
}
blocking_execute_state* state_;
};
struct handler
{
void operator()()
{
cleanup c = { state_ };
state_->func_();
}
blocking_execute_state* state_;
};
Function func_;
asio::detail::mutex mutex_;
asio::detail::event event_;
bool is_complete_;
};
template <typename Executor, typename Function>
void blocking_execute(
Executor&& ex,
Function&& func)
{
typedef decay_t<Function> func_t;
blocking_execute_state<func_t> state(static_cast<Function&&>(func));
state.execute_and_wait(ex);
}
} // namespace blocking_adaptation
} // namespace detail
typedef detail::blocking_adaptation_t<> blocking_adaptation_t;
ASIO_INLINE_VARIABLE constexpr blocking_adaptation_t blocking_adaptation;
} // namespace execution
#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
struct is_applicable_property<T, execution::blocking_adaptation_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
template <typename T>
struct is_applicable_property<T, execution::blocking_adaptation_t::disallowed_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
template <typename T>
struct is_applicable_property<T, execution::blocking_adaptation_t::allowed_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
template <typename T>
struct query_free_default<T, execution::blocking_adaptation_t,
enable_if_t<
can_query<T, execution::blocking_adaptation_t::disallowed_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<T, execution::blocking_adaptation_t::disallowed_t>::value;
typedef execution::blocking_adaptation_t result_type;
};
template <typename T>
struct query_free_default<T, execution::blocking_adaptation_t,
enable_if_t<
!can_query<T, execution::blocking_adaptation_t::disallowed_t>::value
&& can_query<T, execution::blocking_adaptation_t::allowed_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<T, execution::blocking_adaptation_t::allowed_t>::value;
typedef execution::blocking_adaptation_t result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
|| !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
struct static_query<T, execution::blocking_adaptation_t,
enable_if_t<
execution::detail::blocking_adaptation_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::blocking_adaptation_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::blocking_adaptation_t<0>::
query_static_constexpr_member<T>::value();
}
};
template <typename T>
struct static_query<T, execution::blocking_adaptation_t,
enable_if_t<
!execution::detail::blocking_adaptation_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::blocking_adaptation_t<0>::
query_member<T>::is_valid
&& traits::static_query<T,
execution::blocking_adaptation_t::disallowed_t>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename traits::static_query<T,
execution::blocking_adaptation_t::disallowed_t>::result_type result_type;
static constexpr result_type value()
{
return traits::static_query<T,
execution::blocking_adaptation_t::disallowed_t>::value();
}
};
template <typename T>
struct static_query<T, execution::blocking_adaptation_t,
enable_if_t<
!execution::detail::blocking_adaptation_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::blocking_adaptation_t<0>::
query_member<T>::is_valid
&& !traits::static_query<T,
execution::blocking_adaptation_t::disallowed_t>::is_valid
&& traits::static_query<T,
execution::blocking_adaptation_t::allowed_t>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename traits::static_query<T,
execution::blocking_adaptation_t::allowed_t>::result_type result_type;
static constexpr result_type value()
{
return traits::static_query<T,
execution::blocking_adaptation_t::allowed_t>::value();
}
};
template <typename T>
struct static_query<T, execution::blocking_adaptation_t::disallowed_t,
enable_if_t<
execution::detail::blocking_adaptation::disallowed_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::blocking_adaptation::disallowed_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::blocking_adaptation::disallowed_t<0>::
query_static_constexpr_member<T>::value();
}
};
template <typename T>
struct static_query<T, execution::blocking_adaptation_t::disallowed_t,
enable_if_t<
!execution::detail::blocking_adaptation::disallowed_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::blocking_adaptation::disallowed_t<0>::
query_member<T>::is_valid
&& !traits::query_free<T,
execution::blocking_adaptation_t::disallowed_t>::is_valid
&& !can_query<T, execution::blocking_adaptation_t::allowed_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::blocking_adaptation_t::disallowed_t result_type;
static constexpr result_type value()
{
return result_type();
}
};
template <typename T>
struct static_query<T, execution::blocking_adaptation_t::allowed_t,
enable_if_t<
execution::detail::blocking_adaptation::allowed_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::blocking_adaptation::allowed_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::blocking_adaptation::allowed_t<0>::
query_static_constexpr_member<T>::value();
}
};
#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
#if !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
template <typename T>
struct require_free_default<T, execution::blocking_adaptation_t::allowed_t,
enable_if_t<
is_same<T, decay_t<T>>::value
&& execution::is_executor<T>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = false;
typedef execution::detail::blocking_adaptation::adapter<T> result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
template <typename Executor>
struct equality_comparable<
execution::detail::blocking_adaptation::adapter<Executor>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
};
#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
template <typename Executor, typename Function>
struct execute_member<
execution::detail::blocking_adaptation::adapter<Executor>, Function>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = false;
typedef void result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
template <typename Executor, int I>
struct query_static_constexpr_member<
execution::detail::blocking_adaptation::adapter<Executor>,
execution::detail::blocking_adaptation_t<I>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::blocking_adaptation_t::allowed_t result_type;
static constexpr result_type value() noexcept
{
return result_type();
}
};
template <typename Executor, int I>
struct query_static_constexpr_member<
execution::detail::blocking_adaptation::adapter<Executor>,
execution::detail::blocking_adaptation::allowed_t<I>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::blocking_adaptation_t::allowed_t result_type;
static constexpr result_type value() noexcept
{
return result_type();
}
};
template <typename Executor, int I>
struct query_static_constexpr_member<
execution::detail::blocking_adaptation::adapter<Executor>,
execution::detail::blocking_adaptation::disallowed_t<I>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::blocking_adaptation_t::allowed_t result_type;
static constexpr result_type value() noexcept
{
return result_type();
}
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
template <typename Executor, typename Property>
struct query_member<
execution::detail::blocking_adaptation::adapter<Executor>, Property,
enable_if_t<
can_query<const Executor&, Property>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<Executor, Property>::value;
typedef query_result_t<Executor, Property> result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
template <typename Executor, int I>
struct require_member<
execution::detail::blocking_adaptation::adapter<Executor>,
execution::detail::blocking_adaptation::disallowed_t<I>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef Executor result_type;
};
template <typename Executor, typename Property>
struct require_member<
execution::detail::blocking_adaptation::adapter<Executor>, Property,
enable_if_t<
can_require<const Executor&, Property>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_require<Executor, Property>::value;
typedef execution::detail::blocking_adaptation::adapter<
decay_t<require_result_t<Executor, Property>>> result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
template <typename Executor, typename Property>
struct prefer_member<
execution::detail::blocking_adaptation::adapter<Executor>, Property,
enable_if_t<
can_prefer<const Executor&, Property>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_prefer<Executor, Property>::value;
typedef execution::detail::blocking_adaptation::adapter<
decay_t<prefer_result_t<Executor, Property>>> result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
} // namespace traits
#endif // defined(GENERATING_DOCUMENTATION)
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_BLOCKING_ADAPTATION_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/blocking.hpp | //
// execution/blocking.hpp
// ~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_BLOCKING_HPP
#define ASIO_EXECUTION_BLOCKING_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/execution/executor.hpp"
#include "asio/is_applicable_property.hpp"
#include "asio/prefer.hpp"
#include "asio/query.hpp"
#include "asio/require.hpp"
#include "asio/traits/execute_member.hpp"
#include "asio/traits/query_free.hpp"
#include "asio/traits/query_member.hpp"
#include "asio/traits/query_static_constexpr_member.hpp"
#include "asio/traits/static_query.hpp"
#include "asio/traits/static_require.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
#if defined(GENERATING_DOCUMENTATION)
namespace execution {
/// A property to describe what guarantees an executor makes about the blocking
/// behaviour of their execution functions.
struct blocking_t
{
/// The blocking_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The top-level blocking_t property cannot be required.
static constexpr bool is_requirable = false;
/// The top-level blocking_t property cannot be preferred.
static constexpr bool is_preferable = false;
/// The type returned by queries against an @c any_executor.
typedef blocking_t polymorphic_query_result_type;
/// A sub-property that indicates that invocation of an executor's execution
/// function may block pending completion of one or more invocations of the
/// submitted function object.
struct possibly_t
{
/// The blocking_t::possibly_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The blocking_t::possibly_t property can be required.
static constexpr bool is_requirable = true;
/// The blocking_t::possibly_t property can be preferred.
static constexpr bool is_preferable = true;
/// The type returned by queries against an @c any_executor.
typedef blocking_t polymorphic_query_result_type;
/// Default constructor.
constexpr possibly_t();
/// Get the value associated with a property object.
/**
* @returns possibly_t();
*/
static constexpr blocking_t value();
};
/// A sub-property that indicates that invocation of an executor's execution
/// function shall block until completion of all invocations of the submitted
/// function object.
struct always_t
{
/// The blocking_t::always_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The blocking_t::always_t property can be required.
static constexpr bool is_requirable = true;
/// The blocking_t::always_t property can be preferred.
static constexpr bool is_preferable = false;
/// The type returned by queries against an @c any_executor.
typedef blocking_t polymorphic_query_result_type;
/// Default constructor.
constexpr always_t();
/// Get the value associated with a property object.
/**
* @returns always_t();
*/
static constexpr blocking_t value();
};
/// A sub-property that indicates that invocation of an executor's execution
/// function shall not block pending completion of the invocations of the
/// submitted function object.
struct never_t
{
/// The blocking_t::never_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The blocking_t::never_t property can be required.
static constexpr bool is_requirable = true;
/// The blocking_t::never_t property can be preferred.
static constexpr bool is_preferable = true;
/// The type returned by queries against an @c any_executor.
typedef blocking_t polymorphic_query_result_type;
/// Default constructor.
constexpr never_t();
/// Get the value associated with a property object.
/**
* @returns never_t();
*/
static constexpr blocking_t value();
};
/// A special value used for accessing the blocking_t::possibly_t property.
static constexpr possibly_t possibly;
/// A special value used for accessing the blocking_t::always_t property.
static constexpr always_t always;
/// A special value used for accessing the blocking_t::never_t property.
static constexpr never_t never;
/// Default constructor.
constexpr blocking_t();
/// Construct from a sub-property value.
constexpr blocking_t(possibly_t);
/// Construct from a sub-property value.
constexpr blocking_t(always_t);
/// Construct from a sub-property value.
constexpr blocking_t(never_t);
/// Compare property values for equality.
friend constexpr bool operator==(
const blocking_t& a, const blocking_t& b) noexcept;
/// Compare property values for inequality.
friend constexpr bool operator!=(
const blocking_t& a, const blocking_t& b) noexcept;
};
/// A special value used for accessing the blocking_t property.
constexpr blocking_t blocking;
} // namespace execution
#else // defined(GENERATING_DOCUMENTATION)
namespace execution {
namespace detail {
namespace blocking {
template <int I> struct possibly_t;
template <int I> struct always_t;
template <int I> struct never_t;
} // namespace blocking
namespace blocking_adaptation {
template <int I> struct allowed_t;
template <typename Executor, typename Function>
void blocking_execute(
Executor&& ex,
Function&& func);
} // namespace blocking_adaptation
template <int I = 0>
struct blocking_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = false;
static constexpr bool is_preferable = false;
typedef blocking_t polymorphic_query_result_type;
typedef detail::blocking::possibly_t<I> possibly_t;
typedef detail::blocking::always_t<I> always_t;
typedef detail::blocking::never_t<I> never_t;
constexpr blocking_t()
: value_(-1)
{
}
constexpr blocking_t(possibly_t)
: value_(0)
{
}
constexpr blocking_t(always_t)
: value_(1)
{
}
constexpr blocking_t(never_t)
: value_(2)
{
}
template <typename T>
struct proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
struct type
{
template <typename P>
auto query(P&& p) const
noexcept(
noexcept(
declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
)
)
-> decltype(
declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
);
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
};
template <typename T>
struct static_proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
struct type
{
template <typename P>
static constexpr auto query(P&& p)
noexcept(
noexcept(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
)
-> decltype(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
{
return T::query(static_cast<P&&>(p));
}
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
};
template <typename T>
struct query_member :
traits::query_member<typename proxy<T>::type, blocking_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename static_proxy<T>::type, blocking_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr
typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename T>
static constexpr
typename traits::static_query<T, possibly_t>::result_type
static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
traits::static_query<T, possibly_t>::is_valid
>* = 0) noexcept
{
return traits::static_query<T, possibly_t>::value();
}
template <typename T>
static constexpr
typename traits::static_query<T, always_t>::result_type
static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
!traits::static_query<T, possibly_t>::is_valid
>* = 0,
enable_if_t<
traits::static_query<T, always_t>::is_valid
>* = 0) noexcept
{
return traits::static_query<T, always_t>::value();
}
template <typename T>
static constexpr
typename traits::static_query<T, never_t>::result_type
static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
!traits::static_query<T, possibly_t>::is_valid
>* = 0,
enable_if_t<
!traits::static_query<T, always_t>::is_valid
>* = 0,
enable_if_t<
traits::static_query<T, never_t>::is_valid
>* = 0) noexcept
{
return traits::static_query<T, never_t>::value();
}
template <typename E, typename T = decltype(blocking_t::static_query<E>())>
static constexpr const T static_query_v
= blocking_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
friend constexpr bool operator==(
const blocking_t& a, const blocking_t& b)
{
return a.value_ == b.value_;
}
friend constexpr bool operator!=(
const blocking_t& a, const blocking_t& b)
{
return a.value_ != b.value_;
}
struct convertible_from_blocking_t
{
constexpr convertible_from_blocking_t(blocking_t) {}
};
template <typename Executor>
friend constexpr blocking_t query(
const Executor& ex, convertible_from_blocking_t,
enable_if_t<
can_query<const Executor&, possibly_t>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(is_nothrow_query<const Executor&, blocking_t<>::possibly_t>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, possibly_t>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, possibly_t());
}
template <typename Executor>
friend constexpr blocking_t query(
const Executor& ex, convertible_from_blocking_t,
enable_if_t<
!can_query<const Executor&, possibly_t>::value
>* = 0,
enable_if_t<
can_query<const Executor&, always_t>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(is_nothrow_query<const Executor&, blocking_t<>::always_t>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, always_t>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, always_t());
}
template <typename Executor>
friend constexpr blocking_t query(
const Executor& ex, convertible_from_blocking_t,
enable_if_t<
!can_query<const Executor&, possibly_t>::value
>* = 0,
enable_if_t<
!can_query<const Executor&, always_t>::value
>* = 0,
enable_if_t<
can_query<const Executor&, never_t>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(is_nothrow_query<const Executor&, blocking_t<>::never_t>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, never_t>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, never_t());
}
ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(possibly_t, possibly);
ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(always_t, always);
ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(never_t, never);
private:
int value_;
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T blocking_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I>
const typename blocking_t<I>::possibly_t blocking_t<I>::possibly;
template <int I>
const typename blocking_t<I>::always_t blocking_t<I>::always;
template <int I>
const typename blocking_t<I>::never_t blocking_t<I>::never;
namespace blocking {
template <int I = 0>
struct possibly_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = true;
typedef blocking_t<I> polymorphic_query_result_type;
constexpr possibly_t()
{
}
template <typename T>
struct query_member :
traits::query_member<
typename blocking_t<I>::template proxy<T>::type, possibly_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename blocking_t<I>::template static_proxy<T>::type, possibly_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr
typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename T>
static constexpr possibly_t static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
!traits::query_free<T, possibly_t>::is_valid
>* = 0,
enable_if_t<
!can_query<T, always_t<I>>::value
>* = 0,
enable_if_t<
!can_query<T, never_t<I>>::value
>* = 0) noexcept
{
return possibly_t();
}
template <typename E, typename T = decltype(possibly_t::static_query<E>())>
static constexpr const T static_query_v
= possibly_t::static_query<E>();
#endif // defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
static constexpr blocking_t<I> value()
{
return possibly_t();
}
friend constexpr bool operator==(
const possibly_t&, const possibly_t&)
{
return true;
}
friend constexpr bool operator!=(
const possibly_t&, const possibly_t&)
{
return false;
}
friend constexpr bool operator==(
const possibly_t&, const always_t<I>&)
{
return false;
}
friend constexpr bool operator!=(
const possibly_t&, const always_t<I>&)
{
return true;
}
friend constexpr bool operator==(
const possibly_t&, const never_t<I>&)
{
return false;
}
friend constexpr bool operator!=(
const possibly_t&, const never_t<I>&)
{
return true;
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T possibly_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename Executor>
class adapter
{
public:
adapter(int, const Executor& e) noexcept
: executor_(e)
{
}
adapter(const adapter& other) noexcept
: executor_(other.executor_)
{
}
adapter(adapter&& other) noexcept
: executor_(static_cast<Executor&&>(other.executor_))
{
}
template <int I>
static constexpr always_t<I> query(blocking_t<I>) noexcept
{
return always_t<I>();
}
template <int I>
static constexpr always_t<I> query(possibly_t<I>) noexcept
{
return always_t<I>();
}
template <int I>
static constexpr always_t<I> query(always_t<I>) noexcept
{
return always_t<I>();
}
template <int I>
static constexpr always_t<I> query(never_t<I>) noexcept
{
return always_t<I>();
}
template <typename Property>
enable_if_t<
can_query<const Executor&, Property>::value,
query_result_t<const Executor&, Property>
> query(const Property& p) const
noexcept(is_nothrow_query<const Executor&, Property>::value)
{
return asio::query(executor_, p);
}
template <int I>
enable_if_t<
can_require<const Executor&, possibly_t<I>>::value,
require_result_t<const Executor&, possibly_t<I>>
> require(possibly_t<I>) const noexcept
{
return asio::require(executor_, possibly_t<I>());
}
template <int I>
enable_if_t<
can_require<const Executor&, never_t<I>>::value,
require_result_t<const Executor&, never_t<I>>
> require(never_t<I>) const noexcept
{
return asio::require(executor_, never_t<I>());
}
template <typename Property>
enable_if_t<
can_require<const Executor&, Property>::value,
adapter<decay_t<require_result_t<const Executor&, Property>>>
> require(const Property& p) const
noexcept(is_nothrow_require<const Executor&, Property>::value)
{
return adapter<decay_t<require_result_t<const Executor&, Property>>>(
0, asio::require(executor_, p));
}
template <typename Property>
enable_if_t<
can_prefer<const Executor&, Property>::value,
adapter<decay_t<prefer_result_t<const Executor&, Property>>>
> prefer(const Property& p) const
noexcept(is_nothrow_prefer<const Executor&, Property>::value)
{
return adapter<decay_t<prefer_result_t<const Executor&, Property>>>(
0, asio::prefer(executor_, p));
}
template <typename Function>
enable_if_t<
traits::execute_member<const Executor&, Function>::is_valid
> execute(Function&& f) const
{
blocking_adaptation::blocking_execute(
executor_, static_cast<Function&&>(f));
}
friend bool operator==(const adapter& a, const adapter& b) noexcept
{
return a.executor_ == b.executor_;
}
friend bool operator!=(const adapter& a, const adapter& b) noexcept
{
return a.executor_ != b.executor_;
}
private:
Executor executor_;
};
template <int I = 0>
struct always_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = false;
typedef blocking_t<I> polymorphic_query_result_type;
constexpr always_t()
{
}
template <typename T>
struct query_member :
traits::query_member<
typename blocking_t<I>::template proxy<T>::type, always_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename blocking_t<I>::template static_proxy<T>::type, always_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename E, typename T = decltype(always_t::static_query<E>())>
static constexpr const T static_query_v = always_t::static_query<E>();
#endif // defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
static constexpr blocking_t<I> value()
{
return always_t();
}
friend constexpr bool operator==(
const always_t&, const always_t&)
{
return true;
}
friend constexpr bool operator!=(
const always_t&, const always_t&)
{
return false;
}
friend constexpr bool operator==(
const always_t&, const possibly_t<I>&)
{
return false;
}
friend constexpr bool operator!=(
const always_t&, const possibly_t<I>&)
{
return true;
}
friend constexpr bool operator==(
const always_t&, const never_t<I>&)
{
return false;
}
friend constexpr bool operator!=(
const always_t&, const never_t<I>&)
{
return true;
}
template <typename Executor>
friend adapter<Executor> require(
const Executor& e, const always_t&,
enable_if_t<
is_executor<Executor>::value
>* = 0,
enable_if_t<
traits::static_require<
const Executor&,
blocking_adaptation::allowed_t<0>
>::is_valid
>* = 0)
{
return adapter<Executor>(0, e);
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T always_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I>
struct never_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = true;
typedef blocking_t<I> polymorphic_query_result_type;
constexpr never_t()
{
}
template <typename T>
struct query_member :
traits::query_member<
typename blocking_t<I>::template proxy<T>::type, never_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename blocking_t<I>::template static_proxy<T>::type, never_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr
typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename E, typename T = decltype(never_t::static_query<E>())>
static constexpr const T static_query_v
= never_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
static constexpr blocking_t<I> value()
{
return never_t();
}
friend constexpr bool operator==(const never_t&, const never_t&)
{
return true;
}
friend constexpr bool operator!=(const never_t&, const never_t&)
{
return false;
}
friend constexpr bool operator==(const never_t&, const possibly_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const never_t&, const possibly_t<I>&)
{
return true;
}
friend constexpr bool operator==(const never_t&, const always_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const never_t&, const always_t<I>&)
{
return true;
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T never_t<I>::static_query_v;
#endif // defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace blocking
} // namespace detail
typedef detail::blocking_t<> blocking_t;
ASIO_INLINE_VARIABLE constexpr blocking_t blocking;
} // namespace execution
#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
struct is_applicable_property<T, execution::blocking_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
template <typename T>
struct is_applicable_property<T, execution::blocking_t::possibly_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
template <typename T>
struct is_applicable_property<T, execution::blocking_t::always_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
template <typename T>
struct is_applicable_property<T, execution::blocking_t::never_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
template <typename T>
struct query_free_default<T, execution::blocking_t,
enable_if_t<
can_query<T, execution::blocking_t::possibly_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<T, execution::blocking_t::possibly_t>::value;
typedef execution::blocking_t result_type;
};
template <typename T>
struct query_free_default<T, execution::blocking_t,
enable_if_t<
!can_query<T, execution::blocking_t::possibly_t>::value
&& can_query<T, execution::blocking_t::always_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<T, execution::blocking_t::always_t>::value;
typedef execution::blocking_t result_type;
};
template <typename T>
struct query_free_default<T, execution::blocking_t,
enable_if_t<
!can_query<T, execution::blocking_t::possibly_t>::value
&& !can_query<T, execution::blocking_t::always_t>::value
&& can_query<T, execution::blocking_t::never_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<T, execution::blocking_t::never_t>::value;
typedef execution::blocking_t result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
|| !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
struct static_query<T, execution::blocking_t,
enable_if_t<
execution::detail::blocking_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::blocking_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::blocking_t::query_static_constexpr_member<T>::value();
}
};
template <typename T>
struct static_query<T, execution::blocking_t,
enable_if_t<
!execution::detail::blocking_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::blocking_t<0>::
query_member<T>::is_valid
&& traits::static_query<T, execution::blocking_t::possibly_t>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename traits::static_query<T,
execution::blocking_t::possibly_t>::result_type result_type;
static constexpr result_type value()
{
return traits::static_query<T, execution::blocking_t::possibly_t>::value();
}
};
template <typename T>
struct static_query<T, execution::blocking_t,
enable_if_t<
!execution::detail::blocking_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::blocking_t<0>::
query_member<T>::is_valid
&& !traits::static_query<T, execution::blocking_t::possibly_t>::is_valid
&& traits::static_query<T, execution::blocking_t::always_t>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename traits::static_query<T,
execution::blocking_t::always_t>::result_type result_type;
static constexpr result_type value()
{
return traits::static_query<T, execution::blocking_t::always_t>::value();
}
};
template <typename T>
struct static_query<T, execution::blocking_t,
enable_if_t<
!execution::detail::blocking_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::blocking_t<0>::
query_member<T>::is_valid
&& !traits::static_query<T, execution::blocking_t::possibly_t>::is_valid
&& !traits::static_query<T, execution::blocking_t::always_t>::is_valid
&& traits::static_query<T, execution::blocking_t::never_t>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename traits::static_query<T,
execution::blocking_t::never_t>::result_type result_type;
static constexpr result_type value()
{
return traits::static_query<T, execution::blocking_t::never_t>::value();
}
};
template <typename T>
struct static_query<T, execution::blocking_t::possibly_t,
enable_if_t<
execution::detail::blocking::possibly_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::blocking::possibly_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::blocking::possibly_t<0>::
query_static_constexpr_member<T>::value();
}
};
template <typename T>
struct static_query<T, execution::blocking_t::possibly_t,
enable_if_t<
!execution::detail::blocking::possibly_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::blocking::possibly_t<0>::
query_member<T>::is_valid
&& !traits::query_free<T, execution::blocking_t::possibly_t>::is_valid
&& !can_query<T, execution::blocking_t::always_t>::value
&& !can_query<T, execution::blocking_t::never_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::blocking_t::possibly_t result_type;
static constexpr result_type value()
{
return result_type();
}
};
template <typename T>
struct static_query<T, execution::blocking_t::always_t,
enable_if_t<
execution::detail::blocking::always_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::blocking::always_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::blocking::always_t<0>::
query_static_constexpr_member<T>::value();
}
};
template <typename T>
struct static_query<T, execution::blocking_t::never_t,
enable_if_t<
execution::detail::blocking::never_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::blocking::never_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::blocking::never_t<0>::
query_static_constexpr_member<T>::value();
}
};
#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
#if !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
template <typename T>
struct require_free_default<T, execution::blocking_t::always_t,
enable_if_t<
is_same<T, decay_t<T>>::value
&& execution::is_executor<T>::value
&& traits::static_require<
const T&,
execution::detail::blocking_adaptation::allowed_t<0>
>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = false;
typedef execution::detail::blocking::adapter<T> result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
template <typename Executor>
struct equality_comparable<
execution::detail::blocking::adapter<Executor>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
};
#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
template <typename Executor, typename Function>
struct execute_member<
execution::detail::blocking::adapter<Executor>, Function>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = false;
typedef void result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
template <typename Executor, int I>
struct query_static_constexpr_member<
execution::detail::blocking::adapter<Executor>,
execution::detail::blocking_t<I>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::blocking_t::always_t result_type;
static constexpr result_type value() noexcept
{
return result_type();
}
};
template <typename Executor, int I>
struct query_static_constexpr_member<
execution::detail::blocking::adapter<Executor>,
execution::detail::blocking::always_t<I>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::blocking_t::always_t result_type;
static constexpr result_type value() noexcept
{
return result_type();
}
};
template <typename Executor, int I>
struct query_static_constexpr_member<
execution::detail::blocking::adapter<Executor>,
execution::detail::blocking::possibly_t<I>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::blocking_t::always_t result_type;
static constexpr result_type value() noexcept
{
return result_type();
}
};
template <typename Executor, int I>
struct query_static_constexpr_member<
execution::detail::blocking::adapter<Executor>,
execution::detail::blocking::never_t<I>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::blocking_t::always_t result_type;
static constexpr result_type value() noexcept
{
return result_type();
}
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
template <typename Executor, typename Property>
struct query_member<
execution::detail::blocking::adapter<Executor>, Property,
enable_if_t<
can_query<const Executor&, Property>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<Executor, Property>::value;
typedef query_result_t<Executor, Property> result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
template <typename Executor, int I>
struct require_member<
execution::detail::blocking::adapter<Executor>,
execution::detail::blocking::possibly_t<I>,
enable_if_t<
can_require<
const Executor&,
execution::detail::blocking::possibly_t<I>
>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_require<const Executor&,
execution::detail::blocking::possibly_t<I>>::value;
typedef require_result_t<const Executor&,
execution::detail::blocking::possibly_t<I>> result_type;
};
template <typename Executor, int I>
struct require_member<
execution::detail::blocking::adapter<Executor>,
execution::detail::blocking::never_t<I>,
enable_if_t<
can_require<
const Executor&,
execution::detail::blocking::never_t<I>
>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_require<const Executor&,
execution::detail::blocking::never_t<I>>::value;
typedef require_result_t<const Executor&,
execution::detail::blocking::never_t<I>> result_type;
};
template <typename Executor, typename Property>
struct require_member<
execution::detail::blocking::adapter<Executor>, Property,
enable_if_t<
can_require<const Executor&, Property>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_require<Executor, Property>::value;
typedef execution::detail::blocking::adapter<
decay_t<require_result_t<Executor, Property>>> result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
template <typename Executor, typename Property>
struct prefer_member<
execution::detail::blocking::adapter<Executor>, Property,
enable_if_t<
can_prefer<const Executor&, Property>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_prefer<Executor, Property>::value;
typedef execution::detail::blocking::adapter<
decay_t<prefer_result_t<Executor, Property>>> result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
} // namespace traits
#endif // defined(GENERATING_DOCUMENTATION)
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_BLOCKING_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/executor.hpp | //
// execution/executor.hpp
// ~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_EXECUTOR_HPP
#define ASIO_EXECUTION_EXECUTOR_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/execution/invocable_archetype.hpp"
#include "asio/traits/equality_comparable.hpp"
#include "asio/traits/execute_member.hpp"
#if defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT) \
&& defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
# define ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT 1
#endif // defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
// && defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
#include "asio/detail/push_options.hpp"
namespace asio {
namespace execution {
namespace detail {
template <typename T, typename F,
typename = void, typename = void, typename = void, typename = void,
typename = void, typename = void, typename = void, typename = void>
struct is_executor_of_impl : false_type
{
};
template <typename T, typename F>
struct is_executor_of_impl<T, F,
enable_if_t<
traits::execute_member<add_const_t<T>, F>::is_valid
>,
void_t<
result_of_t<decay_t<F>&()>
>,
enable_if_t<
is_constructible<decay_t<F>, F>::value
>,
enable_if_t<
is_move_constructible<decay_t<F>>::value
>,
enable_if_t<
is_nothrow_copy_constructible<T>::value
>,
enable_if_t<
is_nothrow_destructible<T>::value
>,
enable_if_t<
traits::equality_comparable<T>::is_valid
>,
enable_if_t<
traits::equality_comparable<T>::is_noexcept
>> : true_type
{
};
} // namespace detail
/// The is_executor trait detects whether a type T satisfies the
/// execution::executor concept.
/**
* Class template @c is_executor is a UnaryTypeTrait that is derived from @c
* true_type if the type @c T meets the concept definition for an executor,
* otherwise @c false_type.
*/
template <typename T>
struct is_executor :
#if defined(GENERATING_DOCUMENTATION)
integral_constant<bool, automatically_determined>
#else // defined(GENERATING_DOCUMENTATION)
detail::is_executor_of_impl<T, invocable_archetype>
#endif // defined(GENERATING_DOCUMENTATION)
{
};
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
constexpr const bool is_executor_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
#if defined(ASIO_HAS_CONCEPTS)
template <typename T>
ASIO_CONCEPT executor = is_executor<T>::value;
#define ASIO_EXECUTION_EXECUTOR ::asio::execution::executor
#else // defined(ASIO_HAS_CONCEPTS)
#define ASIO_EXECUTION_EXECUTOR typename
#endif // defined(ASIO_HAS_CONCEPTS)
} // namespace execution
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_EXECUTOR_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/context.hpp | //
// execution/context.hpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_CONTEXT2_HPP
#define ASIO_EXECUTION_CONTEXT2_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/execution/executor.hpp"
#include "asio/is_applicable_property.hpp"
#include "asio/traits/query_static_constexpr_member.hpp"
#include "asio/traits/static_query.hpp"
#if defined(ASIO_HAS_STD_ANY)
# include <any>
#endif // defined(ASIO_HAS_STD_ANY)
#include "asio/detail/push_options.hpp"
namespace asio {
#if defined(GENERATING_DOCUMENTATION)
namespace execution {
/// A property that is used to obtain the execution context that is associated
/// with an executor.
struct context_t
{
/// The context_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The context_t property cannot be required.
static constexpr bool is_requirable = false;
/// The context_t property cannot be preferred.
static constexpr bool is_preferable = false;
/// The type returned by queries against an @c any_executor.
typedef std::any polymorphic_query_result_type;
};
/// A special value used for accessing the context_t property.
constexpr context_t context;
} // namespace execution
#else // defined(GENERATING_DOCUMENTATION)
namespace execution {
namespace detail {
template <int I = 0>
struct context_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = false;
static constexpr bool is_preferable = false;
#if defined(ASIO_HAS_STD_ANY)
typedef std::any polymorphic_query_result_type;
#endif // defined(ASIO_HAS_STD_ANY)
constexpr context_t()
{
}
template <typename T>
struct static_proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
struct type
{
template <typename P>
static constexpr auto query(P&& p)
noexcept(
noexcept(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
)
-> decltype(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
{
return T::query(static_cast<P&&>(p));
}
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename static_proxy<T>::type, context_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename E, typename T = decltype(context_t::static_query<E>())>
static constexpr const T static_query_v = context_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T context_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace detail
typedef detail::context_t<> context_t;
ASIO_INLINE_VARIABLE constexpr context_t context;
} // namespace execution
#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
struct is_applicable_property<T, execution::context_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
|| !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
struct static_query<T, execution::context_t,
enable_if_t<
execution::detail::context_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::context_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::context_t<0>::
query_static_constexpr_member<T>::value();
}
};
#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace traits
#endif // defined(GENERATING_DOCUMENTATION)
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_CONTEXT2_HPP
|
0 | repos/asio/asio/include/asio | repos/asio/asio/include/asio/execution/mapping.hpp | //
// execution/mapping.hpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_MAPPING_HPP
#define ASIO_EXECUTION_MAPPING_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/detail/type_traits.hpp"
#include "asio/execution/executor.hpp"
#include "asio/is_applicable_property.hpp"
#include "asio/query.hpp"
#include "asio/traits/query_free.hpp"
#include "asio/traits/query_member.hpp"
#include "asio/traits/query_static_constexpr_member.hpp"
#include "asio/traits/static_query.hpp"
#include "asio/traits/static_require.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
#if defined(GENERATING_DOCUMENTATION)
namespace execution {
/// A property to describe what guarantees an executor makes about the mapping
/// of execution agents on to threads of execution.
struct mapping_t
{
/// The mapping_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The top-level mapping_t property cannot be required.
static constexpr bool is_requirable = false;
/// The top-level mapping_t property cannot be preferred.
static constexpr bool is_preferable = false;
/// The type returned by queries against an @c any_executor.
typedef mapping_t polymorphic_query_result_type;
/// A sub-property that indicates that execution agents are mapped on to
/// threads of execution.
struct thread_t
{
/// The mapping_t::thread_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The mapping_t::thread_t property can be required.
static constexpr bool is_requirable = true;
/// The mapping_t::thread_t property can be preferred.
static constexpr bool is_preferable = true;
/// The type returned by queries against an @c any_executor.
typedef mapping_t polymorphic_query_result_type;
/// Default constructor.
constexpr thread_t();
/// Get the value associated with a property object.
/**
* @returns thread_t();
*/
static constexpr mapping_t value();
};
/// A sub-property that indicates that execution agents are mapped on to
/// new threads of execution.
struct new_thread_t
{
/// The mapping_t::new_thread_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The mapping_t::new_thread_t property can be required.
static constexpr bool is_requirable = true;
/// The mapping_t::new_thread_t property can be preferred.
static constexpr bool is_preferable = true;
/// The type returned by queries against an @c any_executor.
typedef mapping_t polymorphic_query_result_type;
/// Default constructor.
constexpr new_thread_t();
/// Get the value associated with a property object.
/**
* @returns new_thread_t();
*/
static constexpr mapping_t value();
};
/// A sub-property that indicates that the mapping of execution agents is
/// implementation-defined.
struct other_t
{
/// The mapping_t::other_t property applies to executors.
template <typename T>
static constexpr bool is_applicable_property_v = is_executor_v<T>;
/// The mapping_t::other_t property can be required.
static constexpr bool is_requirable = true;
/// The mapping_t::other_t property can be preferred.
static constexpr bool is_preferable = true;
/// The type returned by queries against an @c any_executor.
typedef mapping_t polymorphic_query_result_type;
/// Default constructor.
constexpr other_t();
/// Get the value associated with a property object.
/**
* @returns other_t();
*/
static constexpr mapping_t value();
};
/// A special value used for accessing the mapping_t::thread_t property.
static constexpr thread_t thread;
/// A special value used for accessing the mapping_t::new_thread_t property.
static constexpr new_thread_t new_thread;
/// A special value used for accessing the mapping_t::other_t property.
static constexpr other_t other;
/// Default constructor.
constexpr mapping_t();
/// Construct from a sub-property value.
constexpr mapping_t(thread_t);
/// Construct from a sub-property value.
constexpr mapping_t(new_thread_t);
/// Construct from a sub-property value.
constexpr mapping_t(other_t);
/// Compare property values for equality.
friend constexpr bool operator==(
const mapping_t& a, const mapping_t& b) noexcept;
/// Compare property values for inequality.
friend constexpr bool operator!=(
const mapping_t& a, const mapping_t& b) noexcept;
};
/// A special value used for accessing the mapping_t property.
constexpr mapping_t mapping;
} // namespace execution
#else // defined(GENERATING_DOCUMENTATION)
namespace execution {
namespace detail {
namespace mapping {
template <int I> struct thread_t;
template <int I> struct new_thread_t;
template <int I> struct other_t;
} // namespace mapping
template <int I = 0>
struct mapping_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = false;
static constexpr bool is_preferable = false;
typedef mapping_t polymorphic_query_result_type;
typedef detail::mapping::thread_t<I> thread_t;
typedef detail::mapping::new_thread_t<I> new_thread_t;
typedef detail::mapping::other_t<I> other_t;
constexpr mapping_t()
: value_(-1)
{
}
constexpr mapping_t(thread_t)
: value_(0)
{
}
constexpr mapping_t(new_thread_t)
: value_(1)
{
}
constexpr mapping_t(other_t)
: value_(2)
{
}
template <typename T>
struct proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
struct type
{
template <typename P>
auto query(P&& p) const
noexcept(
noexcept(
declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
)
)
-> decltype(
declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
);
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
};
template <typename T>
struct static_proxy
{
#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
struct type
{
template <typename P>
static constexpr auto query(P&& p)
noexcept(
noexcept(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
)
-> decltype(
conditional_t<true, T, P>::query(static_cast<P&&>(p))
)
{
return T::query(static_cast<P&&>(p));
}
};
#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
typedef T type;
#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
};
template <typename T>
struct query_member :
traits::query_member<typename proxy<T>::type, mapping_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename static_proxy<T>::type, mapping_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr
typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename T>
static constexpr
typename traits::static_query<T, thread_t>::result_type
static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
traits::static_query<T, thread_t>::is_valid
>* = 0) noexcept
{
return traits::static_query<T, thread_t>::value();
}
template <typename T>
static constexpr
typename traits::static_query<T, new_thread_t>::result_type
static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
!traits::static_query<T, thread_t>::is_valid
>* = 0,
enable_if_t<
traits::static_query<T, new_thread_t>::is_valid
>* = 0) noexcept
{
return traits::static_query<T, new_thread_t>::value();
}
template <typename T>
static constexpr
typename traits::static_query<T, other_t>::result_type
static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
!traits::static_query<T, thread_t>::is_valid
>* = 0,
enable_if_t<
!traits::static_query<T, new_thread_t>::is_valid
>* = 0,
enable_if_t<
traits::static_query<T, other_t>::is_valid
>* = 0) noexcept
{
return traits::static_query<T, other_t>::value();
}
template <typename E, typename T = decltype(mapping_t::static_query<E>())>
static constexpr const T static_query_v
= mapping_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
friend constexpr bool operator==(
const mapping_t& a, const mapping_t& b)
{
return a.value_ == b.value_;
}
friend constexpr bool operator!=(
const mapping_t& a, const mapping_t& b)
{
return a.value_ != b.value_;
}
struct convertible_from_mapping_t
{
constexpr convertible_from_mapping_t(mapping_t) {}
};
template <typename Executor>
friend constexpr mapping_t query(
const Executor& ex, convertible_from_mapping_t,
enable_if_t<
can_query<const Executor&, thread_t>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(is_nothrow_query<const Executor&, mapping_t<>::thread_t>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, thread_t>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, thread_t());
}
template <typename Executor>
friend constexpr mapping_t query(
const Executor& ex, convertible_from_mapping_t,
enable_if_t<
!can_query<const Executor&, thread_t>::value
>* = 0,
enable_if_t<
can_query<const Executor&, new_thread_t>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(
is_nothrow_query<const Executor&, mapping_t<>::new_thread_t>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, new_thread_t>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, new_thread_t());
}
template <typename Executor>
friend constexpr mapping_t query(
const Executor& ex, convertible_from_mapping_t,
enable_if_t<
!can_query<const Executor&, thread_t>::value
>* = 0,
enable_if_t<
!can_query<const Executor&, new_thread_t>::value
>* = 0,
enable_if_t<
can_query<const Executor&, other_t>::value
>* = 0)
#if !defined(__clang__) // Clang crashes if noexcept is used here.
#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
noexcept(is_nothrow_query<const Executor&, mapping_t<>::other_t>::value)
#else // defined(ASIO_MSVC)
noexcept(is_nothrow_query<const Executor&, other_t>::value)
#endif // defined(ASIO_MSVC)
#endif // !defined(__clang__)
{
return asio::query(ex, other_t());
}
ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(thread_t, thread);
ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(new_thread_t, new_thread);
ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(other_t, other);
private:
int value_;
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T mapping_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I>
const typename mapping_t<I>::thread_t mapping_t<I>::thread;
template <int I>
const typename mapping_t<I>::new_thread_t mapping_t<I>::new_thread;
template <int I>
const typename mapping_t<I>::other_t mapping_t<I>::other;
namespace mapping {
template <int I = 0>
struct thread_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = true;
typedef mapping_t<I> polymorphic_query_result_type;
constexpr thread_t()
{
}
template <typename T>
struct query_member :
traits::query_member<
typename mapping_t<I>::template proxy<T>::type, thread_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename mapping_t<I>::template static_proxy<T>::type, thread_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr
typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename T>
static constexpr thread_t static_query(
enable_if_t<
!query_static_constexpr_member<T>::is_valid
>* = 0,
enable_if_t<
!query_member<T>::is_valid
>* = 0,
enable_if_t<
!traits::query_free<T, thread_t>::is_valid
>* = 0,
enable_if_t<
!can_query<T, new_thread_t<I>>::value
>* = 0,
enable_if_t<
!can_query<T, other_t<I>>::value
>* = 0) noexcept
{
return thread_t();
}
template <typename E, typename T = decltype(thread_t::static_query<E>())>
static constexpr const T static_query_v
= thread_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
static constexpr mapping_t<I> value()
{
return thread_t();
}
friend constexpr bool operator==(const thread_t&, const thread_t&)
{
return true;
}
friend constexpr bool operator!=(const thread_t&, const thread_t&)
{
return false;
}
friend constexpr bool operator==(const thread_t&, const new_thread_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const thread_t&, const new_thread_t<I>&)
{
return true;
}
friend constexpr bool operator==(const thread_t&, const other_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const thread_t&, const other_t<I>&)
{
return true;
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T thread_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I = 0>
struct new_thread_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = true;
typedef mapping_t<I> polymorphic_query_result_type;
constexpr new_thread_t()
{
}
template <typename T>
struct query_member :
traits::query_member<
typename mapping_t<I>::template proxy<T>::type, new_thread_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename mapping_t<I>::template static_proxy<T>::type, new_thread_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename E, typename T = decltype(new_thread_t::static_query<E>())>
static constexpr const T static_query_v = new_thread_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
static constexpr mapping_t<I> value()
{
return new_thread_t();
}
friend constexpr bool operator==(const new_thread_t&, const new_thread_t&)
{
return true;
}
friend constexpr bool operator!=(const new_thread_t&, const new_thread_t&)
{
return false;
}
friend constexpr bool operator==(const new_thread_t&, const thread_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const new_thread_t&, const thread_t<I>&)
{
return true;
}
friend constexpr bool operator==(const new_thread_t&, const other_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const new_thread_t&, const other_t<I>&)
{
return true;
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T new_thread_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I>
struct other_t
{
#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
static constexpr bool is_applicable_property_v = is_executor<T>::value;
#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
static constexpr bool is_requirable = true;
static constexpr bool is_preferable = true;
typedef mapping_t<I> polymorphic_query_result_type;
constexpr other_t()
{
}
template <typename T>
struct query_member :
traits::query_member<
typename mapping_t<I>::template proxy<T>::type, other_t> {};
template <typename T>
struct query_static_constexpr_member :
traits::query_static_constexpr_member<
typename mapping_t<I>::template static_proxy<T>::type, other_t> {};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
static constexpr
typename query_static_constexpr_member<T>::result_type
static_query()
noexcept(query_static_constexpr_member<T>::is_noexcept)
{
return query_static_constexpr_member<T>::value();
}
template <typename E, typename T = decltype(other_t::static_query<E>())>
static constexpr const T static_query_v = other_t::static_query<E>();
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
static constexpr mapping_t<I> value()
{
return other_t();
}
friend constexpr bool operator==(const other_t&, const other_t&)
{
return true;
}
friend constexpr bool operator!=(const other_t&, const other_t&)
{
return false;
}
friend constexpr bool operator==(const other_t&, const thread_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const other_t&, const thread_t<I>&)
{
return true;
}
friend constexpr bool operator==(const other_t&, const new_thread_t<I>&)
{
return false;
}
friend constexpr bool operator!=(const other_t&, const new_thread_t<I>&)
{
return true;
}
};
#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
&& defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <int I> template <typename E, typename T>
const T other_t<I>::static_query_v;
#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace mapping
} // namespace detail
typedef detail::mapping_t<> mapping_t;
ASIO_INLINE_VARIABLE constexpr mapping_t mapping;
} // namespace execution
#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
template <typename T>
struct is_applicable_property<T, execution::mapping_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
template <typename T>
struct is_applicable_property<T, execution::mapping_t::thread_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
template <typename T>
struct is_applicable_property<T, execution::mapping_t::new_thread_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
template <typename T>
struct is_applicable_property<T, execution::mapping_t::other_t>
: integral_constant<bool, execution::is_executor<T>::value>
{
};
#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
template <typename T>
struct query_free_default<T, execution::mapping_t,
enable_if_t<
can_query<T, execution::mapping_t::thread_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<T, execution::mapping_t::thread_t>::value;
typedef execution::mapping_t result_type;
};
template <typename T>
struct query_free_default<T, execution::mapping_t,
enable_if_t<
!can_query<T, execution::mapping_t::thread_t>::value
&& can_query<T, execution::mapping_t::new_thread_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<T, execution::mapping_t::new_thread_t>::value;
typedef execution::mapping_t result_type;
};
template <typename T>
struct query_free_default<T, execution::mapping_t,
enable_if_t<
!can_query<T, execution::mapping_t::thread_t>::value
&& !can_query<T, execution::mapping_t::new_thread_t>::value
&& can_query<T, execution::mapping_t::other_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept =
is_nothrow_query<T, execution::mapping_t::other_t>::value;
typedef execution::mapping_t result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
|| !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
template <typename T>
struct static_query<T, execution::mapping_t,
enable_if_t<
execution::detail::mapping_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::mapping_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::mapping_t<0>::
query_static_constexpr_member<T>::value();
}
};
template <typename T>
struct static_query<T, execution::mapping_t,
enable_if_t<
!execution::detail::mapping_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::mapping_t<0>::
query_member<T>::is_valid
&& traits::static_query<T, execution::mapping_t::thread_t>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename traits::static_query<T,
execution::mapping_t::thread_t>::result_type result_type;
static constexpr result_type value()
{
return traits::static_query<T, execution::mapping_t::thread_t>::value();
}
};
template <typename T>
struct static_query<T, execution::mapping_t,
enable_if_t<
!execution::detail::mapping_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::mapping_t<0>::
query_member<T>::is_valid
&& !traits::static_query<T, execution::mapping_t::thread_t>::is_valid
&& traits::static_query<T, execution::mapping_t::new_thread_t>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename traits::static_query<T,
execution::mapping_t::new_thread_t>::result_type result_type;
static constexpr result_type value()
{
return traits::static_query<T, execution::mapping_t::new_thread_t>::value();
}
};
template <typename T>
struct static_query<T, execution::mapping_t,
enable_if_t<
!execution::detail::mapping_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::mapping_t<0>::
query_member<T>::is_valid
&& !traits::static_query<T, execution::mapping_t::thread_t>::is_valid
&& !traits::static_query<T, execution::mapping_t::new_thread_t>::is_valid
&& traits::static_query<T, execution::mapping_t::other_t>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename traits::static_query<T,
execution::mapping_t::other_t>::result_type result_type;
static constexpr result_type value()
{
return traits::static_query<T, execution::mapping_t::other_t>::value();
}
};
template <typename T>
struct static_query<T, execution::mapping_t::thread_t,
enable_if_t<
execution::detail::mapping::thread_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::mapping::thread_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::mapping::thread_t<0>::
query_static_constexpr_member<T>::value();
}
};
template <typename T>
struct static_query<T, execution::mapping_t::thread_t,
enable_if_t<
!execution::detail::mapping::thread_t<0>::
query_static_constexpr_member<T>::is_valid
&& !execution::detail::mapping::thread_t<0>::
query_member<T>::is_valid
&& !traits::query_free<T, execution::mapping_t::thread_t>::is_valid
&& !can_query<T, execution::mapping_t::new_thread_t>::value
&& !can_query<T, execution::mapping_t::other_t>::value
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::mapping_t::thread_t result_type;
static constexpr result_type value()
{
return result_type();
}
};
template <typename T>
struct static_query<T, execution::mapping_t::new_thread_t,
enable_if_t<
execution::detail::mapping::new_thread_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::mapping::new_thread_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::mapping::new_thread_t<0>::
query_static_constexpr_member<T>::value();
}
};
template <typename T>
struct static_query<T, execution::mapping_t::other_t,
enable_if_t<
execution::detail::mapping::other_t<0>::
query_static_constexpr_member<T>::is_valid
>>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef typename execution::detail::mapping::other_t<0>::
query_static_constexpr_member<T>::result_type result_type;
static constexpr result_type value()
{
return execution::detail::mapping::other_t<0>::
query_static_constexpr_member<T>::value();
}
};
#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
// || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
} // namespace traits
#endif // defined(GENERATING_DOCUMENTATION)
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_MAPPING_HPP
|
0 | repos/asio/asio/include/asio/execution | repos/asio/asio/include/asio/execution/impl/bad_executor.ipp | //
// exection/impl/bad_executor.ipp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef ASIO_EXECUTION_IMPL_BAD_EXECUTOR_IPP
#define ASIO_EXECUTION_IMPL_BAD_EXECUTOR_IPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include "asio/detail/config.hpp"
#include "asio/execution/bad_executor.hpp"
#include "asio/detail/push_options.hpp"
namespace asio {
namespace execution {
bad_executor::bad_executor() noexcept
{
}
const char* bad_executor::what() const noexcept
{
return "bad executor";
}
} // namespace execution
} // namespace asio
#include "asio/detail/pop_options.hpp"
#endif // ASIO_EXECUTION_IMPL_BAD_EXECUTOR_IPP
|
0 | repos/asio/asio | repos/asio/asio/src/asio.cpp | //
// asio.cpp
// ~~~~~~~~
//
// 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)
//
#include "asio/impl/src.hpp"
|
0 | repos/asio/asio | repos/asio/asio/src/asio_ssl.cpp | //
// asio_ssl.cpp
// ~~~~~~~~~~~~
//
// 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)
//
#include "asio/ssl/impl/src.hpp"
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/latency/tcp_server.cpp | //
// tcp_server.cpp
// ~~~~~~~~~~~~~~
//
// 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)
//
#include <asio/io_context.hpp>
#include <asio/ip/tcp.hpp>
#include <asio/read.hpp>
#include <asio/write.hpp>
#include <boost/shared_ptr.hpp>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
using asio::ip::tcp;
#include <asio/yield.hpp>
class tcp_server : asio::coroutine
{
public:
tcp_server(tcp::acceptor& acceptor, std::size_t buf_size) :
acceptor_(acceptor),
socket_(acceptor_.get_executor()),
buffer_(buf_size)
{
}
void operator()(asio::error_code ec, std::size_t n = 0)
{
reenter (this) for (;;)
{
yield acceptor_.async_accept(socket_, ref(this));
while (!ec)
{
yield asio::async_read(socket_,
asio::buffer(buffer_), ref(this));
if (!ec)
{
for (std::size_t i = 0; i < n; ++i) buffer_[i] = ~buffer_[i];
yield asio::async_write(socket_,
asio::buffer(buffer_), ref(this));
}
}
socket_.close();
}
}
struct ref
{
explicit ref(tcp_server* p)
: p_(p)
{
}
void operator()(asio::error_code ec, std::size_t n = 0)
{
(*p_)(ec, n);
}
private:
tcp_server* p_;
};
private:
tcp::acceptor& acceptor_;
tcp::socket socket_;
std::vector<unsigned char> buffer_;
tcp::endpoint sender_;
};
#include <asio/unyield.hpp>
int main(int argc, char* argv[])
{
if (argc != 5)
{
std::fprintf(stderr,
"Usage: tcp_server <port> <nconns> "
"<bufsize> {spin|block}\n");
return 1;
}
unsigned short port = static_cast<unsigned short>(std::atoi(argv[1]));
int max_connections = std::atoi(argv[2]);
std::size_t buf_size = std::atoi(argv[3]);
bool spin = (std::strcmp(argv[4], "spin") == 0);
asio::io_context io_context(1);
tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), port));
std::vector<boost::shared_ptr<tcp_server> > servers;
for (int i = 0; i < max_connections; ++i)
{
boost::shared_ptr<tcp_server> s(new tcp_server(acceptor, buf_size));
servers.push_back(s);
(*s)(asio::error_code());
}
if (spin)
for (;;) io_context.poll();
else
io_context.run();
}
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/latency/udp_client.cpp | //
// udp_client.cpp
// ~~~~~~~~~~~~~~
//
// 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)
//
#include <asio/ip/udp.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include "high_res_clock.hpp"
using asio::ip::udp;
using boost::posix_time::ptime;
using boost::posix_time::microsec_clock;
const int num_samples = 100000;
int main(int argc, char* argv[])
{
if (argc != 6)
{
std::fprintf(stderr,
"Usage: udp_client <ip> <port1> "
"<nports> <bufsize> {spin|block}\n");
return 1;
}
const char* ip = argv[1];
unsigned short first_port = static_cast<unsigned short>(std::atoi(argv[2]));
unsigned short num_ports = static_cast<unsigned short>(std::atoi(argv[3]));
std::size_t buf_size = static_cast<std::size_t>(std::atoi(argv[4]));
bool spin = (std::strcmp(argv[5], "spin") == 0);
asio::io_context io_context;
udp::socket socket(io_context, udp::endpoint(udp::v4(), 0));
if (spin)
{
socket.non_blocking(true);
}
udp::endpoint target(asio::ip::make_address(ip), first_port);
unsigned short last_port = first_port + num_ports - 1;
std::vector<unsigned char> write_buf(buf_size);
std::vector<unsigned char> read_buf(buf_size);
ptime start = microsec_clock::universal_time();
boost::uint64_t start_hr = high_res_clock();
boost::uint64_t samples[num_samples];
for (int i = 0; i < num_samples; ++i)
{
boost::uint64_t t = high_res_clock();
asio::error_code ec;
socket.send_to(asio::buffer(write_buf), target, 0, ec);
do socket.receive(asio::buffer(read_buf), 0, ec);
while (ec == asio::error::would_block);
samples[i] = high_res_clock() - t;
if (target.port() == last_port)
target.port(first_port);
else
target.port(target.port() + 1);
}
ptime stop = microsec_clock::universal_time();
boost::uint64_t stop_hr = high_res_clock();
boost::uint64_t elapsed_usec = (stop - start).total_microseconds();
boost::uint64_t elapsed_hr = stop_hr - start_hr;
double scale = 1.0 * elapsed_usec / elapsed_hr;
std::sort(samples, samples + num_samples);
std::printf(" 0.0%%\t%f\n", samples[0] * scale);
std::printf(" 0.1%%\t%f\n", samples[num_samples / 1000 - 1] * scale);
std::printf(" 1.0%%\t%f\n", samples[num_samples / 100 - 1] * scale);
std::printf(" 10.0%%\t%f\n", samples[num_samples / 10 - 1] * scale);
std::printf(" 20.0%%\t%f\n", samples[num_samples * 2 / 10 - 1] * scale);
std::printf(" 30.0%%\t%f\n", samples[num_samples * 3 / 10 - 1] * scale);
std::printf(" 40.0%%\t%f\n", samples[num_samples * 4 / 10 - 1] * scale);
std::printf(" 50.0%%\t%f\n", samples[num_samples * 5 / 10 - 1] * scale);
std::printf(" 60.0%%\t%f\n", samples[num_samples * 6 / 10 - 1] * scale);
std::printf(" 70.0%%\t%f\n", samples[num_samples * 7 / 10 - 1] * scale);
std::printf(" 80.0%%\t%f\n", samples[num_samples * 8 / 10 - 1] * scale);
std::printf(" 90.0%%\t%f\n", samples[num_samples * 9 / 10 - 1] * scale);
std::printf(" 99.0%%\t%f\n", samples[num_samples * 99 / 100 - 1] * scale);
std::printf(" 99.9%%\t%f\n", samples[num_samples * 999 / 1000 - 1] * scale);
std::printf("100.0%%\t%f\n", samples[num_samples - 1] * scale);
double total = 0.0;
for (int i = 0; i < num_samples; ++i) total += samples[i] * scale;
std::printf(" mean\t%f\n", total / num_samples);
}
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/latency/udp_server.cpp | //
// udp_server.cpp
// ~~~~~~~~~~~~~~
//
// 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)
//
#include <asio/io_context.hpp>
#include <asio/ip/udp.hpp>
#include <boost/shared_ptr.hpp>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include "allocator.hpp"
using asio::ip::udp;
#include <asio/yield.hpp>
class udp_server : asio::coroutine
{
public:
udp_server(asio::io_context& io_context,
unsigned short port, std::size_t buf_size) :
socket_(io_context, udp::endpoint(udp::v4(), port)),
buffer_(buf_size)
{
}
void operator()(asio::error_code ec, std::size_t n = 0)
{
reenter (this) for (;;)
{
yield socket_.async_receive_from(
asio::buffer(buffer_),
sender_, ref(this));
if (!ec)
{
for (std::size_t i = 0; i < n; ++i) buffer_[i] = ~buffer_[i];
socket_.send_to(asio::buffer(buffer_, n), sender_, 0, ec);
}
}
}
friend void* asio_handler_allocate(std::size_t n, udp_server* s)
{
return s->allocator_.allocate(n);
}
friend void asio_handler_deallocate(void* p, std::size_t, udp_server* s)
{
s->allocator_.deallocate(p);
}
struct ref
{
explicit ref(udp_server* p)
: p_(p)
{
}
void operator()(asio::error_code ec, std::size_t n = 0)
{
(*p_)(ec, n);
}
private:
udp_server* p_;
friend void* asio_handler_allocate(std::size_t n, ref* r)
{
return asio_handler_allocate(n, r->p_);
}
friend void asio_handler_deallocate(void* p, std::size_t n, ref* r)
{
asio_handler_deallocate(p, n, r->p_);
}
};
private:
udp::socket socket_;
std::vector<unsigned char> buffer_;
udp::endpoint sender_;
allocator allocator_;
};
#include <asio/unyield.hpp>
int main(int argc, char* argv[])
{
if (argc != 5)
{
std::fprintf(stderr,
"Usage: udp_server <port1> <nports> "
"<bufsize> {spin|block}\n");
return 1;
}
unsigned short first_port = static_cast<unsigned short>(std::atoi(argv[1]));
unsigned short num_ports = static_cast<unsigned short>(std::atoi(argv[2]));
std::size_t buf_size = std::atoi(argv[3]);
bool spin = (std::strcmp(argv[4], "spin") == 0);
asio::io_context io_context(1);
std::vector<boost::shared_ptr<udp_server> > servers;
for (unsigned short i = 0; i < num_ports; ++i)
{
unsigned short port = first_port + i;
boost::shared_ptr<udp_server> s(new udp_server(io_context, port, buf_size));
servers.push_back(s);
(*s)(asio::error_code());
}
if (spin)
for (;;) io_context.poll();
else
io_context.run();
}
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/latency/high_res_clock.hpp | //
// high_res_clock.hpp
// ~~~~~~~~~~~~~~~~~~
//
// 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)
//
#ifndef HIGH_RES_CLOCK_HPP
#define HIGH_RES_CLOCK_HPP
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#if defined(ASIO_WINDOWS)
inline boost::uint64_t high_res_clock()
{
LARGE_INTEGER i;
QueryPerformanceCounter(&i);
return i.QuadPart;
}
#elif defined(__GNUC__) && defined(__x86_64__)
inline boost::uint64_t high_res_clock()
{
unsigned long low, high;
__asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high));
return (((boost::uint64_t)high) << 32) | low;
}
#else
#include <boost/date_time/posix_time/posix_time_types.hpp>
inline boost::uint64_t high_res_clock()
{
boost::posix_time::ptime now =
boost::posix_time::microsec_clock::universal_time();
boost::posix_time::ptime epoch(
boost::gregorian::date(1970, 1, 1),
boost::posix_time::seconds(0));
return (now - epoch).total_microseconds();
}
#endif
#endif // HIGH_RES_CLOCK_HPP
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/latency/allocator.hpp | //
// allocator.hpp
// ~~~~~~~~~~~~~
//
// 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)
//
#ifndef ALLOCATOR_HPP
#define ALLOCATOR_HPP
#include <boost/aligned_storage.hpp>
// Represents a single connection from a client.
class allocator
{
public:
allocator()
: in_use_(false)
{
}
void* allocate(std::size_t n)
{
if (in_use_ || n >= 1024)
return ::operator new(n);
in_use_ = true;
return static_cast<void*>(&space_);
}
void deallocate(void* p)
{
if (p != static_cast<void*>(&space_))
::operator delete(p);
else
in_use_ = false;
}
private:
allocator(const allocator&);
allocator& operator=(const allocator&);
// Whether the reusable memory space is currently in use.
bool in_use_;
// The reusable memory space made available by the allocator.
boost::aligned_storage<1024>::type space_;
};
#endif // ALLOCATOR_HPP
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/latency/tcp_client.cpp | //
// tcp_client.cpp
// ~~~~~~~~~~~~~~
//
// 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)
//
#include <asio/ip/tcp.hpp>
#include <asio/read.hpp>
#include <asio/write.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <boost/shared_ptr.hpp>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include "high_res_clock.hpp"
using asio::ip::tcp;
using boost::posix_time::ptime;
using boost::posix_time::microsec_clock;
const int num_samples = 100000;
struct transfer_all
{
typedef std::size_t result_type;
std::size_t operator()(const asio::error_code& ec, std::size_t)
{
return (ec && ec != asio::error::would_block) ? 0 : ~0;
}
};
int main(int argc, char* argv[])
{
if (argc != 6)
{
std::fprintf(stderr,
"Usage: tcp_client <ip> <port> "
"<nconns> <bufsize> {spin|block}\n");
return 1;
}
const char* ip = argv[1];
unsigned short port = static_cast<unsigned short>(std::atoi(argv[2]));
int num_connections = std::atoi(argv[3]);
std::size_t buf_size = static_cast<std::size_t>(std::atoi(argv[4]));
bool spin = (std::strcmp(argv[5], "spin") == 0);
asio::io_context io_context;
std::vector<boost::shared_ptr<tcp::socket> > sockets;
for (int i = 0; i < num_connections; ++i)
{
boost::shared_ptr<tcp::socket> s(new tcp::socket(io_context));
tcp::endpoint target(asio::ip::make_address(ip), port);
s->connect(target);
s->set_option(tcp::no_delay(true));
if (spin)
{
s->non_blocking(true);
}
sockets.push_back(s);
}
std::vector<unsigned char> write_buf(buf_size);
std::vector<unsigned char> read_buf(buf_size);
ptime start = microsec_clock::universal_time();
boost::uint64_t start_hr = high_res_clock();
boost::uint64_t samples[num_samples];
for (int i = 0; i < num_samples; ++i)
{
tcp::socket& socket = *sockets[i % num_connections];
boost::uint64_t t = high_res_clock();
asio::error_code ec;
asio::write(socket,
asio::buffer(write_buf),
transfer_all(), ec);
asio::read(socket,
asio::buffer(read_buf),
transfer_all(), ec);
samples[i] = high_res_clock() - t;
}
ptime stop = microsec_clock::universal_time();
boost::uint64_t stop_hr = high_res_clock();
boost::uint64_t elapsed_usec = (stop - start).total_microseconds();
boost::uint64_t elapsed_hr = stop_hr - start_hr;
double scale = 1.0 * elapsed_usec / elapsed_hr;
std::sort(samples, samples + num_samples);
std::printf(" 0.0%%\t%f\n", samples[0] * scale);
std::printf(" 0.1%%\t%f\n", samples[num_samples / 1000 - 1] * scale);
std::printf(" 1.0%%\t%f\n", samples[num_samples / 100 - 1] * scale);
std::printf(" 10.0%%\t%f\n", samples[num_samples / 10 - 1] * scale);
std::printf(" 20.0%%\t%f\n", samples[num_samples * 2 / 10 - 1] * scale);
std::printf(" 30.0%%\t%f\n", samples[num_samples * 3 / 10 - 1] * scale);
std::printf(" 40.0%%\t%f\n", samples[num_samples * 4 / 10 - 1] * scale);
std::printf(" 50.0%%\t%f\n", samples[num_samples * 5 / 10 - 1] * scale);
std::printf(" 60.0%%\t%f\n", samples[num_samples * 6 / 10 - 1] * scale);
std::printf(" 70.0%%\t%f\n", samples[num_samples * 7 / 10 - 1] * scale);
std::printf(" 80.0%%\t%f\n", samples[num_samples * 8 / 10 - 1] * scale);
std::printf(" 90.0%%\t%f\n", samples[num_samples * 9 / 10 - 1] * scale);
std::printf(" 99.0%%\t%f\n", samples[num_samples * 99 / 100 - 1] * scale);
std::printf(" 99.9%%\t%f\n", samples[num_samples * 999 / 1000 - 1] * scale);
std::printf("100.0%%\t%f\n", samples[num_samples - 1] * scale);
double total = 0.0;
for (int i = 0; i < num_samples; ++i) total += samples[i] * scale;
std::printf(" mean\t%f\n", total / num_samples);
}
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/use_awaitable.cpp | //
// use_awaitable.cpp
// ~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/use_awaitable.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"use_awaitable",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/signal_set_base.cpp | //
// signal_set_base.cpp
// ~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/signal_set_base.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"signal_set_base",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/append.cpp | //
// append.cpp
// ~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/append.hpp"
#include "asio/bind_executor.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
#include "asio/system_timer.hpp"
#include "unit_test.hpp"
void append_test()
{
asio::io_context io1;
asio::io_context io2;
asio::system_timer timer1(io1);
int count = 0;
timer1.expires_after(asio::chrono::seconds(0));
timer1.async_wait(
asio::append(
asio::bind_executor(io2.get_executor(),
[&count](asio::error_code, int a, int b)
{
++count;
ASIO_CHECK(a == 123);
ASIO_CHECK(b == 321);
}), 123, 321));
ASIO_CHECK(count == 0);
io1.run();
ASIO_CHECK(count == 0);
io2.run();
ASIO_CHECK(count == 1);
}
ASIO_TEST_SUITE
(
"append",
ASIO_TEST_CASE(append_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/any_io_executor.cpp | //
// any_io_executor.cpp
// ~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/any_io_executor.hpp"
#include <cstring>
#include <functional>
#include "asio/system_executor.hpp"
#include "asio/thread_pool.hpp"
#include "unit_test.hpp"
using namespace asio;
namespace bindns = std;
static bool next_nothrow_new_fails = false;
void* operator new(std::size_t n,
const std::nothrow_t&) noexcept
{
if (next_nothrow_new_fails)
{
next_nothrow_new_fails = false;
return 0;
}
return ::operator new(n);
}
struct fat_executor
{
fat_executor(int id)
: id_(id)
{
std::memset(data_, 0, sizeof(data_));
}
template <typename F>
void execute(const F&) const
{
}
execution_context& query(execution::context_t) const noexcept
{
return asio::query(system_executor(), execution::context);
}
constexpr static execution::blocking_t::never_t query(
execution::blocking_t) noexcept
{
return execution::blocking.never;
}
friend bool operator==(const fat_executor& a,
const fat_executor& b) noexcept
{
return a.id_ == b.id_;
}
friend bool operator!=(const fat_executor& a,
const fat_executor& b) noexcept
{
return a.id_ != b.id_;
}
int id_;
unsigned char data_[1024];
};
namespace asio {
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
template <typename F>
struct execute_member<fat_executor, F>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = false;
typedef void result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
template <>
struct query_member<fat_executor, execution::context_t>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution_context& result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
template <typename Property>
struct query_static_constexpr_member<fat_executor, Property,
typename asio::enable_if<
asio::is_convertible<
Property,
asio::execution::blocking_t
>::value
>::type
>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
typedef execution::blocking_t::never_t result_type;
static constexpr result_type value() noexcept
{
return result_type();
}
};
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
template <>
struct equality_comparable<fat_executor>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
};
#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
} // namespace traits
} // namespace asio
void increment(int* count)
{
++(*count);
}
void any_io_executor_construction_test()
{
thread_pool pool(1);
asio::nullptr_t null_ptr = asio::nullptr_t();
asio::any_io_executor ex1;
ASIO_CHECK(ex1.target<void>() == 0);
ASIO_CHECK(ex1 == null_ptr);
asio::any_io_executor ex2(null_ptr);
ASIO_CHECK(ex2.target<void>() == 0);
ASIO_CHECK(ex2 == null_ptr);
ASIO_CHECK(ex2 == ex1);
asio::any_io_executor ex3(pool.executor());
ASIO_CHECK(ex3.target<void>() != 0);
ASIO_CHECK(ex3 != null_ptr);
ASIO_CHECK(ex3 != ex1);
asio::any_io_executor ex4(ex1);
ASIO_CHECK(ex4.target<void>() == 0);
ASIO_CHECK(ex4 == null_ptr);
ASIO_CHECK(ex4 == ex1);
asio::any_io_executor ex5(ex3);
ASIO_CHECK(ex5.target<void>() != 0);
ASIO_CHECK(ex5 != null_ptr);
ASIO_CHECK(ex5 == ex3);
asio::any_io_executor ex6 = fat_executor(1);
ASIO_CHECK(ex6.target<void>() != 0);
ASIO_CHECK(ex6 != null_ptr);
ASIO_CHECK(ex6 != ex1);
asio::any_io_executor ex7 = fat_executor(1);
ASIO_CHECK(ex7.target<void>() != 0);
ASIO_CHECK(ex7 != null_ptr);
ASIO_CHECK(ex7 != ex1);
ASIO_CHECK(ex7 == ex6);
asio::any_io_executor ex8 = fat_executor(2);
ASIO_CHECK(ex8.target<void>() != 0);
ASIO_CHECK(ex8 != null_ptr);
ASIO_CHECK(ex8 != ex1);
ASIO_CHECK(ex8 != ex6);
ASIO_CHECK(ex8 != ex7);
asio::any_io_executor ex9(ex6);
ASIO_CHECK(ex9.target<void>() != 0);
ASIO_CHECK(ex9 != null_ptr);
ASIO_CHECK(ex9 != ex1);
ASIO_CHECK(ex9 == ex6);
ASIO_CHECK(ex9 == ex7);
ASIO_CHECK(ex9 != ex8);
asio::any_io_executor ex10(std::move(ex1));
ASIO_CHECK(ex10.target<void>() == 0);
ASIO_CHECK(ex10 == null_ptr);
ASIO_CHECK(ex1.target<void>() == 0);
ASIO_CHECK(ex1 == null_ptr);
asio::any_io_executor ex11(std::move(ex3));
ASIO_CHECK(ex11.target<void>() != 0);
ASIO_CHECK(ex11 != null_ptr);
ASIO_CHECK(ex3.target<void>() == 0);
ASIO_CHECK(ex3 == null_ptr);
ASIO_CHECK(ex11 == ex5);
asio::any_io_executor ex12(std::move(ex7));
ASIO_CHECK(ex12.target<void>() != 0);
ASIO_CHECK(ex12 != null_ptr);
ASIO_CHECK(ex7.target<void>() == 0);
ASIO_CHECK(ex7 == null_ptr);
ASIO_CHECK(ex12 == ex6);
ASIO_CHECK(ex12 != ex8);
}
void any_io_executor_nothrow_construction_test()
{
thread_pool pool(1);
asio::nullptr_t null_ptr = asio::nullptr_t();
asio::any_io_executor ex1;
ASIO_CHECK(ex1.target<void>() == 0);
ASIO_CHECK(ex1 == null_ptr);
asio::any_io_executor ex2(null_ptr);
ASIO_CHECK(ex2.target<void>() == 0);
ASIO_CHECK(ex2 == null_ptr);
ASIO_CHECK(ex2 == ex1);
asio::any_io_executor ex3(std::nothrow, pool.executor());
ASIO_CHECK(ex3.target<void>() != 0);
ASIO_CHECK(ex3 != null_ptr);
ASIO_CHECK(ex3 != ex1);
asio::any_io_executor ex4(std::nothrow, ex1);
ASIO_CHECK(ex4.target<void>() == 0);
ASIO_CHECK(ex4 == null_ptr);
ASIO_CHECK(ex4 == ex1);
asio::any_io_executor ex5(std::nothrow, ex3);
ASIO_CHECK(ex5.target<void>() != 0);
ASIO_CHECK(ex5 != null_ptr);
ASIO_CHECK(ex5 == ex3);
asio::any_io_executor ex6(std::nothrow, fat_executor(1));
ASIO_CHECK(ex6.target<void>() != 0);
ASIO_CHECK(ex6 != null_ptr);
ASIO_CHECK(ex6 != ex1);
asio::any_io_executor ex7(std::nothrow, fat_executor(1));
ASIO_CHECK(ex7.target<void>() != 0);
ASIO_CHECK(ex7 != null_ptr);
ASIO_CHECK(ex7 != ex1);
ASIO_CHECK(ex7 == ex6);
asio::any_io_executor ex8(std::nothrow, fat_executor(2));
ASIO_CHECK(ex8.target<void>() != 0);
ASIO_CHECK(ex8 != null_ptr);
ASIO_CHECK(ex8 != ex1);
ASIO_CHECK(ex8 != ex6);
ASIO_CHECK(ex8 != ex7);
asio::any_io_executor ex9(std::nothrow, ex6);
ASIO_CHECK(ex9.target<void>() != 0);
ASIO_CHECK(ex9 != null_ptr);
ASIO_CHECK(ex9 != ex1);
ASIO_CHECK(ex9 == ex6);
ASIO_CHECK(ex9 == ex7);
ASIO_CHECK(ex9 != ex8);
asio::any_io_executor ex10(std::nothrow, std::move(ex1));
ASIO_CHECK(ex10.target<void>() == 0);
ASIO_CHECK(ex10 == null_ptr);
ASIO_CHECK(ex1.target<void>() == 0);
ASIO_CHECK(ex1 == null_ptr);
asio::any_io_executor ex11(std::nothrow, std::move(ex3));
ASIO_CHECK(ex11.target<void>() != 0);
ASIO_CHECK(ex11 != null_ptr);
ASIO_CHECK(ex3.target<void>() == 0);
ASIO_CHECK(ex3 == null_ptr);
ASIO_CHECK(ex11 == ex5);
asio::any_io_executor ex12(std::nothrow, std::move(ex7));
ASIO_CHECK(ex12.target<void>() != 0);
ASIO_CHECK(ex12 != null_ptr);
ASIO_CHECK(ex7.target<void>() == 0);
ASIO_CHECK(ex7 == null_ptr);
ASIO_CHECK(ex12 == ex6);
ASIO_CHECK(ex12 != ex8);
next_nothrow_new_fails = true;
asio::any_io_executor ex13(std::nothrow, fat_executor(3));
ASIO_CHECK(ex13.target<void>() == 0);
ASIO_CHECK(ex13 == null_ptr);
ASIO_CHECK(ex13 == ex1);
}
void any_io_executor_assignment_test()
{
thread_pool pool(1);
asio::nullptr_t null_ptr = asio::nullptr_t();
asio::any_io_executor ex1;
asio::any_io_executor ex2;
ex2 = null_ptr;
ASIO_CHECK(ex2.target<void>() == 0);
asio::any_io_executor ex3;
ex3 = pool.executor();
ASIO_CHECK(ex3.target<void>() != 0);
asio::any_io_executor ex4;
ex4 = ex1;
ASIO_CHECK(ex4.target<void>() == 0);
ASIO_CHECK(ex4 == ex1);
ex4 = ex3;
ASIO_CHECK(ex4.target<void>() != 0);
ASIO_CHECK(ex4 == ex3);
asio::any_io_executor ex5;
ex5 = fat_executor(1);
ASIO_CHECK(ex5.target<void>() != 0);
ASIO_CHECK(ex5 != null_ptr);
ASIO_CHECK(ex5 != ex1);
asio::any_io_executor ex6;
ex6 = fat_executor(1);
ASIO_CHECK(ex6.target<void>() != 0);
ASIO_CHECK(ex6 != null_ptr);
ASIO_CHECK(ex6 != ex1);
ASIO_CHECK(ex6 == ex5);
ex6 = fat_executor(2);
ASIO_CHECK(ex6.target<void>() != 0);
ASIO_CHECK(ex6 != null_ptr);
ASIO_CHECK(ex6 != ex1);
ASIO_CHECK(ex6 != ex5);
asio::any_io_executor ex7;
ex7 = ex5;
ASIO_CHECK(ex7.target<void>() != 0);
ASIO_CHECK(ex7 != null_ptr);
ASIO_CHECK(ex7 != ex1);
ASIO_CHECK(ex7 == ex5);
ASIO_CHECK(ex7 != ex6);
asio::any_io_executor ex8;
ex8 = std::move(ex1);
ASIO_CHECK(ex8.target<void>() == 0);
ASIO_CHECK(ex1.target<void>() == 0);
ex8 = std::move(ex3);
ASIO_CHECK(ex8.target<void>() != 0);
ASIO_CHECK(ex3.target<void>() == 0);
ASIO_CHECK(ex8 == ex4);
ex8 = std::move(ex5);
ASIO_CHECK(ex8.target<void>() != 0);
ASIO_CHECK(ex5.target<void>() == 0);
ASIO_CHECK(ex8 == ex7);
}
void any_io_executor_swap_test()
{
thread_pool pool1(1);
thread_pool pool2(1);
asio::any_io_executor ex1(pool1.executor());
asio::any_io_executor ex2(pool2.executor());
asio::any_io_executor ex3(ex1);
asio::any_io_executor ex4(ex2);
ASIO_CHECK(ex3 == ex1);
ASIO_CHECK(ex4 == ex2);
ex3.swap(ex4);
ASIO_CHECK(ex3 == ex2);
ASIO_CHECK(ex4 == ex1);
execution::swap(ex3, ex4);
ASIO_CHECK(ex3 == ex1);
ASIO_CHECK(ex4 == ex2);
}
void any_io_executor_query_test()
{
thread_pool pool(1);
asio::any_io_executor ex(pool.executor());
ASIO_CHECK(
asio::query(ex, asio::execution::blocking)
== asio::execution::blocking.possibly);
ASIO_CHECK(
asio::query(ex, asio::execution::blocking.possibly)
== asio::execution::blocking.possibly);
ASIO_CHECK(
asio::query(ex, asio::execution::outstanding_work)
== asio::execution::outstanding_work.untracked);
ASIO_CHECK(
asio::query(ex, asio::execution::outstanding_work.untracked)
== asio::execution::outstanding_work.untracked);
ASIO_CHECK(
asio::query(ex, asio::execution::relationship)
== asio::execution::relationship.fork);
ASIO_CHECK(
asio::query(ex, asio::execution::relationship.fork)
== asio::execution::relationship.fork);
}
void any_io_executor_execute_test()
{
int count = 0;
thread_pool pool(1);
asio::any_io_executor ex(pool.executor());
ex.execute(bindns::bind(increment, &count));
asio::prefer(ex, asio::execution::blocking.possibly).execute(
bindns::bind(increment, &count));
asio::require(ex, asio::execution::blocking.never).execute(
bindns::bind(increment, &count));
asio::require(
asio::prefer(ex, asio::execution::outstanding_work.tracked),
asio::execution::blocking.never
).execute(bindns::bind(increment, &count));
asio::require(
asio::prefer(ex,
asio::execution::outstanding_work.untracked),
asio::execution::blocking.never
).execute(bindns::bind(increment, &count));
asio::require(
asio::prefer(ex,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation),
asio::execution::blocking.never
).execute(bindns::bind(increment, &count));
pool.wait();
ASIO_CHECK(count == 6);
}
ASIO_TEST_SUITE
(
"any_io_executor",
ASIO_TEST_CASE(any_io_executor_construction_test)
ASIO_TEST_CASE(any_io_executor_nothrow_construction_test)
ASIO_TEST_CASE(any_io_executor_assignment_test)
ASIO_TEST_CASE(any_io_executor_swap_test)
ASIO_TEST_CASE(any_io_executor_query_test)
ASIO_TEST_CASE(any_io_executor_execute_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/system_context.cpp | //
// system_context.cpp
// ~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/system_context.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"system_context",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/associator.cpp | //
// associator.cpp
// ~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/associator.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"associator",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/consign.cpp | //
// consign.cpp
// ~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/consign.hpp"
#include "asio/bind_executor.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
#include "asio/system_timer.hpp"
#include "unit_test.hpp"
void consign_test()
{
asio::io_context io1;
asio::io_context io2;
asio::system_timer timer1(io1);
int count = 0;
timer1.expires_after(asio::chrono::seconds(0));
timer1.async_wait(
asio::consign(
asio::bind_executor(io2.get_executor(),
[&count](asio::error_code)
{
++count;
}), 123, 321));
ASIO_CHECK(count == 0);
io1.run();
ASIO_CHECK(count == 0);
io2.run();
ASIO_CHECK(count == 1);
}
ASIO_TEST_SUITE
(
"consign",
ASIO_TEST_CASE(consign_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/awaitable.cpp | //
// awaitable.cpp
// ~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/awaitable.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"awaitable",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_stream_file.cpp | //
// basic_stream_file.cpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/basic_stream_file.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_stream_file",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/cancellation_signal.cpp | //
// cancellation_signal.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/cancellation_signal.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"cancellation_signal",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/packaged_task.cpp | //
// packaged_task.cpp
// ~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/packaged_task.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"packaged_task",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/post.cpp | //
// post.cpp
// ~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/post.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"post",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/async_result.cpp | //
// async_result.cpp
// ~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/async_result.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"async_result",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/is_read_buffered.cpp | //
// is_read_buffered.cpp
// ~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/is_read_buffered.hpp"
#include "asio/buffered_read_stream.hpp"
#include "asio/buffered_write_stream.hpp"
#include "asio/io_context.hpp"
#include "asio/ip/tcp.hpp"
#include "unit_test.hpp"
using namespace std; // For memcmp, memcpy and memset.
class test_stream
{
public:
typedef asio::io_context io_context_type;
typedef test_stream lowest_layer_type;
typedef io_context_type::executor_type executor_type;
test_stream(asio::io_context& io_context)
: io_context_(io_context)
{
}
io_context_type& io_context()
{
return io_context_;
}
lowest_layer_type& lowest_layer()
{
return *this;
}
template <typename Const_Buffers>
size_t write(const Const_Buffers&)
{
return 0;
}
template <typename Const_Buffers>
size_t write(const Const_Buffers&, asio::error_code& ec)
{
ec = asio::error_code();
return 0;
}
template <typename Const_Buffers, typename Handler>
void async_write(const Const_Buffers&, Handler handler)
{
asio::error_code error;
asio::post(io_context_,
asio::detail::bind_handler(handler, error, 0));
}
template <typename Mutable_Buffers>
size_t read(const Mutable_Buffers&)
{
return 0;
}
template <typename Mutable_Buffers>
size_t read(const Mutable_Buffers&, asio::error_code& ec)
{
ec = asio::error_code();
return 0;
}
template <typename Mutable_Buffers, typename Handler>
void async_read(const Mutable_Buffers&, Handler handler)
{
asio::error_code error;
asio::post(io_context_,
asio::detail::bind_handler(handler, error, 0));
}
private:
io_context_type& io_context_;
};
void is_read_buffered_test()
{
ASIO_CHECK(!asio::is_read_buffered<
asio::ip::tcp::socket>::value);
ASIO_CHECK(!!asio::is_read_buffered<
asio::buffered_read_stream<
asio::ip::tcp::socket> >::value);
ASIO_CHECK(!asio::is_read_buffered<
asio::buffered_write_stream<
asio::ip::tcp::socket> >::value);
ASIO_CHECK(!!asio::is_read_buffered<
asio::buffered_stream<asio::ip::tcp::socket> >::value);
ASIO_CHECK(!asio::is_read_buffered<test_stream>::value);
ASIO_CHECK(!!asio::is_read_buffered<
asio::buffered_read_stream<test_stream> >::value);
ASIO_CHECK(!asio::is_read_buffered<
asio::buffered_write_stream<test_stream> >::value);
ASIO_CHECK(!!asio::is_read_buffered<
asio::buffered_stream<test_stream> >::value);
}
ASIO_TEST_SUITE
(
"is_read_buffered",
ASIO_TEST_CASE(is_read_buffered_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/buffered_write_stream.cpp | //
// buffered_write_stream.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/buffered_write_stream.hpp"
#include <cstring>
#include <functional>
#include "archetypes/async_result.hpp"
#include "asio/buffer.hpp"
#include "asio/io_context.hpp"
#include "asio/ip/tcp.hpp"
#include "asio/system_error.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_BOOST_ARRAY)
# include <boost/array.hpp>
#else // defined(ASIO_HAS_BOOST_ARRAY)
# include <array>
#endif // defined(ASIO_HAS_BOOST_ARRAY)
typedef asio::buffered_write_stream<
asio::ip::tcp::socket> stream_type;
void write_some_handler(const asio::error_code&, std::size_t)
{
}
void flush_handler(const asio::error_code&, std::size_t)
{
}
void read_some_handler(const asio::error_code&, std::size_t)
{
}
void test_compile()
{
#if defined(ASIO_HAS_BOOST_ARRAY)
using boost::array;
#else // defined(ASIO_HAS_BOOST_ARRAY)
using std::array;
#endif // defined(ASIO_HAS_BOOST_ARRAY)
using namespace asio;
try
{
io_context ioc;
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
array<asio::mutable_buffer, 2> mutable_buffers = {{
asio::buffer(mutable_char_buffer, 10),
asio::buffer(mutable_char_buffer + 10, 10) }};
array<asio::const_buffer, 2> const_buffers = {{
asio::buffer(const_char_buffer, 10),
asio::buffer(const_char_buffer + 10, 10) }};
archetypes::lazy_handler lazy;
asio::error_code ec;
stream_type stream1(ioc);
stream_type stream2(ioc, 1024);
stream_type::executor_type ex = stream1.get_executor();
(void)ex;
stream_type::lowest_layer_type& lowest_layer = stream1.lowest_layer();
(void)lowest_layer;
stream1.write_some(buffer(mutable_char_buffer));
stream1.write_some(buffer(const_char_buffer));
stream1.write_some(mutable_buffers);
stream1.write_some(const_buffers);
stream1.write_some(null_buffers());
stream1.write_some(buffer(mutable_char_buffer), ec);
stream1.write_some(buffer(const_char_buffer), ec);
stream1.write_some(mutable_buffers, ec);
stream1.write_some(const_buffers, ec);
stream1.write_some(null_buffers(), ec);
stream1.async_write_some(buffer(mutable_char_buffer), &write_some_handler);
stream1.async_write_some(buffer(const_char_buffer), &write_some_handler);
stream1.async_write_some(mutable_buffers, &write_some_handler);
stream1.async_write_some(const_buffers, &write_some_handler);
stream1.async_write_some(null_buffers(), &write_some_handler);
int i1 = stream1.async_write_some(buffer(mutable_char_buffer), lazy);
(void)i1;
int i2 = stream1.async_write_some(buffer(const_char_buffer), lazy);
(void)i2;
int i3 = stream1.async_write_some(mutable_buffers, lazy);
(void)i3;
int i4 = stream1.async_write_some(const_buffers, lazy);
(void)i4;
int i5 = stream1.async_write_some(null_buffers(), lazy);
(void)i5;
stream1.flush();
stream1.flush(ec);
stream1.async_flush(&flush_handler);
int i6 = stream1.async_flush(lazy);
(void)i6;
stream1.read_some(buffer(mutable_char_buffer));
stream1.read_some(mutable_buffers);
stream1.read_some(null_buffers());
stream1.read_some(buffer(mutable_char_buffer), ec);
stream1.read_some(mutable_buffers, ec);
stream1.read_some(null_buffers(), ec);
stream1.async_read_some(buffer(mutable_char_buffer), &read_some_handler);
stream1.async_read_some(mutable_buffers, &read_some_handler);
stream1.async_read_some(null_buffers(), &read_some_handler);
int i7 = stream1.async_read_some(buffer(mutable_char_buffer), lazy);
(void)i7;
int i8 = stream1.async_read_some(mutable_buffers, lazy);
(void)i8;
int i9 = stream1.async_read_some(null_buffers(), lazy);
(void)i9;
}
catch (std::exception&)
{
}
}
void test_sync_operations()
{
using namespace std; // For memcmp.
asio::io_context io_context;
asio::ip::tcp::acceptor acceptor(io_context,
asio::ip::tcp::endpoint(asio::ip::tcp::v4(), 0));
asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
server_endpoint.address(asio::ip::address_v4::loopback());
stream_type client_socket(io_context);
client_socket.lowest_layer().connect(server_endpoint);
stream_type server_socket(io_context);
acceptor.accept(server_socket.lowest_layer());
const char write_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const asio::const_buffer write_buf = asio::buffer(write_data);
std::size_t bytes_written = 0;
while (bytes_written < sizeof(write_data))
{
bytes_written += client_socket.write_some(
asio::buffer(write_buf + bytes_written));
client_socket.flush();
}
char read_data[sizeof(write_data)];
const asio::mutable_buffer read_buf = asio::buffer(read_data);
std::size_t bytes_read = 0;
while (bytes_read < sizeof(read_data))
{
bytes_read += server_socket.read_some(
asio::buffer(read_buf + bytes_read));
}
ASIO_CHECK(bytes_written == sizeof(write_data));
ASIO_CHECK(bytes_read == sizeof(read_data));
ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
bytes_written = 0;
while (bytes_written < sizeof(write_data))
{
bytes_written += server_socket.write_some(
asio::buffer(write_buf + bytes_written));
server_socket.flush();
}
bytes_read = 0;
while (bytes_read < sizeof(read_data))
{
bytes_read += client_socket.read_some(
asio::buffer(read_buf + bytes_read));
}
ASIO_CHECK(bytes_written == sizeof(write_data));
ASIO_CHECK(bytes_read == sizeof(read_data));
ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
server_socket.close();
asio::error_code error;
bytes_read = client_socket.read_some(
asio::buffer(read_buf), error);
ASIO_CHECK(bytes_read == 0);
ASIO_CHECK(error == asio::error::eof);
client_socket.close(error);
}
void handle_accept(const asio::error_code& e)
{
ASIO_CHECK(!e);
}
void handle_write(const asio::error_code& e,
std::size_t bytes_transferred,
std::size_t* total_bytes_written)
{
ASIO_CHECK(!e);
if (e)
throw asio::system_error(e); // Terminate test.
*total_bytes_written += bytes_transferred;
}
void handle_flush(const asio::error_code& e)
{
ASIO_CHECK(!e);
}
void handle_read(const asio::error_code& e,
std::size_t bytes_transferred,
std::size_t* total_bytes_read)
{
ASIO_CHECK(!e);
if (e)
throw asio::system_error(e); // Terminate test.
*total_bytes_read += bytes_transferred;
}
void handle_read_eof(const asio::error_code& e,
std::size_t bytes_transferred)
{
ASIO_CHECK(e == asio::error::eof);
ASIO_CHECK(bytes_transferred == 0);
}
void test_async_operations()
{
using namespace std; // For memcmp.
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context io_context;
asio::ip::tcp::acceptor acceptor(io_context,
asio::ip::tcp::endpoint(asio::ip::tcp::v4(), 0));
asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
server_endpoint.address(asio::ip::address_v4::loopback());
stream_type client_socket(io_context);
client_socket.lowest_layer().connect(server_endpoint);
stream_type server_socket(io_context);
acceptor.async_accept(server_socket.lowest_layer(), &handle_accept);
io_context.run();
io_context.restart();
const char write_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const asio::const_buffer write_buf = asio::buffer(write_data);
std::size_t bytes_written = 0;
while (bytes_written < sizeof(write_data))
{
client_socket.async_write_some(
asio::buffer(write_buf + bytes_written),
bindns::bind(handle_write, _1, _2, &bytes_written));
io_context.run();
io_context.restart();
client_socket.async_flush(
bindns::bind(handle_flush, _1));
io_context.run();
io_context.restart();
}
char read_data[sizeof(write_data)];
const asio::mutable_buffer read_buf = asio::buffer(read_data);
std::size_t bytes_read = 0;
while (bytes_read < sizeof(read_data))
{
server_socket.async_read_some(
asio::buffer(read_buf + bytes_read),
bindns::bind(handle_read, _1, _2, &bytes_read));
io_context.run();
io_context.restart();
}
ASIO_CHECK(bytes_written == sizeof(write_data));
ASIO_CHECK(bytes_read == sizeof(read_data));
ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
bytes_written = 0;
while (bytes_written < sizeof(write_data))
{
server_socket.async_write_some(
asio::buffer(write_buf + bytes_written),
bindns::bind(handle_write, _1, _2, &bytes_written));
io_context.run();
io_context.restart();
server_socket.async_flush(
bindns::bind(handle_flush, _1));
io_context.run();
io_context.restart();
}
bytes_read = 0;
while (bytes_read < sizeof(read_data))
{
client_socket.async_read_some(
asio::buffer(read_buf + bytes_read),
bindns::bind(handle_read, _1, _2, &bytes_read));
io_context.run();
io_context.restart();
}
ASIO_CHECK(bytes_written == sizeof(write_data));
ASIO_CHECK(bytes_read == sizeof(read_data));
ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
server_socket.close();
client_socket.async_read_some(asio::buffer(read_buf), handle_read_eof);
}
ASIO_TEST_SUITE
(
"buffered_write_stream",
ASIO_COMPILE_TEST_CASE(test_compile)
ASIO_TEST_CASE(test_sync_operations)
ASIO_TEST_CASE(test_async_operations)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/bind_allocator.cpp | //
// bind_allocator.cpp
// ~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/bind_allocator.hpp"
#include <functional>
#include "asio/io_context.hpp"
#include "asio/steady_timer.hpp"
#include "unit_test.hpp"
using namespace asio;
namespace bindns = std;
typedef steady_timer timer;
namespace chronons = asio::chrono;
template <typename T>
class test_allocator
{
public:
typedef T value_type;
explicit test_allocator(int* allocations)
: allocations_(allocations)
{
}
template <typename U>
test_allocator(const test_allocator<U>& other)
: allocations_(other.allocations_)
{
}
template <typename U>
struct rebind
{
typedef test_allocator<U> other;
};
bool operator==(const test_allocator&) const
{
return true;
}
bool operator!=(const test_allocator&) const
{
return false;
}
T* allocate(std::size_t n) const
{
++(*allocations_);
return static_cast<T*>(::operator new(sizeof(T) * n));
}
void deallocate(T* p, std::size_t /*n*/) const
{
--(*allocations_);
::operator delete(p);
}
//private:
int* allocations_;
};
void increment(int* count)
{
++(*count);
}
void bind_allocator_to_function_object_test()
{
io_context ioc;
int count = 0;
int allocations = 0;
timer t(ioc, chronons::seconds(1));
t.async_wait(
bind_allocator(
test_allocator<int>(&allocations),
bindns::bind(&increment, &count)));
ASIO_CHECK(count == 0);
ASIO_CHECK(allocations == 1);
ioc.run();
ASIO_CHECK(count == 1);
ASIO_CHECK(allocations == 0);
t.async_wait(
bind_allocator(
test_allocator<int>(&allocations),
bind_allocator(
std::allocator<void>(),
bindns::bind(&increment, &count))));
ASIO_CHECK(count == 1);
ASIO_CHECK(allocations == 1);
ioc.restart();
ioc.run();
ASIO_CHECK(count == 2);
ASIO_CHECK(allocations == 0);
}
struct incrementer_token_v1
{
explicit incrementer_token_v1(int* c) : count(c) {}
int* count;
};
struct incrementer_handler_v1
{
explicit incrementer_handler_v1(incrementer_token_v1 t) : count(t.count) {}
void operator()(asio::error_code){ increment(count); }
int* count;
};
namespace asio {
template <>
class async_result<incrementer_token_v1, void(asio::error_code)>
{
public:
typedef incrementer_handler_v1 completion_handler_type;
typedef void return_type;
explicit async_result(completion_handler_type&) {}
return_type get() {}
};
} // namespace asio
void bind_allocator_to_completion_token_v1_test()
{
io_context ioc;
int count = 0;
int allocations = 0;
timer t(ioc, chronons::seconds(1));
t.async_wait(
bind_allocator(
test_allocator<int>(&allocations),
incrementer_token_v1(&count)));
ASIO_CHECK(count == 0);
ASIO_CHECK(allocations == 1);
ioc.run();
ASIO_CHECK(count == 1);
ASIO_CHECK(allocations == 0);
}
struct incrementer_token_v2
{
explicit incrementer_token_v2(int* c) : count(c) {}
int* count;
};
namespace asio {
template <>
class async_result<incrementer_token_v2, void(asio::error_code)>
{
public:
#if !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
typedef void return_type;
#endif // !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
template <typename Initiation, typename... Args>
static void initiate(Initiation initiation,
incrementer_token_v2 token, Args&&... args)
{
initiation(bindns::bind(&increment, token.count),
static_cast<Args&&>(args)...);
}
};
} // namespace asio
void bind_allocator_to_completion_token_v2_test()
{
io_context ioc;
int count = 0;
int allocations = 0;
timer t(ioc, chronons::seconds(1));
t.async_wait(
bind_allocator(
test_allocator<int>(&allocations),
incrementer_token_v2(&count)));
ASIO_CHECK(count == 0);
ASIO_CHECK(allocations == 1);
ioc.run();
ASIO_CHECK(count == 1);
ASIO_CHECK(allocations == 0);
}
void partial_bind_allocator_test()
{
io_context ioc;
int count = 0;
int allocations = 0;
timer t(ioc, chronons::seconds(1));
t.async_wait(bind_allocator(test_allocator<int>(&allocations)))(
bindns::bind(&increment, &count));
ASIO_CHECK(count == 0);
ASIO_CHECK(allocations == 1);
ioc.run();
ASIO_CHECK(count == 1);
ASIO_CHECK(allocations == 0);
t.expires_after(chronons::seconds(1));
t.async_wait()(
bind_allocator(test_allocator<int>(&allocations)))(
incrementer_token_v2(&count));
ASIO_CHECK(count == 0);
ASIO_CHECK(allocations == 1);
ioc.restart();
ioc.run();
ASIO_CHECK(count == 1);
ASIO_CHECK(allocations == 0);
}
ASIO_TEST_SUITE
(
"bind_allocator",
ASIO_TEST_CASE(bind_allocator_to_function_object_test)
ASIO_TEST_CASE(bind_allocator_to_completion_token_v1_test)
ASIO_TEST_CASE(bind_allocator_to_completion_token_v2_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/read_until.cpp | //
// read_until.cpp
// ~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/read_until.hpp"
#include <cstring>
#include <functional>
#include "archetypes/async_result.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
#include "asio/streambuf.hpp"
#include "unit_test.hpp"
class test_stream
{
public:
typedef asio::io_context::executor_type executor_type;
test_stream(asio::io_context& io_context)
: io_context_(io_context),
length_(0),
position_(0),
next_read_length_(0)
{
}
executor_type get_executor() noexcept
{
return io_context_.get_executor();
}
void reset(const void* data, size_t length)
{
using namespace std; // For memcpy.
ASIO_CHECK(length <= max_length);
memcpy(data_, data, length);
length_ = length;
position_ = 0;
next_read_length_ = length;
}
void next_read_length(size_t length)
{
next_read_length_ = length;
}
template <typename Mutable_Buffers>
size_t read_some(const Mutable_Buffers& buffers)
{
size_t n = asio::buffer_copy(buffers,
asio::buffer(data_, length_) + position_,
next_read_length_);
position_ += n;
return n;
}
template <typename Mutable_Buffers>
size_t read_some(const Mutable_Buffers& buffers,
asio::error_code& ec)
{
ec = asio::error_code();
return read_some(buffers);
}
template <typename Mutable_Buffers, typename Handler>
void async_read_some(const Mutable_Buffers& buffers, Handler handler)
{
size_t bytes_transferred = read_some(buffers);
asio::post(get_executor(),
asio::detail::bind_handler(
static_cast<Handler&&>(handler),
asio::error_code(), bytes_transferred));
}
private:
asio::io_context& io_context_;
enum { max_length = 8192 };
char data_[max_length];
size_t length_;
size_t position_;
size_t next_read_length_;
};
static const char read_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
void test_dynamic_string_read_until_char()
{
asio::io_context ioc;
test_stream s(ioc);
std::string data1, data2;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb1 = asio::dynamic_buffer(data1);
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb2 = asio::dynamic_buffer(data2, 25);
asio::error_code ec;
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
std::size_t length = asio::read_until(s, sb1, 'Z');
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, 'Z');
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, 'Z');
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, 'Z', ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, 'Z', ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, 'Z', ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, 'Z', ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, 'Z', ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, 'Z', ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, 'Y', ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, 'Y', ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, 'Y', ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
}
void test_streambuf_read_until_char()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb1;
asio::streambuf sb2(25);
asio::error_code ec;
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
std::size_t length = asio::read_until(s, sb1, 'Z');
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, 'Z');
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, 'Z');
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, 'Z', ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, 'Z', ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, 'Z', ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, 'Z', ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, 'Z', ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, 'Z', ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, 'Y', ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, 'Y', ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, 'Y', ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
void test_dynamic_string_read_until_string()
{
asio::io_context ioc;
test_stream s(ioc);
std::string data1, data2;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb1 = asio::dynamic_buffer(data1);
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb2 = asio::dynamic_buffer(data2, 25);
asio::error_code ec;
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
std::size_t length = asio::read_until(s, sb1, "XYZ");
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, "XYZ");
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, "XYZ");
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, "XYZ", ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, "XYZ", ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, "XYZ", ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, "XYZ", ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, "XYZ", ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, "XYZ", ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, "WXY", ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, "WXY", ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, "WXY", ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
}
void test_streambuf_read_until_string()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb1;
asio::streambuf sb2(25);
asio::error_code ec;
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
std::size_t length = asio::read_until(s, sb1, "XYZ");
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, "XYZ");
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, "XYZ");
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, "XYZ", ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, "XYZ", ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, "XYZ", ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, "XYZ", ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, "XYZ", ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, "XYZ", ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, "WXY", ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, "WXY", ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, "WXY", ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
class match_char
{
public:
explicit match_char(char c) : c_(c) {}
template <typename Iterator>
std::pair<Iterator, bool> operator()(
Iterator begin, Iterator end) const
{
Iterator i = begin;
while (i != end)
if (c_ == *i++)
return std::make_pair(i, true);
return std::make_pair(i, false);
}
private:
char c_;
};
namespace asio {
template <> struct is_match_condition<match_char>
{
enum { value = true };
};
} // namespace asio
void test_dynamic_string_read_until_match_condition()
{
asio::io_context ioc;
test_stream s(ioc);
std::string data1, data2;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb1 = asio::dynamic_buffer(data1);
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb2 = asio::dynamic_buffer(data2, 25);
asio::error_code ec;
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
std::size_t length = asio::read_until(s, sb1, match_char('Z'));
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, match_char('Z'));
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, match_char('Z'));
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, match_char('Z'), ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, match_char('Z'), ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, match_char('Z'), ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, match_char('Z'), ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, match_char('Z'), ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, match_char('Z'), ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, match_char('Y'), ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, match_char('Y'), ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, match_char('Y'), ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
}
void test_streambuf_read_until_match_condition()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb1;
asio::streambuf sb2(25);
asio::error_code ec;
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
std::size_t length = asio::read_until(s, sb1, match_char('Z'));
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, match_char('Z'));
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, match_char('Z'));
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, match_char('Z'), ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, match_char('Z'), ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb1.consume(sb1.size());
length = asio::read_until(s, sb1, match_char('Z'), ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, match_char('Z'), ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, match_char('Z'), ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, match_char('Z'), ec);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, match_char('Y'), ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, match_char('Y'), ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb2.consume(sb2.size());
length = asio::read_until(s, sb2, match_char('Y'), ec);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
void async_read_handler(
const asio::error_code& err, asio::error_code* err_out,
std::size_t bytes_transferred, std::size_t* bytes_out, bool* called)
{
*err_out = err;
*bytes_out = bytes_transferred;
*called = true;
}
void test_dynamic_string_async_read_until_char()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
std::string data1, data2;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb1 = asio::dynamic_buffer(data1);
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb2 = asio::dynamic_buffer(data2, 25);
asio::error_code ec;
std::size_t length;
bool called;
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, 'Z',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, 'Z',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, 'Z',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Z',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Z',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Z',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Y',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Y',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Y',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
int i = asio::async_read_until(s, sb2, 'Y',
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Y')(
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
}
void test_streambuf_async_read_until_char()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb1;
asio::streambuf sb2(25);
asio::error_code ec;
std::size_t length;
bool called;
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, 'Z',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, 'Z',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, 'Z',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Z',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Z',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Z',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Y',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Y',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Y',
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
int i = asio::async_read_until(s, sb2, 'Y',
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, 'Y')(
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
void test_dynamic_string_async_read_until_string()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
std::string data1, data2;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb1 = asio::dynamic_buffer(data1);
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb2 = asio::dynamic_buffer(data2, 25);
asio::error_code ec;
std::size_t length;
bool called;
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, "XYZ",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, "XYZ",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, "XYZ",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "XYZ",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "XYZ",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "XYZ",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "WXY",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "WXY",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "WXY",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
int i = asio::async_read_until(s, sb2, "WXY",
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "WXY")(
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
}
void test_streambuf_async_read_until_string()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb1;
asio::streambuf sb2(25);
asio::error_code ec;
std::size_t length;
bool called;
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, "XYZ",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, "XYZ",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, "XYZ",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "XYZ",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "XYZ",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "XYZ",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "WXY",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "WXY",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "WXY",
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
int i = asio::async_read_until(s, sb2, "WXY",
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, "WXY")(
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
void test_dynamic_string_async_read_until_match_condition()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
std::string data1, data2;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb1 = asio::dynamic_buffer(data1);
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb2 = asio::dynamic_buffer(data2, 25);
asio::error_code ec;
std::size_t length;
bool called;
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, match_char('Z'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, match_char('Z'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, match_char('Z'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Z'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Z'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Z'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Y'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Y'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Y'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
int i = asio::async_read_until(s, sb2, match_char('Y'),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Y'))(
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
}
void test_streambuf_async_read_until_match_condition()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb1;
asio::streambuf sb2(25);
asio::error_code ec;
std::size_t length;
bool called;
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, match_char('Z'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, match_char('Z'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb1.consume(sb1.size());
asio::async_read_until(s, sb1, match_char('Z'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 26);
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Z'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Z'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Z'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(ec == asio::error::not_found);
ASIO_CHECK(length == 0);
s.reset(read_data, sizeof(read_data));
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Y'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Y'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Y'),
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
s.reset(read_data, sizeof(read_data));
sb2.consume(sb2.size());
int i = asio::async_read_until(s, sb2, match_char('Y'),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
ec = asio::error_code();
length = 0;
called = false;
sb2.consume(sb2.size());
asio::async_read_until(s, sb2, match_char('Y'))(
bindns::bind(async_read_handler, _1, &ec,
_2, &length, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(!ec);
ASIO_CHECK(length == 25);
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
ASIO_TEST_SUITE
(
"read_until",
ASIO_TEST_CASE(test_dynamic_string_read_until_char)
ASIO_TEST_CASE(test_streambuf_read_until_char)
ASIO_TEST_CASE(test_dynamic_string_read_until_string)
ASIO_TEST_CASE(test_streambuf_read_until_string)
ASIO_TEST_CASE(test_dynamic_string_read_until_match_condition)
ASIO_TEST_CASE(test_streambuf_read_until_match_condition)
ASIO_TEST_CASE(test_dynamic_string_async_read_until_char)
ASIO_TEST_CASE(test_streambuf_async_read_until_char)
ASIO_TEST_CASE(test_dynamic_string_async_read_until_string)
ASIO_TEST_CASE(test_streambuf_async_read_until_string)
ASIO_TEST_CASE(test_dynamic_string_async_read_until_match_condition)
ASIO_TEST_CASE(test_streambuf_async_read_until_match_condition)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/any_completion_executor.cpp | //
// any_completion_executor.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/any_completion_executor.hpp"
#include <cstring>
#include <functional>
#include "asio/system_executor.hpp"
#include "asio/thread_pool.hpp"
#include "unit_test.hpp"
using namespace asio;
namespace bindns = std;
static bool next_nothrow_new_fails = false;
void* operator new(std::size_t n,
const std::nothrow_t&) noexcept
{
if (next_nothrow_new_fails)
{
next_nothrow_new_fails = false;
return 0;
}
return ::operator new(n);
}
struct fat_executor
{
fat_executor(int id)
: id_(id)
{
std::memset(data_, 0, sizeof(data_));
}
template <typename F>
void execute(const F&) const
{
}
friend bool operator==(const fat_executor& a,
const fat_executor& b) noexcept
{
return a.id_ == b.id_;
}
friend bool operator!=(const fat_executor& a,
const fat_executor& b) noexcept
{
return a.id_ != b.id_;
}
int id_;
unsigned char data_[1024];
};
namespace asio {
namespace traits {
#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
template <typename F>
struct execute_member<fat_executor, F>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = false;
typedef void result_type;
};
#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
template <>
struct equality_comparable<fat_executor>
{
static constexpr bool is_valid = true;
static constexpr bool is_noexcept = true;
};
#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
} // namespace traits
} // namespace asio
void increment(int* count)
{
++(*count);
}
void any_completion_executor_construction_test()
{
thread_pool pool(1);
asio::nullptr_t null_ptr = asio::nullptr_t();
asio::any_completion_executor ex1;
ASIO_CHECK(ex1.target<void>() == 0);
ASIO_CHECK(ex1 == null_ptr);
asio::any_completion_executor ex2(null_ptr);
ASIO_CHECK(ex2.target<void>() == 0);
ASIO_CHECK(ex2 == null_ptr);
ASIO_CHECK(ex2 == ex1);
asio::any_completion_executor ex3(pool.executor());
ASIO_CHECK(ex3.target<void>() != 0);
ASIO_CHECK(ex3 != null_ptr);
ASIO_CHECK(ex3 != ex1);
asio::any_completion_executor ex4(ex1);
ASIO_CHECK(ex4.target<void>() == 0);
ASIO_CHECK(ex4 == null_ptr);
ASIO_CHECK(ex4 == ex1);
asio::any_completion_executor ex5(ex3);
ASIO_CHECK(ex5.target<void>() != 0);
ASIO_CHECK(ex5 != null_ptr);
ASIO_CHECK(ex5 == ex3);
asio::any_completion_executor ex6 = fat_executor(1);
ASIO_CHECK(ex6.target<void>() != 0);
ASIO_CHECK(ex6 != null_ptr);
ASIO_CHECK(ex6 != ex1);
asio::any_completion_executor ex7 = fat_executor(1);
ASIO_CHECK(ex7.target<void>() != 0);
ASIO_CHECK(ex7 != null_ptr);
ASIO_CHECK(ex7 != ex1);
ASIO_CHECK(ex7 == ex6);
asio::any_completion_executor ex8 = fat_executor(2);
ASIO_CHECK(ex8.target<void>() != 0);
ASIO_CHECK(ex8 != null_ptr);
ASIO_CHECK(ex8 != ex1);
ASIO_CHECK(ex8 != ex6);
ASIO_CHECK(ex8 != ex7);
asio::any_completion_executor ex9(ex6);
ASIO_CHECK(ex9.target<void>() != 0);
ASIO_CHECK(ex9 != null_ptr);
ASIO_CHECK(ex9 != ex1);
ASIO_CHECK(ex9 == ex6);
ASIO_CHECK(ex9 == ex7);
ASIO_CHECK(ex9 != ex8);
asio::any_completion_executor ex10(std::move(ex1));
ASIO_CHECK(ex10.target<void>() == 0);
ASIO_CHECK(ex10 == null_ptr);
ASIO_CHECK(ex1.target<void>() == 0);
ASIO_CHECK(ex1 == null_ptr);
asio::any_completion_executor ex11(std::move(ex3));
ASIO_CHECK(ex11.target<void>() != 0);
ASIO_CHECK(ex11 != null_ptr);
ASIO_CHECK(ex3.target<void>() == 0);
ASIO_CHECK(ex3 == null_ptr);
ASIO_CHECK(ex11 == ex5);
asio::any_completion_executor ex12(std::move(ex7));
ASIO_CHECK(ex12.target<void>() != 0);
ASIO_CHECK(ex12 != null_ptr);
ASIO_CHECK(ex7.target<void>() == 0);
ASIO_CHECK(ex7 == null_ptr);
ASIO_CHECK(ex12 == ex6);
ASIO_CHECK(ex12 != ex8);
}
void any_completion_executor_nothrow_construction_test()
{
thread_pool pool(1);
asio::nullptr_t null_ptr = asio::nullptr_t();
asio::any_completion_executor ex1;
ASIO_CHECK(ex1.target<void>() == 0);
ASIO_CHECK(ex1 == null_ptr);
asio::any_completion_executor ex2(null_ptr);
ASIO_CHECK(ex2.target<void>() == 0);
ASIO_CHECK(ex2 == null_ptr);
ASIO_CHECK(ex2 == ex1);
asio::any_completion_executor ex3(std::nothrow, pool.executor());
ASIO_CHECK(ex3.target<void>() != 0);
ASIO_CHECK(ex3 != null_ptr);
ASIO_CHECK(ex3 != ex1);
asio::any_completion_executor ex4(std::nothrow, ex1);
ASIO_CHECK(ex4.target<void>() == 0);
ASIO_CHECK(ex4 == null_ptr);
ASIO_CHECK(ex4 == ex1);
asio::any_completion_executor ex5(std::nothrow, ex3);
ASIO_CHECK(ex5.target<void>() != 0);
ASIO_CHECK(ex5 != null_ptr);
ASIO_CHECK(ex5 == ex3);
asio::any_completion_executor ex6(std::nothrow, fat_executor(1));
ASIO_CHECK(ex6.target<void>() != 0);
ASIO_CHECK(ex6 != null_ptr);
ASIO_CHECK(ex6 != ex1);
asio::any_completion_executor ex7(std::nothrow, fat_executor(1));
ASIO_CHECK(ex7.target<void>() != 0);
ASIO_CHECK(ex7 != null_ptr);
ASIO_CHECK(ex7 != ex1);
ASIO_CHECK(ex7 == ex6);
asio::any_completion_executor ex8(std::nothrow, fat_executor(2));
ASIO_CHECK(ex8.target<void>() != 0);
ASIO_CHECK(ex8 != null_ptr);
ASIO_CHECK(ex8 != ex1);
ASIO_CHECK(ex8 != ex6);
ASIO_CHECK(ex8 != ex7);
asio::any_completion_executor ex9(std::nothrow, ex6);
ASIO_CHECK(ex9.target<void>() != 0);
ASIO_CHECK(ex9 != null_ptr);
ASIO_CHECK(ex9 != ex1);
ASIO_CHECK(ex9 == ex6);
ASIO_CHECK(ex9 == ex7);
ASIO_CHECK(ex9 != ex8);
asio::any_completion_executor ex10(std::nothrow, std::move(ex1));
ASIO_CHECK(ex10.target<void>() == 0);
ASIO_CHECK(ex10 == null_ptr);
ASIO_CHECK(ex1.target<void>() == 0);
ASIO_CHECK(ex1 == null_ptr);
asio::any_completion_executor ex11(std::nothrow, std::move(ex3));
ASIO_CHECK(ex11.target<void>() != 0);
ASIO_CHECK(ex11 != null_ptr);
ASIO_CHECK(ex3.target<void>() == 0);
ASIO_CHECK(ex3 == null_ptr);
ASIO_CHECK(ex11 == ex5);
asio::any_completion_executor ex12(std::nothrow, std::move(ex7));
ASIO_CHECK(ex12.target<void>() != 0);
ASIO_CHECK(ex12 != null_ptr);
ASIO_CHECK(ex7.target<void>() == 0);
ASIO_CHECK(ex7 == null_ptr);
ASIO_CHECK(ex12 == ex6);
ASIO_CHECK(ex12 != ex8);
next_nothrow_new_fails = true;
asio::any_completion_executor ex13(std::nothrow, fat_executor(3));
ASIO_CHECK(ex13.target<void>() == 0);
ASIO_CHECK(ex13 == null_ptr);
ASIO_CHECK(ex13 == ex1);
}
void any_completion_executor_assignment_test()
{
thread_pool pool(1);
asio::nullptr_t null_ptr = asio::nullptr_t();
asio::any_completion_executor ex1;
asio::any_completion_executor ex2;
ex2 = null_ptr;
ASIO_CHECK(ex2.target<void>() == 0);
asio::any_completion_executor ex3;
ex3 = pool.executor();
ASIO_CHECK(ex3.target<void>() != 0);
asio::any_completion_executor ex4;
ex4 = ex1;
ASIO_CHECK(ex4.target<void>() == 0);
ASIO_CHECK(ex4 == ex1);
ex4 = ex3;
ASIO_CHECK(ex4.target<void>() != 0);
ASIO_CHECK(ex4 == ex3);
asio::any_completion_executor ex5;
ex5 = fat_executor(1);
ASIO_CHECK(ex5.target<void>() != 0);
ASIO_CHECK(ex5 != null_ptr);
ASIO_CHECK(ex5 != ex1);
asio::any_completion_executor ex6;
ex6 = fat_executor(1);
ASIO_CHECK(ex6.target<void>() != 0);
ASIO_CHECK(ex6 != null_ptr);
ASIO_CHECK(ex6 != ex1);
ASIO_CHECK(ex6 == ex5);
ex6 = fat_executor(2);
ASIO_CHECK(ex6.target<void>() != 0);
ASIO_CHECK(ex6 != null_ptr);
ASIO_CHECK(ex6 != ex1);
ASIO_CHECK(ex6 != ex5);
asio::any_completion_executor ex7;
ex7 = ex5;
ASIO_CHECK(ex7.target<void>() != 0);
ASIO_CHECK(ex7 != null_ptr);
ASIO_CHECK(ex7 != ex1);
ASIO_CHECK(ex7 == ex5);
ASIO_CHECK(ex7 != ex6);
asio::any_completion_executor ex8;
ex8 = std::move(ex1);
ASIO_CHECK(ex8.target<void>() == 0);
ASIO_CHECK(ex1.target<void>() == 0);
ex8 = std::move(ex3);
ASIO_CHECK(ex8.target<void>() != 0);
ASIO_CHECK(ex3.target<void>() == 0);
ASIO_CHECK(ex8 == ex4);
ex8 = std::move(ex5);
ASIO_CHECK(ex8.target<void>() != 0);
ASIO_CHECK(ex5.target<void>() == 0);
ASIO_CHECK(ex8 == ex7);
}
void any_completion_executor_swap_test()
{
thread_pool pool1(1);
thread_pool pool2(1);
asio::any_completion_executor ex1(pool1.executor());
asio::any_completion_executor ex2(pool2.executor());
asio::any_completion_executor ex3(ex1);
asio::any_completion_executor ex4(ex2);
ASIO_CHECK(ex3 == ex1);
ASIO_CHECK(ex4 == ex2);
ex3.swap(ex4);
ASIO_CHECK(ex3 == ex2);
ASIO_CHECK(ex4 == ex1);
execution::swap(ex3, ex4);
ASIO_CHECK(ex3 == ex1);
ASIO_CHECK(ex4 == ex2);
}
void any_completion_executor_query_test()
{
thread_pool pool(1);
asio::any_completion_executor ex(pool.executor());
ASIO_CHECK(
asio::query(ex, asio::execution::blocking)
== asio::execution::blocking.possibly);
ASIO_CHECK(
asio::query(ex, asio::execution::blocking.possibly)
== asio::execution::blocking.possibly);
ASIO_CHECK(
asio::query(ex, asio::execution::outstanding_work)
== asio::execution::outstanding_work.untracked);
ASIO_CHECK(
asio::query(ex, asio::execution::outstanding_work.untracked)
== asio::execution::outstanding_work.untracked);
ASIO_CHECK(
asio::query(ex, asio::execution::relationship)
== asio::execution::relationship.fork);
ASIO_CHECK(
asio::query(ex, asio::execution::relationship.fork)
== asio::execution::relationship.fork);
}
void any_completion_executor_execute_test()
{
int count = 0;
thread_pool pool(1);
asio::any_completion_executor ex(pool.executor());
ex.execute(bindns::bind(increment, &count));
asio::prefer(ex, asio::execution::blocking.possibly).execute(
bindns::bind(increment, &count));
asio::prefer(ex,
asio::execution::blocking.possibly,
asio::execution::outstanding_work.tracked
).execute(bindns::bind(increment, &count));
asio::prefer(ex,
asio::execution::blocking.possibly,
asio::execution::outstanding_work.untracked
).execute(bindns::bind(increment, &count));
asio::prefer(ex,
asio::execution::blocking.possibly,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation
).execute(bindns::bind(increment, &count));
pool.wait();
ASIO_CHECK(count == 5);
}
ASIO_TEST_SUITE
(
"any_completion_executor",
ASIO_TEST_CASE(any_completion_executor_construction_test)
ASIO_TEST_CASE(any_completion_executor_nothrow_construction_test)
ASIO_TEST_CASE(any_completion_executor_assignment_test)
ASIO_TEST_CASE(any_completion_executor_swap_test)
ASIO_TEST_CASE(any_completion_executor_query_test)
ASIO_TEST_CASE(any_completion_executor_execute_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/redirect_error.cpp | //
// redirect_error.cpp
// ~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/redirect_error.hpp"
#include "asio/bind_executor.hpp"
#include "asio/deferred.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
#include "asio/system_timer.hpp"
#include "asio/use_future.hpp"
#include "unit_test.hpp"
struct redirect_error_handler
{
int* count_;
explicit redirect_error_handler(int* c)
: count_(c)
{
}
void operator()()
{
++(*count_);
}
};
void redirect_error_test()
{
asio::io_context io1;
asio::io_context io2;
asio::system_timer timer1(io1);
asio::error_code ec = asio::error::would_block;
int count = 0;
timer1.expires_after(asio::chrono::seconds(0));
timer1.async_wait(
asio::redirect_error(
asio::bind_executor(io2.get_executor(),
redirect_error_handler(&count)), ec));
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(count == 0);
io1.run();
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(count == 0);
io2.run();
ASIO_CHECK(!ec);
ASIO_CHECK(count == 1);
ec = asio::error::would_block;
timer1.async_wait(
asio::redirect_error(
asio::bind_executor(io2.get_executor(),
asio::deferred), ec))(redirect_error_handler(&count));
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(count == 1);
io1.restart();
io1.run();
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(count == 1);
io2.restart();
io2.run();
ASIO_CHECK(!ec);
ASIO_CHECK(count == 2);
#if defined(ASIO_HAS_STD_FUTURE_CLASS)
ec = asio::error::would_block;
std::future<void> f = timer1.async_wait(
asio::redirect_error(
asio::bind_executor(io2.get_executor(),
asio::use_future), ec));
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
== std::future_status::timeout);
io1.restart();
io1.run();
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
== std::future_status::timeout);
io2.restart();
io2.run();
ASIO_CHECK(!ec);
ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
== std::future_status::ready);
#endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
}
void partial_redirect_error_test()
{
asio::io_context io1;
asio::io_context io2;
asio::system_timer timer1(io1);
asio::error_code ec = asio::error::would_block;
int count = 0;
timer1.expires_after(asio::chrono::seconds(0));
timer1.async_wait(asio::redirect_error(ec))(
asio::bind_executor(io2.get_executor(),
redirect_error_handler(&count)));
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(count == 0);
io1.run();
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(count == 0);
io2.run();
ASIO_CHECK(!ec);
ASIO_CHECK(count == 1);
ec = asio::error::would_block;
timer1.async_wait(asio::redirect_error(ec))(
asio::bind_executor(io2.get_executor(),
asio::deferred))(redirect_error_handler(&count));
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(count == 1);
io1.restart();
io1.run();
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(count == 1);
io2.restart();
io2.run();
ASIO_CHECK(!ec);
ASIO_CHECK(count == 2);
ec = asio::error::would_block;
timer1.async_wait()(asio::redirect_error(ec))(
asio::bind_executor(io2.get_executor(),
asio::deferred))(redirect_error_handler(&count));
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(count == 2);
io1.restart();
io1.run();
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(count == 2);
io2.restart();
io2.run();
ASIO_CHECK(!ec);
ASIO_CHECK(count == 3);
#if defined(ASIO_HAS_STD_FUTURE_CLASS)
ec = asio::error::would_block;
std::future<void> f = timer1.async_wait(asio::redirect_error(ec))(
asio::bind_executor(io2.get_executor(), asio::use_future));
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
== std::future_status::timeout);
io1.restart();
io1.run();
ASIO_CHECK(ec == asio::error::would_block);
ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
== std::future_status::timeout);
io2.restart();
io2.run();
ASIO_CHECK(!ec);
ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
== std::future_status::ready);
#endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
}
ASIO_TEST_SUITE
(
"redirect_error",
ASIO_TEST_CASE(redirect_error_test)
ASIO_TEST_CASE(partial_redirect_error_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/as_tuple.cpp | //
// as_tuple.cpp
// ~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/as_tuple.hpp"
#include "asio/bind_executor.hpp"
#include "asio/deferred.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
#include "asio/system_timer.hpp"
#include "asio/use_future.hpp"
#include "unit_test.hpp"
void as_tuple_test()
{
asio::io_context io1;
asio::io_context io2;
asio::system_timer timer1(io1);
int count = 0;
timer1.expires_after(asio::chrono::seconds(0));
timer1.async_wait(
asio::as_tuple(
asio::bind_executor(io2.get_executor(),
[&count](std::tuple<asio::error_code>)
{
++count;
})));
ASIO_CHECK(count == 0);
io1.run();
ASIO_CHECK(count == 0);
io2.run();
ASIO_CHECK(count == 1);
timer1.async_wait(
asio::as_tuple(
asio::bind_executor(io2.get_executor(),
asio::deferred)))(
[&count](std::tuple<asio::error_code>)
{
++count;
});
ASIO_CHECK(count == 1);
io1.restart();
io1.run();
ASIO_CHECK(count == 1);
io2.restart();
io2.run();
ASIO_CHECK(count == 2);
# if defined(ASIO_HAS_STD_FUTURE_CLASS)
std::future<std::tuple<asio::error_code> > f = timer1.async_wait(
asio::as_tuple(
asio::bind_executor(io2.get_executor(),
asio::use_future)));
ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
== std::future_status::timeout);
io1.restart();
io1.run();
ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
== std::future_status::timeout);
io2.restart();
io2.run();
ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
== std::future_status::ready);
# endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
}
void as_tuple_constness_test()
{
# if defined(ASIO_HAS_STD_FUTURE_CLASS)
asio::io_context io1;
asio::system_timer timer1(io1);
auto tok1 = asio::as_tuple(asio::use_future);
(void)timer1.async_wait(tok1);
(void)timer1.async_wait(std::move(tok1));
const auto tok2 = asio::as_tuple(asio::use_future);
(void)timer1.async_wait(tok2);
(void)timer1.async_wait(std::move(tok2));
constexpr auto tok3 = asio::as_tuple(asio::use_future);
(void)timer1.async_wait(tok3);
(void)timer1.async_wait(std::move(tok3));
# endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
}
void partial_as_tuple_test()
{
asio::io_context io1;
asio::io_context io2;
asio::system_timer timer1(io1);
int count = 0;
timer1.expires_after(asio::chrono::seconds(0));
timer1.async_wait(asio::as_tuple)(
asio::bind_executor(io2.get_executor(),
[&count](std::tuple<asio::error_code>)
{
++count;
}));
ASIO_CHECK(count == 0);
io1.run();
ASIO_CHECK(count == 0);
io2.run();
ASIO_CHECK(count == 1);
timer1.async_wait(asio::as_tuple)(
asio::bind_executor(io2.get_executor(),
asio::deferred))(
[&count](std::tuple<asio::error_code>)
{
++count;
});
ASIO_CHECK(count == 1);
io1.restart();
io1.run();
ASIO_CHECK(count == 1);
io2.restart();
io2.run();
ASIO_CHECK(count == 2);
# if defined(ASIO_HAS_STD_FUTURE_CLASS)
std::future<std::tuple<asio::error_code> > f
= timer1.async_wait(asio::as_tuple)(
asio::bind_executor(io2.get_executor(),
asio::use_future));
ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
== std::future_status::timeout);
io1.restart();
io1.run();
ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
== std::future_status::timeout);
io2.restart();
io2.run();
ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
== std::future_status::ready);
# endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
}
ASIO_TEST_SUITE
(
"as_tuple",
ASIO_TEST_CASE(as_tuple_test)
ASIO_COMPILE_TEST_CASE(as_tuple_constness_test)
ASIO_TEST_CASE(partial_as_tuple_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/read_at.cpp | //
// read_at.cpp
// ~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/read_at.hpp"
#include <array>
#include <cstring>
#include <functional>
#include "archetypes/async_result.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
#include "asio/streambuf.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_BOOST_ARRAY)
#include <boost/array.hpp>
#endif // defined(ASIO_HAS_BOOST_ARRAY)
using namespace std; // For memcmp, memcpy and memset.
class test_random_access_device
{
public:
typedef asio::io_context::executor_type executor_type;
test_random_access_device(asio::io_context& io_context)
: io_context_(io_context),
length_(0),
next_read_length_(0)
{
}
executor_type get_executor() noexcept
{
return io_context_.get_executor();
}
void reset(const void* data, size_t length)
{
ASIO_CHECK(length <= max_length);
length_ = 0;
while (length_ + length < max_length)
{
memcpy(data_ + length_, data, length);
length_ += length;
}
next_read_length_ = length;
}
void next_read_length(size_t length)
{
next_read_length_ = length;
}
template <typename Iterator>
bool check_buffers(asio::uint64_t offset,
Iterator begin, Iterator end, size_t length)
{
if (offset + length > max_length)
return false;
Iterator iter = begin;
size_t checked_length = 0;
for (; iter != end && checked_length < length; ++iter)
{
size_t buffer_length = asio::buffer_size(*iter);
if (buffer_length > length - checked_length)
buffer_length = length - checked_length;
if (memcmp(data_ + offset + checked_length,
iter->data(), buffer_length) != 0)
return false;
checked_length += buffer_length;
}
return true;
}
template <typename Const_Buffers>
bool check_buffers(asio::uint64_t offset,
const Const_Buffers& buffers, size_t length)
{
return check_buffers(offset, asio::buffer_sequence_begin(buffers),
asio::buffer_sequence_end(buffers), length);
}
template <typename Mutable_Buffers>
size_t read_some_at(asio::uint64_t offset,
const Mutable_Buffers& buffers)
{
return asio::buffer_copy(buffers,
asio::buffer(data_, length_) + offset,
next_read_length_);
}
template <typename Mutable_Buffers>
size_t read_some_at(asio::uint64_t offset,
const Mutable_Buffers& buffers, asio::error_code& ec)
{
ec = asio::error_code();
return read_some_at(offset, buffers);
}
template <typename Mutable_Buffers, typename Handler>
void async_read_some_at(asio::uint64_t offset,
const Mutable_Buffers& buffers, Handler&& handler)
{
size_t bytes_transferred = read_some_at(offset, buffers);
asio::post(get_executor(),
asio::detail::bind_handler(
static_cast<Handler&&>(handler),
asio::error_code(), bytes_transferred));
}
private:
asio::io_context& io_context_;
enum { max_length = 8192 };
char data_[max_length];
size_t length_;
size_t next_read_length_;
};
static const char read_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
void test_3_arg_mutable_buffer_read_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
asio::mutable_buffer buffers
= asio::buffer(read_buf, sizeof(read_buf));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
size_t bytes_transferred = asio::read_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_3_arg_vector_buffers_read_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
std::vector<asio::mutable_buffer> buffers;
buffers.push_back(asio::buffer(read_buf, 32));
buffers.push_back(asio::buffer(read_buf) + 32);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
size_t bytes_transferred = asio::read_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_3_arg_streambuf_read_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
asio::streambuf sb(sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
size_t bytes_transferred = asio::read_at(s, 0, sb);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
}
void test_4_arg_nothrow_mutable_buffer_read_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
asio::mutable_buffer buffers
= asio::buffer(read_buf, sizeof(read_buf));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
asio::error_code error;
size_t bytes_transferred = asio::read_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
}
void test_4_arg_nothrow_vector_buffers_read_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
std::vector<asio::mutable_buffer> buffers;
buffers.push_back(asio::buffer(read_buf, 32));
buffers.push_back(asio::buffer(read_buf) + 32);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
asio::error_code error;
size_t bytes_transferred = asio::read_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
}
void test_4_arg_nothrow_streambuf_read_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
asio::streambuf sb(sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
asio::error_code error;
size_t bytes_transferred = asio::read_at(s, 0, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
}
bool old_style_transfer_all(const asio::error_code& ec,
size_t /*bytes_transferred*/)
{
return !!ec;
}
struct short_transfer
{
short_transfer() {}
short_transfer(short_transfer&&) {}
size_t operator()(const asio::error_code& ec,
size_t /*bytes_transferred*/)
{
return !!ec ? 0 : 3;
}
};
void test_4_arg_mutable_buffer_read_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
asio::mutable_buffer buffers
= asio::buffer(read_buf, sizeof(read_buf));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
size_t bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_4_arg_vector_buffers_read_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
std::vector<asio::mutable_buffer> buffers;
buffers.push_back(asio::buffer(read_buf, 32));
buffers.push_back(asio::buffer(read_buf) + 32);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
size_t bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_4_arg_streambuf_read_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
asio::streambuf sb(sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
size_t bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(sb.size() == 50);
ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(sb.size() == 50);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
}
void test_5_arg_mutable_buffer_read_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
asio::mutable_buffer buffers
= asio::buffer(read_buf, sizeof(read_buf));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
asio::error_code error;
size_t bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
}
void test_5_arg_vector_buffers_read_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
std::vector<asio::mutable_buffer> buffers;
buffers.push_back(asio::buffer(read_buf, 32));
buffers.push_back(asio::buffer(read_buf) + 32);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
asio::error_code error;
size_t bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
ASIO_CHECK(!error);
}
void test_5_arg_streambuf_read_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
asio::streambuf sb(sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
asio::error_code error;
size_t bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(sb.size() == 50);
ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(sb.size() == 50);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 0, sb,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read_at(s, 1234, sb,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 0, sb,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read_at(s, 1234, sb,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
}
void async_read_handler(const asio::error_code& e,
size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
{
*called = true;
ASIO_CHECK(!e);
ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
}
void test_4_arg_mutable_buffer_async_read_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
asio::mutable_buffer buffers
= asio::buffer(read_buf, sizeof(read_buf));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read_at(s, 1234, buffers,
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers)(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_4_arg_boost_array_buffers_async_read_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
#if defined(ASIO_HAS_BOOST_ARRAY)
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
boost::array<asio::mutable_buffer, 2> buffers = { {
asio::buffer(read_buf, 32),
asio::buffer(read_buf) + 32 } };
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read_at(s, 1234, buffers,
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers)(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
#endif // defined(ASIO_HAS_BOOST_ARRAY)
}
void test_4_arg_std_array_buffers_async_read_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
std::array<asio::mutable_buffer, 2> buffers = { {
asio::buffer(read_buf, 32),
asio::buffer(read_buf) + 32 } };
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read_at(s, 1234, buffers,
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers)(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_4_arg_vector_buffers_async_read_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
std::vector<asio::mutable_buffer> buffers;
buffers.push_back(asio::buffer(read_buf, 32));
buffers.push_back(asio::buffer(read_buf) + 32);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read_at(s, 1234, buffers,
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers)(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_4_arg_streambuf_async_read_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
asio::streambuf sb(sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bool called = false;
asio::async_read_at(s, 0, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
int i = asio::async_read_at(s, 1234, sb,
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb)(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
}
void test_5_arg_mutable_buffer_async_read_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
asio::mutable_buffer buffers
= asio::buffer(read_buf, sizeof(read_buf));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read_at(s, 1234, buffers,
short_transfer(), archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer())(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_5_arg_boost_array_buffers_async_read_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
#if defined(ASIO_HAS_BOOST_ARRAY)
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
boost::array<asio::mutable_buffer, 2> buffers = { {
asio::buffer(read_buf, 32),
asio::buffer(read_buf) + 32 } };
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read_at(s, 1234, buffers,
short_transfer(), archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer())(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
#endif // defined(ASIO_HAS_BOOST_ARRAY)
}
void test_5_arg_std_array_buffers_async_read_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
std::array<asio::mutable_buffer, 2> buffers = { {
asio::buffer(read_buf, 32),
asio::buffer(read_buf) + 32 } };
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read_at(s, 1234, buffers,
short_transfer(), archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer())(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_5_arg_vector_buffers_async_read_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
char read_buf[sizeof(read_data)];
std::vector<asio::mutable_buffer> buffers;
buffers.push_back(asio::buffer(read_buf, 32));
buffers.push_back(asio::buffer(read_buf) + 32);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 0, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read_at(s, 1234, buffers,
short_transfer(), archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read_at(s, 1234, buffers, short_transfer())(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
}
void test_5_arg_streambuf_async_read_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
asio::streambuf sb(sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bool called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 50);
ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 50);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb,
asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 0, sb, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
int i = asio::async_read_at(s, 1234, sb,
short_transfer(), archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read_at(s, 1234, sb, short_transfer())(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
}
ASIO_TEST_SUITE
(
"read_at",
ASIO_TEST_CASE(test_3_arg_mutable_buffer_read_at)
ASIO_TEST_CASE(test_3_arg_vector_buffers_read_at)
ASIO_TEST_CASE(test_3_arg_streambuf_read_at)
ASIO_TEST_CASE(test_4_arg_nothrow_mutable_buffer_read_at)
ASIO_TEST_CASE(test_4_arg_nothrow_vector_buffers_read_at)
ASIO_TEST_CASE(test_4_arg_nothrow_streambuf_read_at)
ASIO_TEST_CASE(test_4_arg_mutable_buffer_read_at)
ASIO_TEST_CASE(test_4_arg_vector_buffers_read_at)
ASIO_TEST_CASE(test_4_arg_streambuf_read_at)
ASIO_TEST_CASE(test_5_arg_mutable_buffer_read_at)
ASIO_TEST_CASE(test_5_arg_vector_buffers_read_at)
ASIO_TEST_CASE(test_5_arg_streambuf_read_at)
ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_read_at)
ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_read_at)
ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_read_at)
ASIO_TEST_CASE(test_4_arg_vector_buffers_async_read_at)
ASIO_TEST_CASE(test_4_arg_streambuf_async_read_at)
ASIO_TEST_CASE(test_5_arg_mutable_buffer_async_read_at)
ASIO_TEST_CASE(test_5_arg_boost_array_buffers_async_read_at)
ASIO_TEST_CASE(test_5_arg_std_array_buffers_async_read_at)
ASIO_TEST_CASE(test_5_arg_vector_buffers_async_read_at)
ASIO_TEST_CASE(test_5_arg_streambuf_async_read_at)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/bind_executor.cpp | //
// bind_executor.cpp
// ~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/bind_executor.hpp"
#include <functional>
#include "asio/io_context.hpp"
#include "asio/steady_timer.hpp"
#include "unit_test.hpp"
using namespace asio;
namespace bindns = std;
typedef steady_timer timer;
namespace chronons = asio::chrono;
void increment(int* count)
{
++(*count);
}
void bind_executor_to_function_object_test()
{
io_context ioc1;
io_context ioc2;
int count = 0;
timer t(ioc1, chronons::seconds(1));
t.async_wait(
bind_executor(
ioc2.get_executor(),
bindns::bind(&increment, &count)));
ioc1.run();
ASIO_CHECK(count == 0);
ioc2.run();
ASIO_CHECK(count == 1);
t.async_wait(
bind_executor(
ioc2.get_executor(),
bind_executor(
asio::system_executor(),
bindns::bind(&increment, &count))));
ioc1.restart();
ioc1.run();
ASIO_CHECK(count == 1);
ioc2.restart();
ioc2.run();
ASIO_CHECK(count == 2);
}
struct incrementer_token_v1
{
explicit incrementer_token_v1(int* c) : count(c) {}
int* count;
};
struct incrementer_handler_v1
{
explicit incrementer_handler_v1(incrementer_token_v1 t) : count(t.count) {}
void operator()(asio::error_code){ increment(count); }
int* count;
};
namespace asio {
template <>
class async_result<incrementer_token_v1, void(asio::error_code)>
{
public:
typedef incrementer_handler_v1 completion_handler_type;
typedef void return_type;
explicit async_result(completion_handler_type&) {}
return_type get() {}
};
} // namespace asio
void bind_executor_to_completion_token_v1_test()
{
io_context ioc1;
io_context ioc2;
int count = 0;
timer t(ioc1, chronons::seconds(1));
t.async_wait(
bind_executor(
ioc2.get_executor(),
incrementer_token_v1(&count)));
ioc1.run();
ASIO_CHECK(count == 0);
ioc2.run();
ASIO_CHECK(count == 1);
}
struct incrementer_token_v2
{
explicit incrementer_token_v2(int* c) : count(c) {}
int* count;
};
namespace asio {
template <>
class async_result<incrementer_token_v2, void(asio::error_code)>
{
public:
#if !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
typedef void return_type;
#endif // !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
template <typename Initiation, typename... Args>
static void initiate(Initiation initiation,
incrementer_token_v2 token, Args&&... args)
{
initiation(bindns::bind(&increment, token.count),
static_cast<Args&&>(args)...);
}
};
} // namespace asio
void bind_executor_to_completion_token_v2_test()
{
io_context ioc1;
io_context ioc2;
int count = 0;
timer t(ioc1, chronons::seconds(1));
t.async_wait(
bind_executor(
ioc2.get_executor(),
incrementer_token_v2(&count)));
ioc1.run();
ASIO_CHECK(count == 0);
ioc2.run();
ASIO_CHECK(count == 1);
}
void partial_bind_executor_test()
{
io_context ioc1;
io_context ioc2;
int count = 0;
timer t(ioc1, chronons::seconds(1));
t.async_wait(bind_executor(ioc2.get_executor()))(
bindns::bind(&increment, &count));
ioc1.run();
ASIO_CHECK(count == 0);
ioc2.run();
ASIO_CHECK(count == 1);
t.expires_after(chronons::seconds(1));
t.async_wait()(
bind_executor(ioc2.get_executor()))(
incrementer_token_v2(&count));
ioc1.restart();
ioc1.run();
ASIO_CHECK(count == 1);
ioc2.restart();
ioc2.run();
ASIO_CHECK(count == 2);
}
ASIO_TEST_SUITE
(
"bind_executor",
ASIO_TEST_CASE(bind_executor_to_function_object_test)
ASIO_TEST_CASE(bind_executor_to_completion_token_v1_test)
ASIO_TEST_CASE(bind_executor_to_completion_token_v2_test)
ASIO_TEST_CASE(partial_bind_executor_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/co_spawn.cpp | //
// co_spawn.cpp
// ~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/co_spawn.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_CO_AWAIT)
#include <stdexcept>
#include "asio/any_completion_handler.hpp"
#include "asio/bind_cancellation_slot.hpp"
#include "asio/io_context.hpp"
asio::awaitable<void> void_returning_coroutine()
{
co_return;
}
asio::awaitable<int> int_returning_coroutine()
{
co_return 42;
}
void test_co_spawn_with_any_completion_handler()
{
asio::io_context ctx;
bool called = false;
asio::co_spawn(ctx, void_returning_coroutine(),
asio::any_completion_handler<void(std::exception_ptr)>(
[&](std::exception_ptr)
{
called = true;
}));
ASIO_CHECK(!called);
ctx.run();
ASIO_CHECK(called);
int result = 0;
asio::co_spawn(ctx, int_returning_coroutine(),
asio::any_completion_handler<void(std::exception_ptr, int)>(
[&](std::exception_ptr, int i)
{
result = i;
}));
ASIO_CHECK(result == 0);
ctx.restart();
ctx.run();
ASIO_CHECK(result == 42);
}
void test_co_spawn_immediate_cancel()
{
asio::cancellation_signal sig;
asio::io_context ctx;
std::exception_ptr result = nullptr;
bool called = false;
asio::co_spawn(ctx, void_returning_coroutine(),
asio::bind_cancellation_slot(sig.slot(),
[&](std::exception_ptr e)
{
result = e;
called = true;
}));
ASIO_CHECK(!called);
ASIO_CHECK(result == nullptr);
sig.emit(asio::cancellation_type::all);
ctx.run();
ASIO_CHECK(called);
ASIO_CHECK(result != nullptr);
result = nullptr;
called = false;
asio::co_spawn(ctx, int_returning_coroutine(),
asio::bind_cancellation_slot(sig.slot(),
[&](std::exception_ptr e, int i)
{
ASIO_CHECK(i != 42);
result = e;
called = true;
}));
ASIO_CHECK(!called);
ASIO_CHECK(result == nullptr);
sig.emit(asio::cancellation_type::all);
ctx.restart();
ctx.run();
ASIO_CHECK(called);
ASIO_CHECK(result != nullptr);
}
ASIO_TEST_SUITE
(
"co_spawn",
ASIO_TEST_CASE(test_co_spawn_with_any_completion_handler)
ASIO_TEST_CASE(test_co_spawn_immediate_cancel)
)
#else // defined(ASIO_HAS_CO_AWAIT)
ASIO_TEST_SUITE
(
"co_spawn",
ASIO_TEST_CASE(null_test)
)
#endif // defined(ASIO_HAS_CO_AWAIT)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/strand.cpp | //
// strand.cpp
// ~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/strand.hpp"
#include <functional>
#include <sstream>
#include "asio/executor.hpp"
#include "asio/io_context.hpp"
#include "asio/dispatch.hpp"
#include "asio/post.hpp"
#include "asio/thread.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_BOOST_DATE_TIME)
# include "asio/deadline_timer.hpp"
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
# include "asio/steady_timer.hpp"
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
using namespace asio;
namespace bindns = std;
#if defined(ASIO_HAS_BOOST_DATE_TIME)
typedef deadline_timer timer;
namespace chronons = boost::posix_time;
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
typedef steady_timer timer;
namespace chronons = asio::chrono;
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
void increment(int* count)
{
++(*count);
}
void increment_without_lock(strand<io_context::executor_type>* s, int* count)
{
ASIO_CHECK(!s->running_in_this_thread());
int original_count = *count;
dispatch(*s, bindns::bind(increment, count));
// No other functions are currently executing through the locking dispatcher,
// so the previous call to dispatch should have successfully nested.
ASIO_CHECK(*count == original_count + 1);
}
void increment_with_lock(strand<io_context::executor_type>* s, int* count)
{
ASIO_CHECK(s->running_in_this_thread());
int original_count = *count;
dispatch(*s, bindns::bind(increment, count));
// The current function already holds the strand's lock, so the
// previous call to dispatch should have successfully nested.
ASIO_CHECK(*count == original_count + 1);
}
void sleep_increment(io_context* ioc, int* count)
{
timer t(*ioc, chronons::seconds(2));
t.wait();
++(*count);
}
void increment_by_a(int* count, int a)
{
(*count) += a;
}
void increment_by_a_b(int* count, int a, int b)
{
(*count) += a + b;
}
void increment_by_a_b_c(int* count, int a, int b, int c)
{
(*count) += a + b + c;
}
void increment_by_a_b_c_d(int* count, int a, int b, int c, int d)
{
(*count) += a + b + c + d;
}
void start_sleep_increments(io_context* ioc,
strand<io_context::executor_type>* s, int* count)
{
// Give all threads a chance to start.
timer t(*ioc, chronons::seconds(2));
t.wait();
// Start three increments.
post(*s, bindns::bind(sleep_increment, ioc, count));
post(*s, bindns::bind(sleep_increment, ioc, count));
post(*s, bindns::bind(sleep_increment, ioc, count));
}
void throw_exception()
{
throw 1;
}
void io_context_run(io_context* ioc)
{
ioc->run();
}
void strand_test()
{
io_context ioc;
strand<io_context::executor_type> s = make_strand(ioc);
int count = 0;
post(ioc, bindns::bind(increment_without_lock, &s, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
post(s, bindns::bind(increment_with_lock, &s, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
post(ioc, bindns::bind(start_sleep_increments, &ioc, &s, &count));
thread thread1(bindns::bind(io_context_run, &ioc));
thread thread2(bindns::bind(io_context_run, &ioc));
// Check all events run one after another even though there are two threads.
timer timer1(ioc, chronons::seconds(3));
timer1.wait();
ASIO_CHECK(count == 0);
#if defined(ASIO_HAS_BOOST_DATE_TIME)
timer1.expires_at(timer1.expires_at() + chronons::seconds(2));
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
timer1.expires_at(timer1.expiry() + chronons::seconds(2));
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
timer1.wait();
ASIO_CHECK(count == 1);
#if defined(ASIO_HAS_BOOST_DATE_TIME)
timer1.expires_at(timer1.expires_at() + chronons::seconds(2));
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
timer1.expires_at(timer1.expiry() + chronons::seconds(2));
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
timer1.wait();
ASIO_CHECK(count == 2);
thread1.join();
thread2.join();
// The run() calls will not return until all work has finished.
ASIO_CHECK(count == 3);
count = 0;
int exception_count = 0;
ioc.restart();
post(s, throw_exception);
post(s, bindns::bind(increment, &count));
post(s, bindns::bind(increment, &count));
post(s, throw_exception);
post(s, bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
ASIO_CHECK(exception_count == 0);
for (;;)
{
try
{
ioc.run();
break;
}
catch (int)
{
++exception_count;
}
}
// The run() calls will not return until all work has finished.
ASIO_CHECK(count == 3);
ASIO_CHECK(exception_count == 2);
count = 0;
ioc.restart();
// Check for clean shutdown when handlers posted through an orphaned strand
// are abandoned.
{
strand<io_context::executor_type> s2 = make_strand(ioc.get_executor());
post(s2, bindns::bind(increment, &count));
post(s2, bindns::bind(increment, &count));
post(s2, bindns::bind(increment, &count));
}
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
}
void strand_conversion_test()
{
io_context ioc;
strand<io_context::executor_type> s1 = make_strand(ioc);
// Converting constructors.
strand<executor> s2(s1);
strand<executor> s3 = strand<io_context::executor_type>(s1);
// Converting assignment.
s3 = s1;
s3 = strand<io_context::executor_type>(s1);
}
void strand_query_test()
{
io_context ioc;
strand<io_context::executor_type> s1 = make_strand(ioc);
ASIO_CHECK(
&asio::query(s1, asio::execution::context)
== &ioc);
ASIO_CHECK(
asio::query(s1, asio::execution::blocking)
== asio::execution::blocking.possibly);
ASIO_CHECK(
asio::query(s1, asio::execution::blocking.possibly)
== asio::execution::blocking.possibly);
ASIO_CHECK(
asio::query(s1, asio::execution::outstanding_work)
== asio::execution::outstanding_work.untracked);
ASIO_CHECK(
asio::query(s1, asio::execution::outstanding_work.untracked)
== asio::execution::outstanding_work.untracked);
ASIO_CHECK(
asio::query(s1, asio::execution::relationship)
== asio::execution::relationship.fork);
ASIO_CHECK(
asio::query(s1, asio::execution::relationship.fork)
== asio::execution::relationship.fork);
ASIO_CHECK(
asio::query(s1, asio::execution::mapping)
== asio::execution::mapping.thread);
ASIO_CHECK(
asio::query(s1, asio::execution::allocator)
== std::allocator<void>());
}
void strand_execute_test()
{
io_context ioc;
strand<io_context::executor_type> s1 = make_strand(ioc);
int count = 0;
s1.execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::require(s1, asio::execution::blocking.possibly).execute(
bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::require(s1, asio::execution::blocking.never).execute(
bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
ASIO_CHECK(!ioc.stopped());
asio::require(s1,
asio::execution::blocking.never,
asio::execution::outstanding_work.tracked
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::require(s1,
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::require(s1,
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.fork
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::require(s1,
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::prefer(
asio::require(s1,
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation),
asio::execution::allocator(std::allocator<void>())
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
asio::prefer(
asio::require(s1,
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation),
asio::execution::allocator
).execute(bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(!ioc.stopped());
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(ioc.stopped());
ASIO_CHECK(count == 1);
}
ASIO_TEST_SUITE
(
"strand",
ASIO_TEST_CASE(strand_test)
ASIO_COMPILE_TEST_CASE(strand_conversion_test)
ASIO_TEST_CASE(strand_query_test)
ASIO_TEST_CASE(strand_execute_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/bind_immediate_executor.cpp | //
// bind_immediate_executor.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/bind_immediate_executor.hpp"
#include <functional>
#include "asio/immediate.hpp"
#include "asio/io_context.hpp"
#include "unit_test.hpp"
using namespace asio;
namespace bindns = std;
void increment(int* count)
{
++(*count);
}
void bind_immediate_executor_to_function_object_test()
{
io_context ioc1;
io_context ioc2;
int count = 0;
async_immediate(ioc1,
bind_immediate_executor(
ioc2.get_executor(),
bindns::bind(&increment, &count)));
ioc1.run();
ASIO_CHECK(count == 0);
ioc2.run();
ASIO_CHECK(count == 1);
async_immediate(ioc1.get_executor(),
bind_immediate_executor(
ioc2.get_executor(),
bind_immediate_executor(
asio::system_executor(),
bindns::bind(&increment, &count))));
ioc1.restart();
ioc1.run();
ASIO_CHECK(count == 1);
ioc2.restart();
ioc2.run();
ASIO_CHECK(count == 2);
}
struct incrementer_token_v1
{
explicit incrementer_token_v1(int* c) : count(c) {}
int* count;
};
struct incrementer_handler_v1
{
explicit incrementer_handler_v1(incrementer_token_v1 t) : count(t.count) {}
void operator()(){ increment(count); }
int* count;
};
namespace asio {
template <>
class async_result<incrementer_token_v1, void()>
{
public:
typedef incrementer_handler_v1 completion_handler_type;
typedef void return_type;
explicit async_result(completion_handler_type&) {}
return_type get() {}
};
} // namespace asio
void bind_immediate_executor_to_completion_token_v1_test()
{
io_context ioc1;
io_context ioc2;
int count = 0;
async_immediate(ioc1,
bind_immediate_executor(
ioc2.get_executor(),
incrementer_token_v1(&count)));
ioc1.run();
ASIO_CHECK(count == 0);
ioc2.run();
ASIO_CHECK(count == 1);
}
struct incrementer_token_v2
{
explicit incrementer_token_v2(int* c) : count(c) {}
int* count;
};
namespace asio {
template <>
class async_result<incrementer_token_v2, void()>
{
public:
#if !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
typedef void return_type;
#endif // !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
template <typename Initiation, typename... Args>
static void initiate(Initiation initiation,
incrementer_token_v2 token, Args&&... args)
{
initiation(bindns::bind(&increment, token.count),
static_cast<Args&&>(args)...);
}
};
} // namespace asio
void bind_immediate_executor_to_completion_token_v2_test()
{
io_context ioc1;
io_context ioc2;
int count = 0;
async_immediate(ioc1,
bind_immediate_executor(
ioc2.get_executor(),
incrementer_token_v2(&count)));
ioc1.run();
ASIO_CHECK(count == 0);
ioc2.run();
ASIO_CHECK(count == 1);
}
void partial_bind_immediate_executor_test()
{
io_context ioc1;
io_context ioc2;
int count = 0;
async_immediate(ioc1, bind_immediate_executor(ioc2.get_executor()))(
bindns::bind(&increment, &count));
ioc1.run();
ASIO_CHECK(count == 0);
ioc2.run();
ASIO_CHECK(count == 1);
async_immediate(ioc1, bind_immediate_executor(ioc2.get_executor()))(
incrementer_token_v2(&count));
ioc1.restart();
ioc1.run();
ASIO_CHECK(count == 1);
ioc2.restart();
ioc2.run();
ASIO_CHECK(count == 2);
}
ASIO_TEST_SUITE
(
"bind_immediate_executor",
ASIO_TEST_CASE(bind_immediate_executor_to_function_object_test)
ASIO_TEST_CASE(bind_immediate_executor_to_completion_token_v1_test)
ASIO_TEST_CASE(bind_immediate_executor_to_completion_token_v2_test)
ASIO_TEST_CASE(partial_bind_immediate_executor_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/executor_work_guard.cpp | //
// executor_work_guard.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/executor_work_guard.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"executor_work_guard",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/execution_context.cpp | //
// execution_context.cpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/execution_context.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"execution_context",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_datagram_socket.cpp | //
// basic_datagram_socket.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/basic_datagram_socket.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_datagram_socket",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/buffered_read_stream.cpp | //
// buffered_read_stream.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/buffered_read_stream.hpp"
#include <cstring>
#include <functional>
#include "archetypes/async_result.hpp"
#include "asio/buffer.hpp"
#include "asio/io_context.hpp"
#include "asio/ip/tcp.hpp"
#include "asio/system_error.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_BOOST_ARRAY)
# include <boost/array.hpp>
#else // defined(ASIO_HAS_BOOST_ARRAY)
# include <array>
#endif // defined(ASIO_HAS_BOOST_ARRAY)
typedef asio::buffered_read_stream<
asio::ip::tcp::socket> stream_type;
void write_some_handler(const asio::error_code&, std::size_t)
{
}
void fill_handler(const asio::error_code&, std::size_t)
{
}
void read_some_handler(const asio::error_code&, std::size_t)
{
}
void test_compile()
{
#if defined(ASIO_HAS_BOOST_ARRAY)
using boost::array;
#else // defined(ASIO_HAS_BOOST_ARRAY)
using std::array;
#endif // defined(ASIO_HAS_BOOST_ARRAY)
using namespace asio;
try
{
io_context ioc;
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
array<asio::mutable_buffer, 2> mutable_buffers = {{
asio::buffer(mutable_char_buffer, 10),
asio::buffer(mutable_char_buffer + 10, 10) }};
array<asio::const_buffer, 2> const_buffers = {{
asio::buffer(const_char_buffer, 10),
asio::buffer(const_char_buffer + 10, 10) }};
archetypes::lazy_handler lazy;
asio::error_code ec;
stream_type stream1(ioc);
stream_type stream2(ioc, 1024);
stream_type::executor_type ex = stream1.get_executor();
(void)ex;
stream_type::lowest_layer_type& lowest_layer = stream1.lowest_layer();
(void)lowest_layer;
stream1.write_some(buffer(mutable_char_buffer));
stream1.write_some(buffer(const_char_buffer));
stream1.write_some(mutable_buffers);
stream1.write_some(const_buffers);
stream1.write_some(null_buffers());
stream1.write_some(buffer(mutable_char_buffer), ec);
stream1.write_some(buffer(const_char_buffer), ec);
stream1.write_some(mutable_buffers, ec);
stream1.write_some(const_buffers, ec);
stream1.write_some(null_buffers(), ec);
stream1.async_write_some(buffer(mutable_char_buffer), &write_some_handler);
stream1.async_write_some(buffer(const_char_buffer), &write_some_handler);
stream1.async_write_some(mutable_buffers, &write_some_handler);
stream1.async_write_some(const_buffers, &write_some_handler);
stream1.async_write_some(null_buffers(), &write_some_handler);
int i1 = stream1.async_write_some(buffer(mutable_char_buffer), lazy);
(void)i1;
int i2 = stream1.async_write_some(buffer(const_char_buffer), lazy);
(void)i2;
int i3 = stream1.async_write_some(mutable_buffers, lazy);
(void)i3;
int i4 = stream1.async_write_some(const_buffers, lazy);
(void)i4;
int i5 = stream1.async_write_some(null_buffers(), lazy);
(void)i5;
stream1.fill();
stream1.fill(ec);
stream1.async_fill(&fill_handler);
int i6 = stream1.async_fill(lazy);
(void)i6;
stream1.read_some(buffer(mutable_char_buffer));
stream1.read_some(mutable_buffers);
stream1.read_some(null_buffers());
stream1.read_some(buffer(mutable_char_buffer), ec);
stream1.read_some(mutable_buffers, ec);
stream1.read_some(null_buffers(), ec);
stream1.async_read_some(buffer(mutable_char_buffer), &read_some_handler);
stream1.async_read_some(mutable_buffers, &read_some_handler);
stream1.async_read_some(null_buffers(), &read_some_handler);
int i7 = stream1.async_read_some(buffer(mutable_char_buffer), lazy);
(void)i7;
int i8 = stream1.async_read_some(mutable_buffers, lazy);
(void)i8;
int i9 = stream1.async_read_some(null_buffers(), lazy);
(void)i9;
}
catch (std::exception&)
{
}
}
void test_sync_operations()
{
using namespace std; // For memcmp.
asio::io_context io_context;
asio::ip::tcp::acceptor acceptor(io_context,
asio::ip::tcp::endpoint(asio::ip::tcp::v4(), 0));
asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
server_endpoint.address(asio::ip::address_v4::loopback());
stream_type client_socket(io_context);
client_socket.lowest_layer().connect(server_endpoint);
stream_type server_socket(io_context);
acceptor.accept(server_socket.lowest_layer());
const char write_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const asio::const_buffer write_buf = asio::buffer(write_data);
std::size_t bytes_written = 0;
while (bytes_written < sizeof(write_data))
{
bytes_written += client_socket.write_some(
asio::buffer(write_buf + bytes_written));
}
char read_data[sizeof(write_data)];
const asio::mutable_buffer read_buf = asio::buffer(read_data);
std::size_t bytes_read = 0;
while (bytes_read < sizeof(read_data))
{
bytes_read += server_socket.read_some(
asio::buffer(read_buf + bytes_read));
}
ASIO_CHECK(bytes_written == sizeof(write_data));
ASIO_CHECK(bytes_read == sizeof(read_data));
ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
bytes_written = 0;
while (bytes_written < sizeof(write_data))
{
bytes_written += server_socket.write_some(
asio::buffer(write_buf + bytes_written));
}
bytes_read = 0;
while (bytes_read < sizeof(read_data))
{
bytes_read += client_socket.read_some(
asio::buffer(read_buf + bytes_read));
}
ASIO_CHECK(bytes_written == sizeof(write_data));
ASIO_CHECK(bytes_read == sizeof(read_data));
ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
server_socket.close();
asio::error_code error;
bytes_read = client_socket.read_some(
asio::buffer(read_buf), error);
ASIO_CHECK(bytes_read == 0);
ASIO_CHECK(error == asio::error::eof);
client_socket.close(error);
}
void handle_accept(const asio::error_code& e)
{
ASIO_CHECK(!e);
}
void handle_write(const asio::error_code& e,
std::size_t bytes_transferred,
std::size_t* total_bytes_written)
{
ASIO_CHECK(!e);
if (e)
throw asio::system_error(e); // Terminate test.
*total_bytes_written += bytes_transferred;
}
void handle_read(const asio::error_code& e,
std::size_t bytes_transferred,
std::size_t* total_bytes_read)
{
ASIO_CHECK(!e);
if (e)
throw asio::system_error(e); // Terminate test.
*total_bytes_read += bytes_transferred;
}
void handle_read_eof(const asio::error_code& e,
std::size_t bytes_transferred)
{
ASIO_CHECK(e == asio::error::eof);
ASIO_CHECK(bytes_transferred == 0);
}
void test_async_operations()
{
using namespace std; // For memcmp.
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context io_context;
asio::ip::tcp::acceptor acceptor(io_context,
asio::ip::tcp::endpoint(asio::ip::tcp::v4(), 0));
asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
server_endpoint.address(asio::ip::address_v4::loopback());
stream_type client_socket(io_context);
client_socket.lowest_layer().connect(server_endpoint);
stream_type server_socket(io_context);
acceptor.async_accept(server_socket.lowest_layer(), &handle_accept);
io_context.run();
io_context.restart();
const char write_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const asio::const_buffer write_buf = asio::buffer(write_data);
std::size_t bytes_written = 0;
while (bytes_written < sizeof(write_data))
{
client_socket.async_write_some(
asio::buffer(write_buf + bytes_written),
bindns::bind(handle_write, _1, _2, &bytes_written));
io_context.run();
io_context.restart();
}
char read_data[sizeof(write_data)];
const asio::mutable_buffer read_buf = asio::buffer(read_data);
std::size_t bytes_read = 0;
while (bytes_read < sizeof(read_data))
{
server_socket.async_read_some(
asio::buffer(read_buf + bytes_read),
bindns::bind(handle_read, _1, _2, &bytes_read));
io_context.run();
io_context.restart();
}
ASIO_CHECK(bytes_written == sizeof(write_data));
ASIO_CHECK(bytes_read == sizeof(read_data));
ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
bytes_written = 0;
while (bytes_written < sizeof(write_data))
{
server_socket.async_write_some(
asio::buffer(write_buf + bytes_written),
bindns::bind(handle_write, _1, _2, &bytes_written));
io_context.run();
io_context.restart();
}
bytes_read = 0;
while (bytes_read < sizeof(read_data))
{
client_socket.async_read_some(
asio::buffer(read_buf + bytes_read),
bindns::bind(handle_read, _1, _2, &bytes_read));
io_context.run();
io_context.restart();
}
ASIO_CHECK(bytes_written == sizeof(write_data));
ASIO_CHECK(bytes_read == sizeof(read_data));
ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
server_socket.close();
client_socket.async_read_some(asio::buffer(read_buf), handle_read_eof);
}
ASIO_TEST_SUITE
(
"buffered_read_stream",
ASIO_COMPILE_TEST_CASE(test_compile)
ASIO_TEST_CASE(test_sync_operations)
ASIO_TEST_CASE(test_async_operations)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_file.cpp | //
// basic_file.cpp
// ~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/basic_file.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_file",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/system_timer.cpp | //
// system_timer.cpp
// ~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/system_timer.hpp"
#include <functional>
#include "asio/bind_cancellation_slot.hpp"
#include "asio/cancellation_signal.hpp"
#include "asio/executor_work_guard.hpp"
#include "asio/io_context.hpp"
#include "asio/thread.hpp"
#include "unit_test.hpp"
namespace bindns = std;
void increment(int* count)
{
++(*count);
}
void decrement_to_zero(asio::system_timer* t, int* count)
{
if (*count > 0)
{
--(*count);
int before_value = *count;
t->expires_at(t->expiry() + asio::chrono::seconds(1));
t->async_wait(bindns::bind(decrement_to_zero, t, count));
// Completion cannot nest, so count value should remain unchanged.
ASIO_CHECK(*count == before_value);
}
}
void increment_if_not_cancelled(int* count,
const asio::error_code& ec)
{
if (!ec)
++(*count);
}
void cancel_timer(asio::system_timer* t)
{
std::size_t num_cancelled = t->cancel();
ASIO_CHECK(num_cancelled == 1);
}
void cancel_one_timer(asio::system_timer* t)
{
std::size_t num_cancelled = t->cancel_one();
ASIO_CHECK(num_cancelled == 1);
}
asio::system_timer::time_point now()
{
return asio::system_timer::clock_type::now();
}
void system_timer_test()
{
using asio::chrono::seconds;
using asio::chrono::microseconds;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
const asio::io_context::executor_type ioc_ex = ioc.get_executor();
int count = 0;
asio::system_timer::time_point start = now();
asio::system_timer t1(ioc, seconds(1));
t1.wait();
// The timer must block until after its expiry time.
asio::system_timer::time_point end = now();
asio::system_timer::time_point expected_end = start + seconds(1);
ASIO_CHECK(expected_end < end || expected_end == end);
start = now();
asio::system_timer t2(ioc_ex, seconds(1) + microseconds(500000));
t2.wait();
// The timer must block until after its expiry time.
end = now();
expected_end = start + seconds(1) + microseconds(500000);
ASIO_CHECK(expected_end < end || expected_end == end);
t2.expires_at(t2.expiry() + seconds(1));
t2.wait();
// The timer must block until after its expiry time.
end = now();
expected_end += seconds(1);
ASIO_CHECK(expected_end < end || expected_end == end);
start = now();
t2.expires_after(seconds(1) + microseconds(200000));
t2.wait();
// The timer must block until after its expiry time.
end = now();
expected_end = start + seconds(1) + microseconds(200000);
ASIO_CHECK(expected_end < end || expected_end == end);
start = now();
asio::system_timer t3(ioc, seconds(5));
t3.async_wait(bindns::bind(increment, &count));
// No completions can be delivered until run() is called.
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all operations have finished, and
// this should not be until after the timer's expiry time.
ASIO_CHECK(count == 1);
end = now();
expected_end = start + seconds(1);
ASIO_CHECK(expected_end < end || expected_end == end);
count = 3;
start = now();
asio::system_timer t4(ioc, seconds(1));
t4.async_wait(bindns::bind(decrement_to_zero, &t4, &count));
// No completions can be delivered until run() is called.
ASIO_CHECK(count == 3);
ioc.restart();
ioc.run();
// The run() call will not return until all operations have finished, and
// this should not be until after the timer's final expiry time.
ASIO_CHECK(count == 0);
end = now();
expected_end = start + seconds(3);
ASIO_CHECK(expected_end < end || expected_end == end);
count = 0;
start = now();
asio::system_timer t5(ioc, seconds(10));
t5.async_wait(bindns::bind(increment_if_not_cancelled, &count, _1));
asio::system_timer t6(ioc, seconds(1));
t6.async_wait(bindns::bind(cancel_timer, &t5));
// No completions can be delivered until run() is called.
ASIO_CHECK(count == 0);
ioc.restart();
ioc.run();
// The timer should have been cancelled, so count should not have changed.
// The total run time should not have been much more than 1 second (and
// certainly far less than 10 seconds).
ASIO_CHECK(count == 0);
end = now();
expected_end = start + seconds(2);
ASIO_CHECK(end < expected_end);
// Wait on the timer again without cancelling it. This time the asynchronous
// wait should run to completion and increment the counter.
t5.async_wait(bindns::bind(increment_if_not_cancelled, &count, _1));
ioc.restart();
ioc.run();
// The timer should not have been cancelled, so count should have changed.
// The total time since the timer was created should be more than 10 seconds.
ASIO_CHECK(count == 1);
end = now();
expected_end = start + seconds(10);
ASIO_CHECK(expected_end < end || expected_end == end);
count = 0;
start = now();
// Start two waits on a timer, one of which will be cancelled. The one
// which is not cancelled should still run to completion and increment the
// counter.
asio::system_timer t7(ioc, seconds(3));
t7.async_wait(bindns::bind(increment_if_not_cancelled, &count, _1));
t7.async_wait(bindns::bind(increment_if_not_cancelled, &count, _1));
asio::system_timer t8(ioc, seconds(1));
t8.async_wait(bindns::bind(cancel_one_timer, &t7));
ioc.restart();
ioc.run();
// One of the waits should not have been cancelled, so count should have
// changed. The total time since the timer was created should be more than 3
// seconds.
ASIO_CHECK(count == 1);
end = now();
expected_end = start + seconds(3);
ASIO_CHECK(expected_end < end || expected_end == end);
}
struct timer_handler
{
timer_handler() {}
void operator()(const asio::error_code&) {}
timer_handler(timer_handler&&) {}
private:
timer_handler(const timer_handler&);
};
void system_timer_cancel_test()
{
static asio::io_context io_context;
struct timer
{
asio::system_timer t;
timer() : t(io_context)
{
t.expires_at((asio::system_timer::time_point::max)());
}
} timers[50];
timers[2].t.async_wait(timer_handler());
timers[41].t.async_wait(timer_handler());
for (int i = 10; i < 20; ++i)
timers[i].t.async_wait(timer_handler());
ASIO_CHECK(timers[2].t.cancel() == 1);
ASIO_CHECK(timers[41].t.cancel() == 1);
for (int i = 10; i < 20; ++i)
ASIO_CHECK(timers[i].t.cancel() == 1);
}
struct custom_allocation_timer_handler
{
custom_allocation_timer_handler(int* count) : count_(count) {}
void operator()(const asio::error_code&) {}
int* count_;
template <typename T>
struct allocator
{
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;
template <typename U>
struct rebind
{
typedef allocator<U> other;
};
explicit allocator(int* count) noexcept
: count_(count)
{
}
allocator(const allocator& other) noexcept
: count_(other.count_)
{
}
template <typename U>
allocator(const allocator<U>& other) noexcept
: count_(other.count_)
{
}
pointer allocate(size_type n, const void* = 0)
{
++(*count_);
return static_cast<T*>(::operator new(sizeof(T) * n));
}
void deallocate(pointer p, size_type)
{
--(*count_);
::operator delete(p);
}
size_type max_size() const
{
return ~size_type(0);
}
void construct(pointer p, const T& v)
{
new (p) T(v);
}
void destroy(pointer p)
{
p->~T();
}
int* count_;
};
typedef allocator<int> allocator_type;
allocator_type get_allocator() const noexcept
{
return allocator_type(count_);
}
};
void system_timer_custom_allocation_test()
{
static asio::io_context io_context;
struct timer
{
asio::system_timer t;
timer() : t(io_context) {}
} timers[100];
int allocation_count = 0;
for (int i = 0; i < 50; ++i)
{
timers[i].t.expires_at((asio::system_timer::time_point::max)());
timers[i].t.async_wait(custom_allocation_timer_handler(&allocation_count));
}
for (int i = 50; i < 100; ++i)
{
timers[i].t.expires_at((asio::system_timer::time_point::min)());
timers[i].t.async_wait(custom_allocation_timer_handler(&allocation_count));
}
for (int i = 0; i < 50; ++i)
timers[i].t.cancel();
io_context.run();
ASIO_CHECK(allocation_count == 0);
}
void io_context_run(asio::io_context* ioc)
{
ioc->run();
}
void system_timer_thread_test()
{
asio::io_context ioc;
asio::executor_work_guard<asio::io_context::executor_type> work
= asio::make_work_guard(ioc);
asio::system_timer t1(ioc);
asio::system_timer t2(ioc);
int count = 0;
asio::thread th(bindns::bind(io_context_run, &ioc));
t2.expires_after(asio::chrono::seconds(2));
t2.wait();
t1.expires_after(asio::chrono::seconds(2));
t1.async_wait(bindns::bind(increment, &count));
t2.expires_after(asio::chrono::seconds(4));
t2.wait();
ioc.stop();
th.join();
ASIO_CHECK(count == 1);
}
asio::system_timer make_timer(asio::io_context& ioc, int* count)
{
asio::system_timer t(ioc);
t.expires_after(asio::chrono::seconds(1));
t.async_wait(bindns::bind(increment, count));
return t;
}
typedef asio::basic_waitable_timer<
asio::system_timer::clock_type,
asio::system_timer::traits_type,
asio::io_context::executor_type> io_context_system_timer;
io_context_system_timer make_convertible_timer(asio::io_context& ioc, int* count)
{
io_context_system_timer t(ioc);
t.expires_after(asio::chrono::seconds(1));
t.async_wait(bindns::bind(increment, count));
return t;
}
void system_timer_move_test()
{
asio::io_context io_context1;
asio::io_context io_context2;
int count = 0;
asio::system_timer t1 = make_timer(io_context1, &count);
asio::system_timer t2 = make_timer(io_context2, &count);
asio::system_timer t3 = std::move(t1);
t2 = std::move(t1);
io_context2.run();
ASIO_CHECK(count == 1);
io_context1.run();
ASIO_CHECK(count == 2);
asio::system_timer t4 = make_convertible_timer(io_context1, &count);
asio::system_timer t5 = make_convertible_timer(io_context2, &count);
asio::system_timer t6 = std::move(t4);
t2 = std::move(t4);
io_context2.restart();
io_context2.run();
ASIO_CHECK(count == 3);
io_context1.restart();
io_context1.run();
ASIO_CHECK(count == 4);
}
void system_timer_op_cancel_test()
{
asio::cancellation_signal cancel_signal;
asio::io_context ioc;
int count = 0;
asio::system_timer timer(ioc, asio::chrono::seconds(10));
timer.async_wait(bindns::bind(increment, &count));
timer.async_wait(
asio::bind_cancellation_slot(
cancel_signal.slot(),
bindns::bind(increment, &count)));
timer.async_wait(bindns::bind(increment, &count));
ioc.poll();
ASIO_CHECK(count == 0);
ASIO_CHECK(!ioc.stopped());
cancel_signal.emit(asio::cancellation_type::all);
ioc.run_one();
ioc.poll();
ASIO_CHECK(count == 1);
ASIO_CHECK(!ioc.stopped());
timer.cancel();
ioc.run();
ASIO_CHECK(count == 3);
ASIO_CHECK(ioc.stopped());
}
ASIO_TEST_SUITE
(
"system_timer",
ASIO_TEST_CASE(system_timer_test)
ASIO_TEST_CASE(system_timer_cancel_test)
ASIO_TEST_CASE(system_timer_custom_allocation_test)
ASIO_TEST_CASE(system_timer_thread_test)
ASIO_TEST_CASE(system_timer_move_test)
ASIO_TEST_CASE(system_timer_op_cancel_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/read.cpp | //
// read.cpp
// ~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/read.hpp"
#include <array>
#include <cstring>
#include <functional>
#include <vector>
#include "archetypes/async_result.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
#include "asio/streambuf.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_BOOST_ARRAY)
#include <boost/array.hpp>
#endif // defined(ASIO_HAS_BOOST_ARRAY)
using namespace std; // For memcmp, memcpy and memset.
class test_stream
{
public:
typedef asio::io_context::executor_type executor_type;
test_stream(asio::io_context& io_context)
: io_context_(io_context),
length_(0),
position_(0),
next_read_length_(0)
{
}
executor_type get_executor() noexcept
{
return io_context_.get_executor();
}
void reset(const void* data, size_t length)
{
ASIO_CHECK(length <= max_length);
memcpy(data_, data, length);
length_ = length;
position_ = 0;
next_read_length_ = length;
}
void next_read_length(size_t length)
{
next_read_length_ = length;
}
template <typename Iterator>
bool check_buffers(Iterator begin, Iterator end, size_t length)
{
if (length != position_)
return false;
Iterator iter = begin;
size_t checked_length = 0;
for (; iter != end && checked_length < length; ++iter)
{
size_t buffer_length = asio::buffer_size(*iter);
if (buffer_length > length - checked_length)
buffer_length = length - checked_length;
if (memcmp(data_ + checked_length, iter->data(), buffer_length) != 0)
return false;
checked_length += buffer_length;
}
return true;
}
template <typename Const_Buffers>
bool check_buffers(const Const_Buffers& buffers, size_t length)
{
return check_buffers(asio::buffer_sequence_begin(buffers),
asio::buffer_sequence_end(buffers), length);
}
template <typename Mutable_Buffers>
size_t read_some(const Mutable_Buffers& buffers)
{
size_t n = asio::buffer_copy(buffers,
asio::buffer(data_, length_) + position_,
next_read_length_);
position_ += n;
return n;
}
template <typename Mutable_Buffers>
size_t read_some(const Mutable_Buffers& buffers,
asio::error_code& ec)
{
ec = asio::error_code();
return read_some(buffers);
}
template <typename Mutable_Buffers, typename Handler>
void async_read_some(const Mutable_Buffers& buffers,
Handler&& handler)
{
size_t bytes_transferred = read_some(buffers);
asio::post(get_executor(),
asio::detail::bind_handler(
static_cast<Handler&&>(handler),
asio::error_code(), bytes_transferred));
}
private:
asio::io_context& io_context_;
enum { max_length = 8192 };
char data_[max_length];
size_t length_;
size_t position_;
size_t next_read_length_;
};
static const char read_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
void test_2_arg_zero_buffers_read()
{
asio::io_context ioc;
test_stream s(ioc);
std::vector<asio::mutable_buffer> buffers;
size_t bytes_transferred = asio::read(s, buffers);
ASIO_CHECK(bytes_transferred == 0);
}
void test_2_arg_mutable_buffer_read()
{
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
asio::mutable_buffer buffers
= asio::buffer(read_buf, sizeof(read_buf));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
size_t bytes_transferred = asio::read(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
}
void test_2_arg_vector_buffers_read()
{
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
std::vector<asio::mutable_buffer> buffers;
buffers.push_back(asio::buffer(read_buf, 32));
buffers.push_back(asio::buffer(read_buf, 39) + 32);
buffers.push_back(asio::buffer(read_buf) + 39);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
size_t bytes_transferred = asio::read(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
}
void test_2_arg_dynamic_string_read()
{
asio::io_context ioc;
test_stream s(ioc);
std::string data;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb
= asio::dynamic_buffer(data, sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
size_t bytes_transferred = asio::read(s, sb);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
}
void test_2_arg_streambuf_read()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb(sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
size_t bytes_transferred = asio::read(s, sb);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
void test_3_arg_nothrow_zero_buffers_read()
{
asio::io_context ioc;
test_stream s(ioc);
std::vector<asio::mutable_buffer> buffers;
asio::error_code error;
size_t bytes_transferred = asio::read(s, buffers, error);
ASIO_CHECK(bytes_transferred == 0);
ASIO_CHECK(!error);
}
void test_3_arg_nothrow_mutable_buffer_read()
{
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
asio::mutable_buffer buffers
= asio::buffer(read_buf, sizeof(read_buf));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
asio::error_code error;
size_t bytes_transferred = asio::read(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
}
void test_3_arg_nothrow_vector_buffers_read()
{
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
std::vector<asio::mutable_buffer> buffers;
buffers.push_back(asio::buffer(read_buf, 32));
buffers.push_back(asio::buffer(read_buf, 39) + 32);
buffers.push_back(asio::buffer(read_buf) + 39);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
asio::error_code error;
size_t bytes_transferred = asio::read(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
}
void test_3_arg_nothrow_dynamic_string_read()
{
asio::io_context ioc;
test_stream s(ioc);
std::string data;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb
= asio::dynamic_buffer(data, sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
asio::error_code error;
size_t bytes_transferred = asio::read(s, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
}
void test_3_arg_nothrow_streambuf_read()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb(sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
asio::error_code error;
size_t bytes_transferred = asio::read(s, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
bool old_style_transfer_all(const asio::error_code& ec,
size_t /*bytes_transferred*/)
{
return !!ec;
}
struct short_transfer
{
short_transfer() {}
short_transfer(short_transfer&&) {}
size_t operator()(const asio::error_code& ec,
size_t /*bytes_transferred*/)
{
return !!ec ? 0 : 3;
}
};
void test_3_arg_mutable_buffer_read()
{
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
asio::mutable_buffer buffers
= asio::buffer(read_buf, sizeof(read_buf));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
size_t bytes_transferred = asio::read(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
}
void test_3_arg_vector_buffers_read()
{
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
std::vector<asio::mutable_buffer> buffers;
buffers.push_back(asio::buffer(read_buf, 32));
buffers.push_back(asio::buffer(read_buf, 39) + 32);
buffers.push_back(asio::buffer(read_buf) + 39);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
size_t bytes_transferred = asio::read(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
}
void test_3_arg_dynamic_string_read()
{
asio::io_context ioc;
test_stream s(ioc);
std::string data;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb
= asio::dynamic_buffer(data, sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
size_t bytes_transferred = asio::read(s, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(sb.size() == 50);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 50));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
}
void test_3_arg_streambuf_read()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb(sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
size_t bytes_transferred = asio::read(s, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(sb.size() == 50);
ASIO_CHECK(s.check_buffers(sb.data(), 50));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(), 1));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(), 42));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
void test_4_arg_mutable_buffer_read()
{
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
asio::mutable_buffer buffers
= asio::buffer(read_buf, sizeof(read_buf));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
asio::error_code error;
size_t bytes_transferred = asio::read(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(buffers, 50));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
}
void test_4_arg_vector_buffers_read()
{
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
std::vector<asio::mutable_buffer> buffers;
buffers.push_back(asio::buffer(read_buf, 32));
buffers.push_back(asio::buffer(read_buf, 39) + 32);
buffers.push_back(asio::buffer(read_buf) + 39);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
asio::error_code error;
size_t bytes_transferred = asio::read(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(buffers, 50));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(buffers, 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(buffers, 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(buffers, 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bytes_transferred = asio::read(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
error = asio::error_code();
bytes_transferred = asio::read(s, buffers, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
ASIO_CHECK(!error);
}
void test_4_arg_dynamic_string_read()
{
asio::io_context ioc;
test_stream s(ioc);
std::string data;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb
= asio::dynamic_buffer(data, sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
asio::error_code error;
size_t bytes_transferred = asio::read(s, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(sb.size() == 50);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 50));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
ASIO_CHECK(!error);
}
void test_4_arg_streambuf_read()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb(sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
asio::error_code error;
size_t bytes_transferred = asio::read(s, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(sb.size() == 50);
ASIO_CHECK(s.check_buffers(sb.data(), 50));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(), 1));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(), 42));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bytes_transferred = asio::read(s, sb, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
error = asio::error_code();
bytes_transferred = asio::read(s, sb, short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(read_data));
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
ASIO_CHECK(!error);
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
void async_read_handler(const asio::error_code& e,
size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
{
*called = true;
ASIO_CHECK(!e);
ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
}
void test_3_arg_mutable_buffer_async_read()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
asio::mutable_buffer buffers
= asio::buffer(read_buf, sizeof(read_buf));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read(s, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read(s, buffers, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers)(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
}
void test_3_arg_boost_array_buffers_async_read()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
#if defined(ASIO_HAS_BOOST_ARRAY)
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
boost::array<asio::mutable_buffer, 2> buffers = { {
asio::buffer(read_buf, 32),
asio::buffer(read_buf) + 32 } };
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read(s, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read(s, buffers, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers)(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
#endif // defined(ASIO_HAS_BOOST_ARRAY)
}
void test_3_arg_std_array_buffers_async_read()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
std::array<asio::mutable_buffer, 2> buffers = { {
asio::buffer(read_buf, 32),
asio::buffer(read_buf) + 32 } };
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read(s, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read(s, buffers, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers)(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
}
void test_3_arg_vector_buffers_async_read()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
std::vector<asio::mutable_buffer> buffers;
buffers.push_back(asio::buffer(read_buf, 32));
buffers.push_back(asio::buffer(read_buf, 39) + 32);
buffers.push_back(asio::buffer(read_buf) + 39);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read(s, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read(s, buffers, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers)(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
}
void test_3_arg_dynamic_string_async_read()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
std::string data;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb
= asio::dynamic_buffer(data, sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bool called = false;
asio::async_read(s, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
int i = asio::async_read(s, sb, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb)(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
}
void test_3_arg_streambuf_async_read()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb(sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bool called = false;
asio::async_read(s, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
int i = asio::async_read(s, sb, archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb)(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
void test_4_arg_mutable_buffer_async_read()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
asio::mutable_buffer buffers
= asio::buffer(read_buf, sizeof(read_buf));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read(s, buffers, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read(s, buffers,
short_transfer(), archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer())(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
}
void test_4_arg_boost_array_buffers_async_read()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
#if defined(ASIO_HAS_BOOST_ARRAY)
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
boost::array<asio::mutable_buffer, 2> buffers = { {
asio::buffer(read_buf, 32),
asio::buffer(read_buf) + 32 } };
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read(s, buffers, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read(s, buffers,
short_transfer(), archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer())(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
#endif // defined(ASIO_HAS_BOOST_ARRAY)
}
void test_4_arg_std_array_buffers_async_read()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
std::array<asio::mutable_buffer, 2> buffers = { {
asio::buffer(read_buf, 32),
asio::buffer(read_buf) + 32 } };
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read(s, buffers, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read(s, buffers,
short_transfer(), archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer())(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
}
void test_4_arg_vector_buffers_async_read()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
char read_buf[sizeof(read_data)];
std::vector<asio::mutable_buffer> buffers;
buffers.push_back(asio::buffer(read_buf, 32));
buffers.push_back(asio::buffer(read_buf, 39) + 32);
buffers.push_back(asio::buffer(read_buf) + 39);
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
bool called = false;
asio::async_read(s, buffers, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 50));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 1));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 10));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, 42));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
memset(read_buf, 0, sizeof(read_buf));
int i = asio::async_read(s, buffers,
short_transfer(), archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
memset(read_buf, 0, sizeof(read_buf));
called = false;
asio::async_read(s, buffers, short_transfer())(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
}
void test_4_arg_dynamic_string_async_read()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
std::string data;
asio::dynamic_string_buffer<char, std::string::traits_type,
std::string::allocator_type> sb
= asio::dynamic_buffer(data, sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bool called = false;
asio::async_read(s, sb, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 50);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 50));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
int i = asio::async_read(s, sb,
short_transfer(), archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, short_transfer())(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
}
void test_4_arg_streambuf_async_read()
{
#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_stream s(ioc);
asio::streambuf sb(sizeof(read_data));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
bool called = false;
asio::async_read(s, sb, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_all(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(1),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_at_least(42),
bindns::bind(async_read_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 50);
ASIO_CHECK(s.check_buffers(sb.data(), 50));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(), 1));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(1),
bindns::bind(async_read_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 1);
ASIO_CHECK(s.check_buffers(sb.data(), 1));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(10),
bindns::bind(async_read_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 10);
ASIO_CHECK(s.check_buffers(sb.data(), 10));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(), 42));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, asio::transfer_exactly(42),
bindns::bind(async_read_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == 42);
ASIO_CHECK(s.check_buffers(sb.data(), 42));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, old_style_transfer_all,
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(1);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, short_transfer(),
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
sb.consume(sb.size());
int i = asio::async_read(s, sb,
short_transfer(), archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
s.reset(read_data, sizeof(read_data));
s.next_read_length(10);
sb.consume(sb.size());
called = false;
asio::async_read(s, sb, short_transfer())(
bindns::bind(async_read_handler,
_1, _2, sizeof(read_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(sb.size() == sizeof(read_data));
ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
}
ASIO_TEST_SUITE
(
"read",
ASIO_TEST_CASE(test_2_arg_zero_buffers_read)
ASIO_TEST_CASE(test_2_arg_mutable_buffer_read)
ASIO_TEST_CASE(test_2_arg_vector_buffers_read)
ASIO_TEST_CASE(test_2_arg_dynamic_string_read)
ASIO_TEST_CASE(test_2_arg_streambuf_read)
ASIO_TEST_CASE(test_3_arg_nothrow_zero_buffers_read)
ASIO_TEST_CASE(test_3_arg_nothrow_mutable_buffer_read)
ASIO_TEST_CASE(test_3_arg_nothrow_vector_buffers_read)
ASIO_TEST_CASE(test_3_arg_nothrow_dynamic_string_read)
ASIO_TEST_CASE(test_3_arg_nothrow_streambuf_read)
ASIO_TEST_CASE(test_3_arg_mutable_buffer_read)
ASIO_TEST_CASE(test_3_arg_vector_buffers_read)
ASIO_TEST_CASE(test_3_arg_dynamic_string_read)
ASIO_TEST_CASE(test_3_arg_streambuf_read)
ASIO_TEST_CASE(test_4_arg_mutable_buffer_read)
ASIO_TEST_CASE(test_4_arg_vector_buffers_read)
ASIO_TEST_CASE(test_4_arg_dynamic_string_read)
ASIO_TEST_CASE(test_4_arg_streambuf_read)
ASIO_TEST_CASE(test_3_arg_mutable_buffer_async_read)
ASIO_TEST_CASE(test_3_arg_boost_array_buffers_async_read)
ASIO_TEST_CASE(test_3_arg_std_array_buffers_async_read)
ASIO_TEST_CASE(test_3_arg_vector_buffers_async_read)
ASIO_TEST_CASE(test_3_arg_dynamic_string_async_read)
ASIO_TEST_CASE(test_3_arg_streambuf_async_read)
ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_read)
ASIO_TEST_CASE(test_4_arg_vector_buffers_async_read)
ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_read)
ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_read)
ASIO_TEST_CASE(test_4_arg_dynamic_string_async_read)
ASIO_TEST_CASE(test_4_arg_streambuf_async_read)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/immediate.cpp | //
// immediate.cpp
// ~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/immediate.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"immediate",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/associated_immediate_executor.cpp | //
// associated_immediate_executor.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2022 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/associated_immediate_executor.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"associated_immediate_executor",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/io_context_strand.cpp | //
// io_context_strand.cpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/io_context_strand.hpp"
#include <functional>
#include <sstream>
#include "asio/io_context.hpp"
#include "asio/dispatch.hpp"
#include "asio/post.hpp"
#include "asio/thread.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_BOOST_DATE_TIME)
# include "asio/deadline_timer.hpp"
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
# include "asio/steady_timer.hpp"
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
using namespace asio;
namespace bindns = std;
#if defined(ASIO_HAS_BOOST_DATE_TIME)
typedef deadline_timer timer;
namespace chronons = boost::posix_time;
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
typedef steady_timer timer;
namespace chronons = asio::chrono;
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
void increment(int* count)
{
++(*count);
}
void increment_without_lock(io_context::strand* s, int* count)
{
ASIO_CHECK(!s->running_in_this_thread());
int original_count = *count;
dispatch(*s, bindns::bind(increment, count));
// No other functions are currently executing through the locking dispatcher,
// so the previous call to dispatch should have successfully nested.
ASIO_CHECK(*count == original_count + 1);
}
void increment_with_lock(io_context::strand* s, int* count)
{
ASIO_CHECK(s->running_in_this_thread());
int original_count = *count;
dispatch(*s, bindns::bind(increment, count));
// The current function already holds the strand's lock, so the
// previous call to dispatch should have successfully nested.
ASIO_CHECK(*count == original_count + 1);
}
void sleep_increment(io_context* ioc, int* count)
{
timer t(*ioc, chronons::seconds(2));
t.wait();
++(*count);
}
void increment_by_a(int* count, int a)
{
(*count) += a;
}
void increment_by_a_b(int* count, int a, int b)
{
(*count) += a + b;
}
void increment_by_a_b_c(int* count, int a, int b, int c)
{
(*count) += a + b + c;
}
void increment_by_a_b_c_d(int* count, int a, int b, int c, int d)
{
(*count) += a + b + c + d;
}
void start_sleep_increments(io_context* ioc, io_context::strand* s, int* count)
{
// Give all threads a chance to start.
timer t(*ioc, chronons::seconds(2));
t.wait();
// Start three increments.
post(*s, bindns::bind(sleep_increment, ioc, count));
post(*s, bindns::bind(sleep_increment, ioc, count));
post(*s, bindns::bind(sleep_increment, ioc, count));
}
void throw_exception()
{
throw 1;
}
void io_context_run(io_context* ioc)
{
ioc->run();
}
void strand_test()
{
io_context ioc;
io_context::strand s(ioc);
int count = 0;
post(ioc, bindns::bind(increment_without_lock, &s, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
post(s, bindns::bind(increment_with_lock, &s, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
ioc.run();
// The run() call will not return until all work has finished.
ASIO_CHECK(count == 1);
count = 0;
ioc.restart();
post(ioc, bindns::bind(start_sleep_increments, &ioc, &s, &count));
thread thread1(bindns::bind(io_context_run, &ioc));
thread thread2(bindns::bind(io_context_run, &ioc));
// Check all events run one after another even though there are two threads.
timer timer1(ioc, chronons::seconds(3));
timer1.wait();
ASIO_CHECK(count == 0);
#if defined(ASIO_HAS_BOOST_DATE_TIME)
timer1.expires_at(timer1.expires_at() + chronons::seconds(2));
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
timer1.expires_at(timer1.expiry() + chronons::seconds(2));
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
timer1.wait();
ASIO_CHECK(count == 1);
#if defined(ASIO_HAS_BOOST_DATE_TIME)
timer1.expires_at(timer1.expires_at() + chronons::seconds(2));
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
timer1.expires_at(timer1.expiry() + chronons::seconds(2));
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
timer1.wait();
ASIO_CHECK(count == 2);
thread1.join();
thread2.join();
// The run() calls will not return until all work has finished.
ASIO_CHECK(count == 3);
count = 0;
int exception_count = 0;
ioc.restart();
post(s, throw_exception);
post(s, bindns::bind(increment, &count));
post(s, bindns::bind(increment, &count));
post(s, throw_exception);
post(s, bindns::bind(increment, &count));
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
ASIO_CHECK(exception_count == 0);
for (;;)
{
try
{
ioc.run();
break;
}
catch (int)
{
++exception_count;
}
}
// The run() calls will not return until all work has finished.
ASIO_CHECK(count == 3);
ASIO_CHECK(exception_count == 2);
count = 0;
ioc.restart();
// Check for clean shutdown when handlers posted through an orphaned strand
// are abandoned.
{
io_context::strand s2(ioc);
post(s2, bindns::bind(increment, &count));
post(s2, bindns::bind(increment, &count));
post(s2, bindns::bind(increment, &count));
}
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
}
void strand_wrap_test()
{
#if !defined(ASIO_NO_DEPRECATED)
io_context ioc;
io_context::strand s(ioc);
int count = 0;
s.wrap(bindns::bind(increment, &count))();
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
ioc.restart();
ioc.run();
// The run() calls will not return until all work has finished.
ASIO_CHECK(count == 1);
count = 0;
s.wrap(increment)(&count);
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
ioc.restart();
ioc.run();
// The run() calls will not return until all work has finished.
ASIO_CHECK(count == 1);
count = 0;
s.wrap(increment_by_a)(&count, 1);
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
ioc.restart();
ioc.run();
// The run() calls will not return until all work has finished.
ASIO_CHECK(count == 1);
count = 0;
s.wrap(increment_by_a_b)(&count, 1, 2);
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
ioc.restart();
ioc.run();
// The run() calls will not return until all work has finished.
ASIO_CHECK(count == 3);
count = 0;
s.wrap(increment_by_a_b_c)(&count, 1, 2, 3);
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
ioc.restart();
ioc.run();
// The run() calls will not return until all work has finished.
ASIO_CHECK(count == 6);
count = 0;
s.wrap(increment_by_a_b_c_d)(&count, 1, 2, 3, 4);
// No handlers can be called until run() is called.
ASIO_CHECK(count == 0);
ioc.restart();
ioc.run();
// The run() calls will not return until all work has finished.
ASIO_CHECK(count == 10);
#endif // !defined(ASIO_NO_DEPRECATED)
}
ASIO_TEST_SUITE
(
"strand",
ASIO_TEST_CASE(strand_test)
ASIO_TEST_CASE(strand_wrap_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/buffer_registration.cpp | //
// buffer_registration.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/buffer_registration.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"buffer_registration",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/system_executor.cpp | //
// system_executor.cpp
// ~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/system_executor.hpp"
#include <functional>
#include "asio/dispatch.hpp"
#include "asio/post.hpp"
#include "unit_test.hpp"
using namespace asio;
namespace bindns = std;
void increment(asio::detail::atomic_count* count)
{
++(*count);
}
void system_executor_query_test()
{
ASIO_CHECK(
&asio::query(system_executor(),
asio::execution::context)
!= static_cast<const system_context*>(0));
ASIO_CHECK(
asio::query(system_executor(),
asio::execution::blocking)
== asio::execution::blocking.possibly);
ASIO_CHECK(
asio::query(system_executor(),
asio::execution::blocking.possibly)
== asio::execution::blocking.possibly);
ASIO_CHECK(
asio::query(system_executor(),
asio::execution::outstanding_work)
== asio::execution::outstanding_work.untracked);
ASIO_CHECK(
asio::query(system_executor(),
asio::execution::outstanding_work.untracked)
== asio::execution::outstanding_work.untracked);
ASIO_CHECK(
asio::query(system_executor(),
asio::execution::relationship)
== asio::execution::relationship.fork);
ASIO_CHECK(
asio::query(system_executor(),
asio::execution::relationship.fork)
== asio::execution::relationship.fork);
ASIO_CHECK(
asio::query(system_executor(),
asio::execution::mapping)
== asio::execution::mapping.thread);
ASIO_CHECK(
asio::query(system_executor(),
asio::execution::allocator)
== std::allocator<void>());
}
void system_executor_execute_test()
{
asio::detail::atomic_count count(0);
system_executor().execute(bindns::bind(increment, &count));
asio::require(system_executor(),
asio::execution::blocking.possibly
).execute(bindns::bind(increment, &count));
asio::require(system_executor(),
asio::execution::blocking.always
).execute(bindns::bind(increment, &count));
asio::require(system_executor(),
asio::execution::blocking.never
).execute(bindns::bind(increment, &count));
asio::require(system_executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked
).execute(bindns::bind(increment, &count));
asio::require(system_executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.fork
).execute(bindns::bind(increment, &count));
asio::require(system_executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation
).execute(bindns::bind(increment, &count));
asio::prefer(
asio::require(system_executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation),
asio::execution::allocator(std::allocator<void>())
).execute(bindns::bind(increment, &count));
asio::prefer(
asio::require(system_executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation),
asio::execution::allocator
).execute(bindns::bind(increment, &count));
asio::query(system_executor(), execution::context).join();
ASIO_CHECK(count == 9);
}
ASIO_TEST_SUITE
(
"system_executor",
ASIO_TEST_CASE(system_executor_query_test)
ASIO_TEST_CASE(system_executor_execute_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/writable_pipe.cpp | //
// writable_pipe.cpp
// ~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header pipe is self-contained.
#include "asio/writable_pipe.hpp"
#include "archetypes/async_result.hpp"
#include "asio/io_context.hpp"
#include "unit_test.hpp"
// writable_pipe_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all public member functions on the class
// writable_pipe compile and link correctly. Runtime failures are ignored.
namespace writable_pipe_compile {
struct write_some_handler
{
write_some_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
write_some_handler(write_some_handler&&) {}
private:
write_some_handler(const write_some_handler&);
};
struct read_some_handler
{
read_some_handler() {}
void operator()(const asio::error_code&, std::size_t) {}
read_some_handler(read_some_handler&&) {}
private:
read_some_handler(const read_some_handler&);
};
void test()
{
#if defined(ASIO_HAS_PIPE)
using namespace asio;
try
{
io_context ioc;
const io_context::executor_type ioc_ex = ioc.get_executor();
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
archetypes::lazy_handler lazy;
asio::error_code ec;
// basic_writable_pipe constructors.
writable_pipe pipe1(ioc);
writable_pipe::native_handle_type native_pipe1 = pipe1.native_handle();
writable_pipe pipe2(ioc, native_pipe1);
writable_pipe pipe3(ioc_ex);
writable_pipe::native_handle_type native_pipe2 = pipe1.native_handle();
writable_pipe pipe4(ioc_ex, native_pipe2);
writable_pipe pipe5(std::move(pipe4));
basic_writable_pipe<io_context::executor_type> pipe6(ioc);
writable_pipe pipe7(std::move(pipe6));
// basic_writable_pipe operators.
pipe1 = writable_pipe(ioc);
pipe1 = std::move(pipe2);
pipe1 = std::move(pipe6);
// basic_io_object functions.
writable_pipe::executor_type ex = pipe1.get_executor();
(void)ex;
// basic_writable_pipe functions.
writable_pipe::native_handle_type native_pipe3 = pipe1.native_handle();
pipe1.assign(native_pipe3);
writable_pipe::native_handle_type native_pipe4 = pipe1.native_handle();
pipe1.assign(native_pipe4, ec);
bool is_open = pipe1.is_open();
(void)is_open;
pipe1.close();
pipe1.close(ec);
writable_pipe::native_handle_type native_pipe5 = pipe1.release();
(void)native_pipe5;
writable_pipe::native_handle_type native_pipe6 = pipe1.release(ec);
(void)native_pipe6;
writable_pipe::native_handle_type native_pipe7 = pipe1.native_handle();
(void)native_pipe7;
pipe1.cancel();
pipe1.cancel(ec);
pipe1.write_some(buffer(mutable_char_buffer));
pipe1.write_some(buffer(const_char_buffer));
pipe1.write_some(buffer(mutable_char_buffer), ec);
pipe1.write_some(buffer(const_char_buffer), ec);
pipe1.async_write_some(buffer(mutable_char_buffer), write_some_handler());
pipe1.async_write_some(buffer(const_char_buffer), write_some_handler());
int i1 = pipe1.async_write_some(buffer(mutable_char_buffer), lazy);
(void)i1;
int i2 = pipe1.async_write_some(buffer(const_char_buffer), lazy);
(void)i2;
}
catch (std::exception&)
{
}
#endif // defined(ASIO_HAS_PIPE)
}
} // namespace writable_pipe_compile
ASIO_TEST_SUITE
(
"writable_pipe",
ASIO_COMPILE_TEST_CASE(writable_pipe_compile::test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/steady_timer.cpp | //
// steady_timer.cpp
// ~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/steady_timer.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"steady_timer",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/use_future.cpp | //
// use_future.cpp
// ~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/use_future.hpp"
#include <string>
#include "unit_test.hpp"
#if defined(ASIO_HAS_STD_FUTURE_CLASS)
#include "archetypes/async_ops.hpp"
void use_future_0_test()
{
using asio::use_future;
using namespace archetypes;
std::future<void> f;
f = async_op_0(use_future);
try
{
f.get();
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_0(true, use_future);
try
{
f.get();
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_0(false, use_future);
try
{
f.get();
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::operation_aborted);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_0(true, use_future);
try
{
f.get();
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_0(false, use_future);
try
{
f.get();
ASIO_CHECK(false);
}
catch (std::exception& e)
{
ASIO_CHECK(e.what() == std::string("blah"));
}
catch (...)
{
ASIO_CHECK(false);
}
}
void use_future_1_test()
{
using asio::use_future;
using namespace archetypes;
std::future<int> f;
f = async_op_1(use_future);
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_1(true, use_future);
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_1(false, use_future);
try
{
int i = f.get();
ASIO_CHECK(false);
(void)i;
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::operation_aborted);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_1(true, use_future);
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_1(false, use_future);
try
{
int i = f.get();
ASIO_CHECK(false);
(void)i;
}
catch (std::exception& e)
{
ASIO_CHECK(e.what() == std::string("blah"));
}
catch (...)
{
ASIO_CHECK(false);
}
}
void use_future_2_test()
{
using asio::use_future;
using namespace archetypes;
std::future<std::tuple<int, double>> f;
f = async_op_2(use_future);
try
{
int i;
double d;
std::tie(i, d) = f.get();
ASIO_CHECK(i == 42);
ASIO_CHECK(d == 2.0);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_2(true, use_future);
try
{
int i;
double d;
std::tie(i, d) = f.get();
ASIO_CHECK(i == 42);
ASIO_CHECK(d == 2.0);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_2(false, use_future);
try
{
std::tuple<int, double> t = f.get();
ASIO_CHECK(false);
(void)t;
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::operation_aborted);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_2(true, use_future);
try
{
int i;
double d;
std::tie(i, d) = f.get();
ASIO_CHECK(i == 42);
ASIO_CHECK(d == 2.0);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_2(false, use_future);
try
{
std::tuple<int, double> t = f.get();
ASIO_CHECK(false);
(void)t;
}
catch (std::exception& e)
{
ASIO_CHECK(e.what() == std::string("blah"));
}
catch (...)
{
ASIO_CHECK(false);
}
}
void use_future_3_test()
{
using asio::use_future;
using namespace archetypes;
std::future<std::tuple<int, double, char>> f;
f = async_op_3(use_future);
try
{
int i;
double d;
char c;
std::tie(i, d, c) = f.get();
ASIO_CHECK(i == 42);
ASIO_CHECK(d == 2.0);
ASIO_CHECK(c == 'a');
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_3(true, use_future);
try
{
int i;
double d;
char c;
std::tie(i, d, c) = f.get();
ASIO_CHECK(i == 42);
ASIO_CHECK(d == 2.0);
ASIO_CHECK(c == 'a');
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_3(false, use_future);
try
{
std::tuple<int, double, char> t = f.get();
ASIO_CHECK(false);
(void)t;
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::operation_aborted);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_3(true, use_future);
try
{
int i;
double d;
char c;
std::tie(i, d, c) = f.get();
ASIO_CHECK(i == 42);
ASIO_CHECK(d == 2.0);
ASIO_CHECK(c == 'a');
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_3(false, use_future);
try
{
std::tuple<int, double, char> t = f.get();
ASIO_CHECK(false);
(void)t;
}
catch (std::exception& e)
{
ASIO_CHECK(e.what() == std::string("blah"));
}
catch (...)
{
ASIO_CHECK(false);
}
}
int package_0()
{
return 42;
}
int package_ec_0(asio::error_code ec)
{
return ec ? 0 : 42;
}
int package_ex_0(std::exception_ptr ex)
{
return ex ? 0 : 42;
}
void use_future_package_0_test()
{
using asio::use_future;
using namespace archetypes;
std::future<int> f;
f = async_op_0(use_future(package_0));
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_0(true, use_future(&package_ec_0));
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_0(false, use_future(package_ec_0));
try
{
int i = f.get();
ASIO_CHECK(i == 0);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_0(true, use_future(package_ex_0));
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_0(false, use_future(package_ex_0));
try
{
int i = f.get();
ASIO_CHECK(i == 0);
}
catch (...)
{
ASIO_CHECK(false);
}
}
int package_1(int i)
{
return i;
}
int package_ec_1(asio::error_code ec, int i)
{
return ec ? 0 : i;
}
int package_ex_1(std::exception_ptr ex, int i)
{
return ex ? 0 : i;
}
void use_future_package_1_test()
{
using asio::use_future;
using namespace archetypes;
std::future<int> f;
f = async_op_1(use_future(package_1));
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_1(true, use_future(package_ec_1));
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_1(false, use_future(package_ec_1));
try
{
int i = f.get();
ASIO_CHECK(i == 0);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_1(true, use_future(package_ex_1));
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_1(false, use_future(package_ex_1));
try
{
int i = f.get();
ASIO_CHECK(i == 0);
}
catch (...)
{
ASIO_CHECK(false);
}
}
int package_2(int i, double)
{
return i;
}
int package_ec_2(asio::error_code ec, int i, double)
{
return ec ? 0 : i;
}
int package_ex_2(std::exception_ptr ex, int i, double)
{
return ex ? 0 : i;
}
void use_future_package_2_test()
{
using asio::use_future;
using namespace archetypes;
std::future<int> f;
f = async_op_2(use_future(package_2));
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_2(true, use_future(package_ec_2));
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_2(false, use_future(package_ec_2));
try
{
int i = f.get();
ASIO_CHECK(i == 0);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_2(true, use_future(package_ex_2));
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_2(false, use_future(package_ex_2));
try
{
int i = f.get();
ASIO_CHECK(i == 0);
}
catch (...)
{
ASIO_CHECK(false);
}
}
int package_3(int i, double, char)
{
return i;
}
int package_ec_3(asio::error_code ec, int i, double, char)
{
return ec ? 0 : i;
}
int package_ex_3(std::exception_ptr ex, int i, double, char)
{
return ex ? 0 : i;
}
void use_future_package_3_test()
{
using asio::use_future;
using namespace archetypes;
std::future<int> f;
f = async_op_3(use_future(package_3));
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_3(true, use_future(package_ec_3));
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ec_3(false, use_future(package_ec_3));
try
{
int i = f.get();
ASIO_CHECK(i == 0);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_3(true, use_future(package_ex_3));
try
{
int i = f.get();
ASIO_CHECK(i == 42);
}
catch (...)
{
ASIO_CHECK(false);
}
f = async_op_ex_3(false, use_future(package_ex_3));
try
{
int i = f.get();
ASIO_CHECK(i == 0);
}
catch (...)
{
ASIO_CHECK(false);
}
}
ASIO_TEST_SUITE
(
"use_future",
ASIO_TEST_CASE(use_future_0_test)
ASIO_TEST_CASE(use_future_1_test)
ASIO_TEST_CASE(use_future_2_test)
ASIO_TEST_CASE(use_future_3_test)
ASIO_TEST_CASE(use_future_package_0_test)
ASIO_TEST_CASE(use_future_package_1_test)
ASIO_TEST_CASE(use_future_package_2_test)
ASIO_TEST_CASE(use_future_package_3_test)
)
#else // defined(ASIO_HAS_STD_FUTURE_CLASS)
ASIO_TEST_SUITE
(
"use_future",
ASIO_TEST_CASE(null_test)
)
#endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/connect.cpp | //
// connect.cpp
// ~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/connect.hpp"
#include <functional>
#include <vector>
#include "asio/detail/thread.hpp"
#include "asio/ip/tcp.hpp"
#include "unit_test.hpp"
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
class connection_sink
{
public:
connection_sink()
: acceptor_(io_context_,
asio::ip::tcp::endpoint(
asio::ip::address_v4::loopback(), 0)),
target_endpoint_(acceptor_.local_endpoint()),
socket_(io_context_),
thread_(bindns::bind(&connection_sink::run, this))
{
}
~connection_sink()
{
io_context_.stop();
thread_.join();
}
asio::ip::tcp::endpoint target_endpoint()
{
return target_endpoint_;
}
private:
void run()
{
io_context_.run();
}
void handle_accept()
{
socket_.close();
acceptor_.async_accept(socket_,
bindns::bind(&connection_sink::handle_accept, this));
}
asio::io_context io_context_;
asio::ip::tcp::acceptor acceptor_;
asio::ip::tcp::endpoint target_endpoint_;
asio::ip::tcp::socket socket_;
asio::detail::thread thread_;
};
bool true_cond_1(const asio::error_code& /*ec*/,
const asio::ip::tcp::endpoint& /*endpoint*/)
{
return true;
}
struct true_cond_2
{
template <typename Endpoint>
bool operator()(const asio::error_code& /*ec*/,
const Endpoint& /*endpoint*/)
{
return true;
}
};
std::vector<asio::ip::tcp::endpoint>::const_iterator legacy_true_cond_1(
const asio::error_code& /*ec*/,
std::vector<asio::ip::tcp::endpoint>::const_iterator next)
{
return next;
}
struct legacy_true_cond_2
{
template <typename Iterator>
Iterator operator()(const asio::error_code& /*ec*/, Iterator next)
{
return next;
}
};
bool false_cond(const asio::error_code& /*ec*/,
const asio::ip::tcp::endpoint& /*endpoint*/)
{
return false;
}
void range_handler(const asio::error_code& ec,
const asio::ip::tcp::endpoint& endpoint,
asio::error_code* out_ec,
asio::ip::tcp::endpoint* out_endpoint)
{
*out_ec = ec;
*out_endpoint = endpoint;
}
void iter_handler(const asio::error_code& ec,
std::vector<asio::ip::tcp::endpoint>::const_iterator iter,
asio::error_code* out_ec,
std::vector<asio::ip::tcp::endpoint>::const_iterator* out_iter)
{
*out_ec = ec;
*out_iter = iter;
}
void test_connect_range()
{
connection_sink sink;
asio::io_context io_context;
asio::ip::tcp::socket socket(io_context);
std::vector<asio::ip::tcp::endpoint> endpoints;
asio::ip::tcp::endpoint result;
try
{
result = asio::connect(socket, endpoints);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, endpoints);
ASIO_CHECK(result == endpoints[0]);
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, endpoints);
ASIO_CHECK(result == endpoints[0]);
endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
result = asio::connect(socket, endpoints);
ASIO_CHECK(result == endpoints[1]);
}
void test_connect_range_ec()
{
connection_sink sink;
asio::io_context io_context;
asio::ip::tcp::socket socket(io_context);
std::vector<asio::ip::tcp::endpoint> endpoints;
asio::ip::tcp::endpoint result;
asio::error_code ec;
result = asio::connect(socket, endpoints, ec);
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, endpoints, ec);
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, endpoints, ec);
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
result = asio::connect(socket, endpoints, ec);
ASIO_CHECK(result == endpoints[1]);
ASIO_CHECK(!ec);
}
void test_connect_range_cond()
{
connection_sink sink;
asio::io_context io_context;
asio::ip::tcp::socket socket(io_context);
std::vector<asio::ip::tcp::endpoint> endpoints;
asio::ip::tcp::endpoint result;
try
{
result = asio::connect(socket, endpoints, true_cond_1);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
try
{
result = asio::connect(socket, endpoints, true_cond_2());
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
try
{
result = asio::connect(socket, endpoints, legacy_true_cond_1);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
try
{
result = asio::connect(socket, endpoints, legacy_true_cond_2());
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
try
{
result = asio::connect(socket, endpoints, false_cond);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, endpoints, true_cond_1);
ASIO_CHECK(result == endpoints[0]);
result = asio::connect(socket, endpoints, true_cond_2());
ASIO_CHECK(result == endpoints[0]);
result = asio::connect(socket, endpoints, legacy_true_cond_1);
ASIO_CHECK(result == endpoints[0]);
result = asio::connect(socket, endpoints, legacy_true_cond_2());
ASIO_CHECK(result == endpoints[0]);
try
{
result = asio::connect(socket, endpoints, false_cond);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, endpoints, true_cond_1);
ASIO_CHECK(result == endpoints[0]);
result = asio::connect(socket, endpoints, true_cond_2());
ASIO_CHECK(result == endpoints[0]);
result = asio::connect(socket, endpoints, legacy_true_cond_1);
ASIO_CHECK(result == endpoints[0]);
result = asio::connect(socket, endpoints, legacy_true_cond_2());
ASIO_CHECK(result == endpoints[0]);
try
{
result = asio::connect(socket, endpoints, false_cond);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
result = asio::connect(socket, endpoints, true_cond_1);
ASIO_CHECK(result == endpoints[1]);
result = asio::connect(socket, endpoints, true_cond_2());
ASIO_CHECK(result == endpoints[1]);
result = asio::connect(socket, endpoints, legacy_true_cond_1);
ASIO_CHECK(result == endpoints[1]);
result = asio::connect(socket, endpoints, legacy_true_cond_2());
ASIO_CHECK(result == endpoints[1]);
try
{
result = asio::connect(socket, endpoints, false_cond);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
}
void test_connect_range_cond_ec()
{
connection_sink sink;
asio::io_context io_context;
asio::ip::tcp::socket socket(io_context);
std::vector<asio::ip::tcp::endpoint> endpoints;
asio::ip::tcp::endpoint result;
asio::error_code ec;
result = asio::connect(socket, endpoints, true_cond_1, ec);
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
result = asio::connect(socket, endpoints, true_cond_2(), ec);
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
result = asio::connect(socket, endpoints, legacy_true_cond_1, ec);
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
result = asio::connect(socket, endpoints, legacy_true_cond_2(), ec);
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
result = asio::connect(socket, endpoints, false_cond, ec);
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, endpoints, true_cond_1, ec);
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
result = asio::connect(socket, endpoints, true_cond_2(), ec);
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
result = asio::connect(socket, endpoints, legacy_true_cond_1, ec);
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
result = asio::connect(socket, endpoints, legacy_true_cond_2(), ec);
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
result = asio::connect(socket, endpoints, false_cond, ec);
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, endpoints, true_cond_1, ec);
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
result = asio::connect(socket, endpoints, true_cond_2(), ec);
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
result = asio::connect(socket, endpoints, legacy_true_cond_1, ec);
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
result = asio::connect(socket, endpoints, legacy_true_cond_2(), ec);
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
result = asio::connect(socket, endpoints, false_cond, ec);
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
result = asio::connect(socket, endpoints, true_cond_1, ec);
ASIO_CHECK(result == endpoints[1]);
ASIO_CHECK(!ec);
result = asio::connect(socket, endpoints, true_cond_2(), ec);
ASIO_CHECK(result == endpoints[1]);
ASIO_CHECK(!ec);
result = asio::connect(socket, endpoints, legacy_true_cond_1, ec);
ASIO_CHECK(result == endpoints[1]);
ASIO_CHECK(!ec);
result = asio::connect(socket, endpoints, legacy_true_cond_2(), ec);
ASIO_CHECK(result == endpoints[1]);
ASIO_CHECK(!ec);
result = asio::connect(socket, endpoints, false_cond, ec);
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
}
void test_connect_iter()
{
connection_sink sink;
asio::io_context io_context;
asio::ip::tcp::socket socket(io_context);
std::vector<asio::ip::tcp::endpoint> endpoints;
const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
std::vector<asio::ip::tcp::endpoint>::const_iterator result;
try
{
result = asio::connect(socket, cendpoints.begin(), cendpoints.end());
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, cendpoints.begin(), cendpoints.end());
ASIO_CHECK(result == cendpoints.begin());
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, cendpoints.begin(), cendpoints.end());
ASIO_CHECK(result == cendpoints.begin());
endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
result = asio::connect(socket, cendpoints.begin(), cendpoints.end());
ASIO_CHECK(result == cendpoints.begin() + 1);
}
void test_connect_iter_ec()
{
connection_sink sink;
asio::io_context io_context;
asio::ip::tcp::socket socket(io_context);
std::vector<asio::ip::tcp::endpoint> endpoints;
const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
std::vector<asio::ip::tcp::endpoint>::const_iterator result;
asio::error_code ec;
result = asio::connect(socket,
cendpoints.begin(), cendpoints.end(), ec);
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket,
cendpoints.begin(), cendpoints.end(), ec);
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket,
cendpoints.begin(), cendpoints.end(), ec);
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
result = asio::connect(socket,
cendpoints.begin(), cendpoints.end(), ec);
ASIO_CHECK(result == cendpoints.begin() + 1);
ASIO_CHECK(!ec);
}
void test_connect_iter_cond()
{
connection_sink sink;
asio::io_context io_context;
asio::ip::tcp::socket socket(io_context);
std::vector<asio::ip::tcp::endpoint> endpoints;
const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
std::vector<asio::ip::tcp::endpoint>::const_iterator result;
try
{
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_1);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
try
{
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_2());
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
try
{
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_1);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
try
{
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_2());
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
try
{
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), false_cond);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_1);
ASIO_CHECK(result == cendpoints.begin());
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_2());
ASIO_CHECK(result == cendpoints.begin());
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_1);
ASIO_CHECK(result == cendpoints.begin());
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_2());
ASIO_CHECK(result == cendpoints.begin());
try
{
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), false_cond);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_1);
ASIO_CHECK(result == cendpoints.begin());
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_2());
ASIO_CHECK(result == cendpoints.begin());
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_1);
ASIO_CHECK(result == cendpoints.begin());
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_2());
ASIO_CHECK(result == cendpoints.begin());
try
{
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), false_cond);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_1);
ASIO_CHECK(result == cendpoints.begin() + 1);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_2());
ASIO_CHECK(result == cendpoints.begin() + 1);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_1);
ASIO_CHECK(result == cendpoints.begin() + 1);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_2());
ASIO_CHECK(result == cendpoints.begin() + 1);
try
{
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), false_cond);
ASIO_CHECK(false);
}
catch (asio::system_error& e)
{
ASIO_CHECK(e.code() == asio::error::not_found);
}
}
void test_connect_iter_cond_ec()
{
connection_sink sink;
asio::io_context io_context;
asio::ip::tcp::socket socket(io_context);
std::vector<asio::ip::tcp::endpoint> endpoints;
const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
std::vector<asio::ip::tcp::endpoint>::const_iterator result;
asio::error_code ec;
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_1, ec);
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_2(), ec);
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_1, ec);
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_2(), ec);
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), false_cond, ec);
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_1, ec);
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_2(), ec);
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_1, ec);
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_2(), ec);
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), false_cond, ec);
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.push_back(sink.target_endpoint());
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_1, ec);
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_2(), ec);
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_1, ec);
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_2(), ec);
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), false_cond, ec);
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_1, ec);
ASIO_CHECK(result == cendpoints.begin() + 1);
ASIO_CHECK(!ec);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), true_cond_2(), ec);
ASIO_CHECK(result == cendpoints.begin() + 1);
ASIO_CHECK(!ec);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_1, ec);
ASIO_CHECK(result == cendpoints.begin() + 1);
ASIO_CHECK(!ec);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), legacy_true_cond_2(), ec);
ASIO_CHECK(result == cendpoints.begin() + 1);
ASIO_CHECK(!ec);
result = asio::connect(socket, cendpoints.begin(),
cendpoints.end(), false_cond, ec);
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
}
void test_async_connect_range()
{
connection_sink sink;
asio::io_context io_context;
asio::ip::tcp::socket socket(io_context);
std::vector<asio::ip::tcp::endpoint> endpoints;
asio::ip::tcp::endpoint result;
asio::error_code ec;
asio::async_connect(socket, endpoints,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.push_back(sink.target_endpoint());
asio::async_connect(socket, endpoints,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
endpoints.push_back(sink.target_endpoint());
asio::async_connect(socket, endpoints,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
asio::async_connect(socket, endpoints,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[1]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints)(
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[1]);
ASIO_CHECK(!ec);
}
void test_async_connect_range_cond()
{
connection_sink sink;
asio::io_context io_context;
asio::ip::tcp::socket socket(io_context);
std::vector<asio::ip::tcp::endpoint> endpoints;
asio::ip::tcp::endpoint result;
asio::error_code ec;
asio::async_connect(socket, endpoints, true_cond_1,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
asio::async_connect(socket, endpoints, true_cond_2(),
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
asio::async_connect(socket, endpoints, legacy_true_cond_1,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
asio::async_connect(socket, endpoints, legacy_true_cond_2(),
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
asio::async_connect(socket, endpoints, false_cond,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.push_back(sink.target_endpoint());
asio::async_connect(socket, endpoints, true_cond_1,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints, true_cond_2(),
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints, legacy_true_cond_1,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints, legacy_true_cond_2(),
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints, false_cond,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.push_back(sink.target_endpoint());
asio::async_connect(socket, endpoints, true_cond_1,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints, true_cond_2(),
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints, legacy_true_cond_1,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints, legacy_true_cond_2(),
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[0]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints, false_cond,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
asio::async_connect(socket, endpoints, true_cond_1,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[1]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints, true_cond_2(),
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[1]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints, legacy_true_cond_1,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[1]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints, legacy_true_cond_2(),
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == endpoints[1]);
ASIO_CHECK(!ec);
asio::async_connect(socket, endpoints, false_cond,
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
asio::async_connect(socket, endpoints, false_cond)(
bindns::bind(range_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == asio::ip::tcp::endpoint());
ASIO_CHECK(ec == asio::error::not_found);
}
void test_async_connect_iter()
{
connection_sink sink;
asio::io_context io_context;
asio::ip::tcp::socket socket(io_context);
std::vector<asio::ip::tcp::endpoint> endpoints;
const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
std::vector<asio::ip::tcp::endpoint>::const_iterator result;
asio::error_code ec;
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.push_back(sink.target_endpoint());
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
endpoints.push_back(sink.target_endpoint());
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin() + 1);
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end())(
bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin() + 1);
ASIO_CHECK(!ec);
}
void test_async_connect_iter_cond()
{
connection_sink sink;
asio::io_context io_context;
asio::ip::tcp::socket socket(io_context);
std::vector<asio::ip::tcp::endpoint> endpoints;
const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
std::vector<asio::ip::tcp::endpoint>::const_iterator result;
asio::error_code ec;
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
legacy_true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
legacy_true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
false_cond, bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.push_back(sink.target_endpoint());
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
legacy_true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
legacy_true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
false_cond, bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.push_back(sink.target_endpoint());
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
legacy_true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
legacy_true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin());
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
false_cond, bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin() + 1);
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin() + 1);
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
legacy_true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin() + 1);
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
legacy_true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.begin() + 1);
ASIO_CHECK(!ec);
asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
false_cond, bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
asio::async_connect(socket, cendpoints.begin(),
cendpoints.end(), false_cond)(
bindns::bind(iter_handler, _1, _2, &ec, &result));
io_context.restart();
io_context.run();
ASIO_CHECK(result == cendpoints.end());
ASIO_CHECK(ec == asio::error::not_found);
}
ASIO_TEST_SUITE
(
"connect",
ASIO_TEST_CASE(test_connect_range)
ASIO_TEST_CASE(test_connect_range_ec)
ASIO_TEST_CASE(test_connect_range_cond)
ASIO_TEST_CASE(test_connect_range_cond_ec)
ASIO_TEST_CASE(test_connect_iter)
ASIO_TEST_CASE(test_connect_iter_ec)
ASIO_TEST_CASE(test_connect_iter_cond)
ASIO_TEST_CASE(test_connect_iter_cond_ec)
ASIO_TEST_CASE(test_async_connect_range)
ASIO_TEST_CASE(test_async_connect_range_cond)
ASIO_TEST_CASE(test_async_connect_iter)
ASIO_TEST_CASE(test_async_connect_iter_cond)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/wait_traits.cpp | //
// wait_traits.cpp
// ~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/wait_traits.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"wait_traits",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/is_write_buffered.cpp | //
// is_write_buffered.cpp
// ~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/is_write_buffered.hpp"
#include "asio/buffered_read_stream.hpp"
#include "asio/buffered_write_stream.hpp"
#include "asio/io_context.hpp"
#include "asio/ip/tcp.hpp"
#include "unit_test.hpp"
using namespace std; // For memcmp, memcpy and memset.
class test_stream
{
public:
typedef asio::io_context io_context_type;
typedef test_stream lowest_layer_type;
typedef io_context_type::executor_type executor_type;
test_stream(asio::io_context& io_context)
: io_context_(io_context)
{
}
io_context_type& io_context()
{
return io_context_;
}
lowest_layer_type& lowest_layer()
{
return *this;
}
template <typename Const_Buffers>
size_t write(const Const_Buffers&)
{
return 0;
}
template <typename Const_Buffers>
size_t write(const Const_Buffers&, asio::error_code& ec)
{
ec = asio::error_code();
return 0;
}
template <typename Const_Buffers, typename Handler>
void async_write(const Const_Buffers&, Handler handler)
{
asio::error_code error;
asio::post(io_context_,
asio::detail::bind_handler(handler, error, 0));
}
template <typename Mutable_Buffers>
size_t read(const Mutable_Buffers&)
{
return 0;
}
template <typename Mutable_Buffers>
size_t read(const Mutable_Buffers&, asio::error_code& ec)
{
ec = asio::error_code();
return 0;
}
template <typename Mutable_Buffers, typename Handler>
void async_read(const Mutable_Buffers&, Handler handler)
{
asio::error_code error;
asio::post(io_context_,
asio::detail::bind_handler(handler, error, 0));
}
private:
io_context_type& io_context_;
};
void is_write_buffered_test()
{
ASIO_CHECK(!asio::is_write_buffered<
asio::ip::tcp::socket>::value);
ASIO_CHECK(!asio::is_write_buffered<
asio::buffered_read_stream<
asio::ip::tcp::socket> >::value);
ASIO_CHECK(!!asio::is_write_buffered<
asio::buffered_write_stream<
asio::ip::tcp::socket> >::value);
ASIO_CHECK(!!asio::is_write_buffered<
asio::buffered_stream<asio::ip::tcp::socket> >::value);
ASIO_CHECK(!asio::is_write_buffered<test_stream>::value);
ASIO_CHECK(!asio::is_write_buffered<
asio::buffered_read_stream<test_stream> >::value);
ASIO_CHECK(!!asio::is_write_buffered<
asio::buffered_write_stream<test_stream> >::value);
ASIO_CHECK(!!asio::is_write_buffered<
asio::buffered_stream<test_stream> >::value);
}
ASIO_TEST_SUITE
(
"is_write_buffered",
ASIO_TEST_CASE(is_write_buffered_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_readable_pipe.cpp | //
// basic_readable_pipe.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/basic_readable_pipe.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_readable_pipe",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/bind_cancellation_slot.cpp | //
// bind_cancellation_slot.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/bind_cancellation_slot.hpp"
#include <functional>
#include "asio/cancellation_signal.hpp"
#include "asio/io_context.hpp"
#include "asio/steady_timer.hpp"
#include "unit_test.hpp"
using namespace asio;
namespace bindns = std;
typedef steady_timer timer;
namespace chronons = asio::chrono;
void increment_on_cancel(int* count, const asio::error_code& error)
{
if (error == asio::error::operation_aborted)
++(*count);
}
void bind_cancellation_slot_to_function_object_test()
{
io_context ioc;
cancellation_signal sig;
int count = 0;
timer t(ioc, chronons::seconds(5));
t.async_wait(
bind_cancellation_slot(sig.slot(),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1)));
ioc.poll();
ASIO_CHECK(count == 0);
sig.emit(asio::cancellation_type::all);
ioc.run();
ASIO_CHECK(count == 1);
t.async_wait(
bind_cancellation_slot(sig.slot(),
bind_cancellation_slot(sig.slot(),
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1))));
ioc.restart();
ioc.poll();
ASIO_CHECK(count == 1);
sig.emit(asio::cancellation_type::all);
ioc.run();
ASIO_CHECK(count == 2);
}
struct incrementer_token_v1
{
explicit incrementer_token_v1(int* c) : count(c) {}
int* count;
};
struct incrementer_handler_v1
{
explicit incrementer_handler_v1(incrementer_token_v1 t) : count(t.count) {}
void operator()(asio::error_code error)
{
increment_on_cancel(count, error);
}
int* count;
};
namespace asio {
template <>
class async_result<incrementer_token_v1, void(asio::error_code)>
{
public:
typedef incrementer_handler_v1 completion_handler_type;
typedef void return_type;
explicit async_result(completion_handler_type&) {}
return_type get() {}
};
} // namespace asio
void bind_cancellation_slot_to_completion_token_v1_test()
{
io_context ioc;
cancellation_signal sig;
int count = 0;
timer t(ioc, chronons::seconds(5));
t.async_wait(
bind_cancellation_slot(sig.slot(),
incrementer_token_v1(&count)));
ioc.poll();
ASIO_CHECK(count == 0);
sig.emit(asio::cancellation_type::all);
ioc.run();
ASIO_CHECK(count == 1);
}
struct incrementer_token_v2
{
explicit incrementer_token_v2(int* c) : count(c) {}
int* count;
};
namespace asio {
template <>
class async_result<incrementer_token_v2, void(asio::error_code)>
{
public:
#if !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
typedef void return_type;
#endif // !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
template <typename Initiation, typename... Args>
static void initiate(Initiation initiation,
incrementer_token_v2 token, Args&&... args)
{
initiation(
bindns::bind(&increment_on_cancel,
token.count, bindns::placeholders::_1),
static_cast<Args&&>(args)...);
}
};
} // namespace asio
void bind_cancellation_slot_to_completion_token_v2_test()
{
io_context ioc;
cancellation_signal sig;
int count = 0;
timer t(ioc, chronons::seconds(5));
t.async_wait(
bind_cancellation_slot(sig.slot(),
incrementer_token_v2(&count)));
ioc.poll();
ASIO_CHECK(count == 0);
sig.emit(asio::cancellation_type::all);
ioc.run();
ASIO_CHECK(count == 1);
}
void partial_bind_cancellation_slot()
{
io_context ioc;
cancellation_signal sig;
int count = 0;
timer t(ioc, chronons::seconds(5));
t.async_wait(bind_cancellation_slot(sig.slot()))(
bindns::bind(&increment_on_cancel,
&count, bindns::placeholders::_1));
ioc.poll();
ASIO_CHECK(count == 0);
sig.emit(asio::cancellation_type::all);
ioc.run();
ASIO_CHECK(count == 1);
t.async_wait()(
bind_cancellation_slot(sig.slot()))(
incrementer_token_v2(&count));
ioc.restart();
ioc.poll();
ASIO_CHECK(count == 1);
sig.emit(asio::cancellation_type::all);
ioc.run();
ASIO_CHECK(count == 2);
}
ASIO_TEST_SUITE
(
"bind_cancellation_slot",
ASIO_TEST_CASE(bind_cancellation_slot_to_function_object_test)
ASIO_TEST_CASE(bind_cancellation_slot_to_completion_token_v1_test)
ASIO_TEST_CASE(bind_cancellation_slot_to_completion_token_v2_test)
ASIO_TEST_CASE(partial_bind_cancellation_slot)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/thread_pool.cpp | //
// thread_pool.cpp
// ~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/thread_pool.hpp"
#include <functional>
#include "asio/dispatch.hpp"
#include "asio/post.hpp"
#include "unit_test.hpp"
using namespace asio;
namespace bindns = std;
void increment(int* count)
{
++(*count);
}
void decrement_to_zero(thread_pool* pool, int* count)
{
if (*count > 0)
{
--(*count);
int before_value = *count;
asio::post(*pool, bindns::bind(decrement_to_zero, pool, count));
// Handler execution cannot nest, so count value should remain unchanged.
ASIO_CHECK(*count == before_value);
}
}
void nested_decrement_to_zero(thread_pool* pool, int* count)
{
if (*count > 0)
{
--(*count);
asio::dispatch(*pool,
bindns::bind(nested_decrement_to_zero, pool, count));
// Handler execution is nested, so count value should now be zero.
ASIO_CHECK(*count == 0);
}
}
void thread_pool_test()
{
thread_pool pool(1);
int count1 = 0;
asio::post(pool, bindns::bind(increment, &count1));
int count2 = 10;
asio::post(pool, bindns::bind(decrement_to_zero, &pool, &count2));
int count3 = 10;
asio::post(pool, bindns::bind(nested_decrement_to_zero, &pool, &count3));
pool.wait();
ASIO_CHECK(count1 == 1);
ASIO_CHECK(count2 == 0);
ASIO_CHECK(count3 == 0);
}
class test_service : public asio::execution_context::service
{
public:
#if defined(ASIO_NO_TYPEID)
static asio::execution_context::id id;
#endif // defined(ASIO_NO_TYPEID)
typedef test_service key_type;
test_service(asio::execution_context& ctx)
: asio::execution_context::service(ctx)
{
}
private:
virtual void shutdown() {}
};
#if defined(ASIO_NO_TYPEID)
asio::execution_context::id test_service::id;
#endif // defined(ASIO_NO_TYPEID)
void thread_pool_service_test()
{
asio::thread_pool pool1(1);
asio::thread_pool pool2(1);
asio::thread_pool pool3(1);
// Implicit service registration.
asio::use_service<test_service>(pool1);
ASIO_CHECK(asio::has_service<test_service>(pool1));
test_service* svc1 = new test_service(pool1);
try
{
asio::add_service(pool1, svc1);
ASIO_ERROR("add_service did not throw");
}
catch (asio::service_already_exists&)
{
}
delete svc1;
// Explicit service registration.
test_service& svc2 = asio::make_service<test_service>(pool2);
ASIO_CHECK(asio::has_service<test_service>(pool2));
ASIO_CHECK(&asio::use_service<test_service>(pool2) == &svc2);
test_service* svc3 = new test_service(pool2);
try
{
asio::add_service(pool2, svc3);
ASIO_ERROR("add_service did not throw");
}
catch (asio::service_already_exists&)
{
}
delete svc3;
// Explicit registration with invalid owner.
test_service* svc4 = new test_service(pool2);
try
{
asio::add_service(pool3, svc4);
ASIO_ERROR("add_service did not throw");
}
catch (asio::invalid_service_owner&)
{
}
delete svc4;
ASIO_CHECK(!asio::has_service<test_service>(pool3));
}
void thread_pool_executor_query_test()
{
thread_pool pool(1);
ASIO_CHECK(
&asio::query(pool.executor(),
asio::execution::context)
== &pool);
ASIO_CHECK(
asio::query(pool.executor(),
asio::execution::blocking)
== asio::execution::blocking.possibly);
ASIO_CHECK(
asio::query(pool.executor(),
asio::execution::blocking.possibly)
== asio::execution::blocking.possibly);
ASIO_CHECK(
asio::query(pool.executor(),
asio::execution::outstanding_work)
== asio::execution::outstanding_work.untracked);
ASIO_CHECK(
asio::query(pool.executor(),
asio::execution::outstanding_work.untracked)
== asio::execution::outstanding_work.untracked);
ASIO_CHECK(
asio::query(pool.executor(),
asio::execution::relationship)
== asio::execution::relationship.fork);
ASIO_CHECK(
asio::query(pool.executor(),
asio::execution::relationship.fork)
== asio::execution::relationship.fork);
ASIO_CHECK(
asio::query(pool.executor(),
asio::execution::mapping)
== asio::execution::mapping.thread);
ASIO_CHECK(
asio::query(pool.executor(),
asio::execution::allocator)
== std::allocator<void>());
ASIO_CHECK(
asio::query(pool.executor(),
asio::execution::occupancy)
== 1);
}
void thread_pool_executor_execute_test()
{
int count = 0;
thread_pool pool(1);
pool.executor().execute(bindns::bind(increment, &count));
asio::require(pool.executor(),
asio::execution::blocking.possibly
).execute(bindns::bind(increment, &count));
asio::require(pool.executor(),
asio::execution::blocking.always
).execute(bindns::bind(increment, &count));
asio::require(pool.executor(),
asio::execution::blocking.never
).execute(bindns::bind(increment, &count));
asio::require(pool.executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.tracked
).execute(bindns::bind(increment, &count));
asio::require(pool.executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked
).execute(bindns::bind(increment, &count));
asio::require(pool.executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.fork
).execute(bindns::bind(increment, &count));
asio::require(pool.executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation
).execute(bindns::bind(increment, &count));
asio::prefer(
asio::require(pool.executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation),
asio::execution::allocator(std::allocator<void>())
).execute(bindns::bind(increment, &count));
asio::prefer(
asio::require(pool.executor(),
asio::execution::blocking.never,
asio::execution::outstanding_work.untracked,
asio::execution::relationship.continuation),
asio::execution::allocator
).execute(bindns::bind(increment, &count));
pool.wait();
ASIO_CHECK(count == 10);
}
ASIO_TEST_SUITE
(
"thread_pool",
ASIO_TEST_CASE(thread_pool_test)
ASIO_TEST_CASE(thread_pool_service_test)
ASIO_TEST_CASE(thread_pool_executor_query_test)
ASIO_TEST_CASE(thread_pool_executor_execute_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/buffered_stream.cpp | //
// buffered_stream.cpp
// ~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/buffered_stream.hpp"
#include <cstring>
#include <functional>
#include "archetypes/async_result.hpp"
#include "asio/buffer.hpp"
#include "asio/io_context.hpp"
#include "asio/ip/tcp.hpp"
#include "asio/system_error.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_BOOST_ARRAY)
# include <boost/array.hpp>
#else // defined(ASIO_HAS_BOOST_ARRAY)
# include <array>
#endif // defined(ASIO_HAS_BOOST_ARRAY)
typedef asio::buffered_stream<
asio::ip::tcp::socket> stream_type;
void write_some_handler(const asio::error_code&, std::size_t)
{
}
void flush_handler(const asio::error_code&, std::size_t)
{
}
void fill_handler(const asio::error_code&, std::size_t)
{
}
void read_some_handler(const asio::error_code&, std::size_t)
{
}
void test_compile()
{
#if defined(ASIO_HAS_BOOST_ARRAY)
using boost::array;
#else // defined(ASIO_HAS_BOOST_ARRAY)
using std::array;
#endif // defined(ASIO_HAS_BOOST_ARRAY)
using namespace asio;
try
{
io_context ioc;
char mutable_char_buffer[128] = "";
const char const_char_buffer[128] = "";
array<asio::mutable_buffer, 2> mutable_buffers = {{
asio::buffer(mutable_char_buffer, 10),
asio::buffer(mutable_char_buffer + 10, 10) }};
array<asio::const_buffer, 2> const_buffers = {{
asio::buffer(const_char_buffer, 10),
asio::buffer(const_char_buffer + 10, 10) }};
archetypes::lazy_handler lazy;
asio::error_code ec;
stream_type stream1(ioc);
stream_type stream2(ioc, 1024, 1024);
stream_type::executor_type ex = stream1.get_executor();
(void)ex;
stream_type::lowest_layer_type& lowest_layer = stream1.lowest_layer();
(void)lowest_layer;
stream1.write_some(buffer(mutable_char_buffer));
stream1.write_some(buffer(const_char_buffer));
stream1.write_some(mutable_buffers);
stream1.write_some(const_buffers);
stream1.write_some(null_buffers());
stream1.write_some(buffer(mutable_char_buffer), ec);
stream1.write_some(buffer(const_char_buffer), ec);
stream1.write_some(mutable_buffers, ec);
stream1.write_some(const_buffers, ec);
stream1.write_some(null_buffers(), ec);
stream1.async_write_some(buffer(mutable_char_buffer), &write_some_handler);
stream1.async_write_some(buffer(const_char_buffer), &write_some_handler);
stream1.async_write_some(mutable_buffers, &write_some_handler);
stream1.async_write_some(const_buffers, &write_some_handler);
stream1.async_write_some(null_buffers(), &write_some_handler);
int i1 = stream1.async_write_some(buffer(mutable_char_buffer), lazy);
(void)i1;
int i2 = stream1.async_write_some(buffer(const_char_buffer), lazy);
(void)i2;
int i3 = stream1.async_write_some(mutable_buffers, lazy);
(void)i3;
int i4 = stream1.async_write_some(const_buffers, lazy);
(void)i4;
int i5 = stream1.async_write_some(null_buffers(), lazy);
(void)i5;
stream1.flush();
stream1.flush(ec);
stream1.async_flush(&flush_handler);
int i6 = stream1.async_flush(lazy);
(void)i6;
stream1.fill();
stream1.fill(ec);
stream1.async_fill(&fill_handler);
int i7 = stream1.async_fill(lazy);
(void)i7;
stream1.read_some(buffer(mutable_char_buffer));
stream1.read_some(mutable_buffers);
stream1.read_some(null_buffers());
stream1.read_some(buffer(mutable_char_buffer), ec);
stream1.read_some(mutable_buffers, ec);
stream1.read_some(null_buffers(), ec);
stream1.async_read_some(buffer(mutable_char_buffer), &read_some_handler);
stream1.async_read_some(mutable_buffers, &read_some_handler);
stream1.async_read_some(null_buffers(), &read_some_handler);
int i8 = stream1.async_read_some(buffer(mutable_char_buffer), lazy);
(void)i8;
int i9 = stream1.async_read_some(mutable_buffers, lazy);
(void)i9;
int i10 = stream1.async_read_some(null_buffers(), lazy);
(void)i10;
}
catch (std::exception&)
{
}
}
void test_sync_operations()
{
using namespace std; // For memcmp.
asio::io_context io_context;
asio::ip::tcp::acceptor acceptor(io_context,
asio::ip::tcp::endpoint(asio::ip::tcp::v4(), 0));
asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
server_endpoint.address(asio::ip::address_v4::loopback());
stream_type client_socket(io_context);
client_socket.lowest_layer().connect(server_endpoint);
stream_type server_socket(io_context);
acceptor.accept(server_socket.lowest_layer());
const char write_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const asio::const_buffer write_buf = asio::buffer(write_data);
std::size_t bytes_written = 0;
while (bytes_written < sizeof(write_data))
{
bytes_written += client_socket.write_some(
asio::buffer(write_buf + bytes_written));
client_socket.flush();
}
char read_data[sizeof(write_data)];
const asio::mutable_buffer read_buf = asio::buffer(read_data);
std::size_t bytes_read = 0;
while (bytes_read < sizeof(read_data))
{
bytes_read += server_socket.read_some(
asio::buffer(read_buf + bytes_read));
}
ASIO_CHECK(bytes_written == sizeof(write_data));
ASIO_CHECK(bytes_read == sizeof(read_data));
ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
bytes_written = 0;
while (bytes_written < sizeof(write_data))
{
bytes_written += server_socket.write_some(
asio::buffer(write_buf + bytes_written));
server_socket.flush();
}
bytes_read = 0;
while (bytes_read < sizeof(read_data))
{
bytes_read += client_socket.read_some(
asio::buffer(read_buf + bytes_read));
}
ASIO_CHECK(bytes_written == sizeof(write_data));
ASIO_CHECK(bytes_read == sizeof(read_data));
ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
server_socket.close();
asio::error_code error;
bytes_read = client_socket.read_some(
asio::buffer(read_buf), error);
ASIO_CHECK(bytes_read == 0);
ASIO_CHECK(error == asio::error::eof);
client_socket.close(error);
}
void handle_accept(const asio::error_code& e)
{
ASIO_CHECK(!e);
}
void handle_write(const asio::error_code& e,
std::size_t bytes_transferred,
std::size_t* total_bytes_written)
{
ASIO_CHECK(!e);
if (e)
throw asio::system_error(e); // Terminate test.
*total_bytes_written += bytes_transferred;
}
void handle_flush(const asio::error_code& e)
{
ASIO_CHECK(!e);
}
void handle_read(const asio::error_code& e,
std::size_t bytes_transferred,
std::size_t* total_bytes_read)
{
ASIO_CHECK(!e);
if (e)
throw asio::system_error(e); // Terminate test.
*total_bytes_read += bytes_transferred;
}
void handle_read_eof(const asio::error_code& e,
std::size_t bytes_transferred)
{
ASIO_CHECK(e == asio::error::eof);
ASIO_CHECK(bytes_transferred == 0);
}
void test_async_operations()
{
using namespace std; // For memcmp.
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context io_context;
asio::ip::tcp::acceptor acceptor(io_context,
asio::ip::tcp::endpoint(asio::ip::tcp::v4(), 0));
asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
server_endpoint.address(asio::ip::address_v4::loopback());
stream_type client_socket(io_context);
client_socket.lowest_layer().connect(server_endpoint);
stream_type server_socket(io_context);
acceptor.async_accept(server_socket.lowest_layer(), &handle_accept);
io_context.run();
io_context.restart();
const char write_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const asio::const_buffer write_buf = asio::buffer(write_data);
std::size_t bytes_written = 0;
while (bytes_written < sizeof(write_data))
{
client_socket.async_write_some(
asio::buffer(write_buf + bytes_written),
bindns::bind(handle_write, _1, _2, &bytes_written));
io_context.run();
io_context.restart();
client_socket.async_flush(
bindns::bind(handle_flush, _1));
io_context.run();
io_context.restart();
}
char read_data[sizeof(write_data)];
const asio::mutable_buffer read_buf = asio::buffer(read_data);
std::size_t bytes_read = 0;
while (bytes_read < sizeof(read_data))
{
server_socket.async_read_some(
asio::buffer(read_buf + bytes_read),
bindns::bind(handle_read, _1, _2, &bytes_read));
io_context.run();
io_context.restart();
}
ASIO_CHECK(bytes_written == sizeof(write_data));
ASIO_CHECK(bytes_read == sizeof(read_data));
ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
bytes_written = 0;
while (bytes_written < sizeof(write_data))
{
server_socket.async_write_some(
asio::buffer(write_buf + bytes_written),
bindns::bind(handle_write, _1, _2, &bytes_written));
io_context.run();
io_context.restart();
server_socket.async_flush(
bindns::bind(handle_flush, _1));
io_context.run();
io_context.restart();
}
bytes_read = 0;
while (bytes_read < sizeof(read_data))
{
client_socket.async_read_some(
asio::buffer(read_buf + bytes_read),
bindns::bind(handle_read, _1, _2, &bytes_read));
io_context.run();
io_context.restart();
}
ASIO_CHECK(bytes_written == sizeof(write_data));
ASIO_CHECK(bytes_read == sizeof(read_data));
ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
server_socket.close();
client_socket.async_read_some(asio::buffer(read_buf), handle_read_eof);
}
ASIO_TEST_SUITE
(
"buffered_stream",
ASIO_COMPILE_TEST_CASE(test_compile)
ASIO_TEST_CASE(test_sync_operations)
ASIO_TEST_CASE(test_async_operations)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/write_at.cpp | //
// write_at.cpp
// ~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/write_at.hpp"
#include <array>
#include <cstring>
#include <functional>
#include "archetypes/async_result.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
#include "asio/streambuf.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_BOOST_ARRAY)
#include <boost/array.hpp>
#endif // defined(ASIO_HAS_BOOST_ARRAY)
using namespace std; // For memcmp, memcpy and memset.
class test_random_access_device
{
public:
typedef asio::io_context::executor_type executor_type;
test_random_access_device(asio::io_context& io_context)
: io_context_(io_context),
length_(max_length),
next_write_length_(max_length)
{
memset(data_, 0, max_length);
}
executor_type get_executor() noexcept
{
return io_context_.get_executor();
}
void reset()
{
memset(data_, 0, max_length);
next_write_length_ = max_length;
}
void next_write_length(size_t length)
{
next_write_length_ = length;
}
template <typename Iterator>
bool check_buffers(asio::uint64_t offset,
Iterator begin, Iterator end, size_t length)
{
if (offset + length > max_length)
return false;
Iterator iter = begin;
size_t checked_length = 0;
for (; iter != end && checked_length < length; ++iter)
{
size_t buffer_length = asio::buffer_size(*iter);
if (buffer_length > length - checked_length)
buffer_length = length - checked_length;
if (memcmp(data_ + offset + checked_length,
iter->data(), buffer_length) != 0)
return false;
checked_length += buffer_length;
}
return true;
}
template <typename Const_Buffers>
bool check_buffers(asio::uint64_t offset,
const Const_Buffers& buffers, size_t length)
{
return check_buffers(offset, asio::buffer_sequence_begin(buffers),
asio::buffer_sequence_end(buffers), length);
}
template <typename Const_Buffers>
size_t write_some_at(asio::uint64_t offset,
const Const_Buffers& buffers)
{
return asio::buffer_copy(
asio::buffer(data_, length_) + offset,
buffers, next_write_length_);
}
template <typename Const_Buffers>
size_t write_some_at(asio::uint64_t offset,
const Const_Buffers& buffers, asio::error_code& ec)
{
ec = asio::error_code();
return write_some_at(offset, buffers);
}
template <typename Const_Buffers, typename Handler>
void async_write_some_at(asio::uint64_t offset,
const Const_Buffers& buffers, Handler&& handler)
{
size_t bytes_transferred = write_some_at(offset, buffers);
asio::post(get_executor(),
asio::detail::bind_handler(
static_cast<Handler&&>(handler),
asio::error_code(), bytes_transferred));
}
private:
asio::io_context& io_context_;
enum { max_length = 8192 };
char data_[max_length];
size_t length_;
size_t next_write_length_;
};
static const char write_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static char mutable_write_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
void test_3_arg_const_buffer_write_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
size_t bytes_transferred = asio::write_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
}
void test_3_arg_mutable_buffer_write_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
asio::mutable_buffer buffers
= asio::buffer(mutable_write_data, sizeof(mutable_write_data));
s.reset();
size_t bytes_transferred = asio::write_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
}
void test_3_arg_vector_buffers_write_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
std::vector<asio::const_buffer> buffers;
buffers.push_back(asio::buffer(write_data, 32));
buffers.push_back(asio::buffer(write_data) + 32);
s.reset();
size_t bytes_transferred = asio::write_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
}
void test_4_arg_nothrow_const_buffer_write_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
asio::error_code error;
size_t bytes_transferred = asio::write_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
}
void test_4_arg_nothrow_mutable_buffer_write_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
asio::mutable_buffer buffers
= asio::buffer(mutable_write_data, sizeof(mutable_write_data));
s.reset();
asio::error_code error;
size_t bytes_transferred = asio::write_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
}
void test_4_arg_nothrow_vector_buffers_write_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
std::vector<asio::const_buffer> buffers;
buffers.push_back(asio::buffer(write_data, 32));
buffers.push_back(asio::buffer(write_data) + 32);
s.reset();
asio::error_code error;
size_t bytes_transferred = asio::write_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
}
bool old_style_transfer_all(const asio::error_code& ec,
size_t /*bytes_transferred*/)
{
return !!ec;
}
struct short_transfer
{
short_transfer() {}
short_transfer(short_transfer&&) {}
size_t operator()(const asio::error_code& ec,
size_t /*bytes_transferred*/)
{
return !!ec ? 0 : 3;
}
};
void test_4_arg_const_buffer_write_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
size_t bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
}
void test_4_arg_mutable_buffer_write_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
asio::mutable_buffer buffers
= asio::buffer(mutable_write_data, sizeof(mutable_write_data));
s.reset();
size_t bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
}
void test_4_arg_vector_buffers_write_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
std::vector<asio::const_buffer> buffers;
buffers.push_back(asio::buffer(write_data, 32));
buffers.push_back(asio::buffer(write_data) + 32);
s.reset();
size_t bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42));
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1));
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10));
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42));
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
}
void test_5_arg_const_buffer_write_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
asio::error_code error;
size_t bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
}
void test_5_arg_mutable_buffer_write_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
asio::mutable_buffer buffers
= asio::buffer(mutable_write_data, sizeof(mutable_write_data));
s.reset();
asio::error_code error;
size_t bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
ASIO_CHECK(!error);
}
void test_5_arg_vector_buffers_write_at()
{
asio::io_context ioc;
test_random_access_device s(ioc);
std::vector<asio::const_buffer> buffers;
buffers.push_back(asio::buffer(write_data, 32));
buffers.push_back(asio::buffer(write_data) + 32);
s.reset();
asio::error_code error;
size_t bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_all(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(1), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_at_least(42), error);
ASIO_CHECK(bytes_transferred == 50);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(1), error);
ASIO_CHECK(bytes_transferred == 1);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(10), error);
ASIO_CHECK(bytes_transferred == 10);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset();
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
asio::transfer_exactly(42), error);
ASIO_CHECK(bytes_transferred == 42);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
old_style_transfer_all, error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
bytes_transferred = asio::write_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(1);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 0, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
s.reset();
s.next_write_length(10);
error = asio::error_code();
bytes_transferred = asio::write_at(s, 1234, buffers,
short_transfer(), error);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
ASIO_CHECK(!error);
}
void async_write_handler(const asio::error_code& e,
size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
{
*called = true;
ASIO_CHECK(!e);
ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
}
void test_4_arg_const_buffer_async_write_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
bool called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write_at(s, 0, buffers,
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers)(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
}
void test_4_arg_mutable_buffer_async_write_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
asio::mutable_buffer buffers
= asio::buffer(mutable_write_data, sizeof(mutable_write_data));
s.reset();
bool called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
int i = asio::async_write_at(s, 0, buffers,
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers)(
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
}
void test_4_arg_boost_array_buffers_async_write_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
#if defined(ASIO_HAS_BOOST_ARRAY)
asio::io_context ioc;
test_random_access_device s(ioc);
boost::array<asio::const_buffer, 2> buffers = { {
asio::buffer(write_data, 32),
asio::buffer(write_data) + 32 } };
s.reset();
bool called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write_at(s, 0, buffers,
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers)(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
#endif // defined(ASIO_HAS_BOOST_ARRAY)
}
void test_4_arg_std_array_buffers_async_write_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
std::array<asio::const_buffer, 2> buffers = { {
asio::buffer(write_data, 32),
asio::buffer(write_data) + 32 } };
s.reset();
bool called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write_at(s, 0, buffers,
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers)(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
}
void test_4_arg_vector_buffers_async_write_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
std::vector<asio::const_buffer> buffers;
buffers.push_back(asio::buffer(write_data, 32));
buffers.push_back(asio::buffer(write_data) + 32);
s.reset();
bool called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write_at(s, 0, buffers,
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers)(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
}
void test_4_arg_streambuf_async_write_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
asio::streambuf sb;
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
bool called = false;
asio::async_write_at(s, 0, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 1234, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, sb,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
int i = asio::async_write_at(s, 0, sb,
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, sb)(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
}
void test_5_arg_const_buffer_async_write_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
bool called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write_at(s, 0, buffers, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
}
void test_5_arg_mutable_buffer_async_write_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
asio::mutable_buffer buffers
= asio::buffer(mutable_write_data, sizeof(mutable_write_data));
s.reset();
bool called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
s.reset();
int i = asio::async_write_at(s, 0, buffers, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(mutable_write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
}
void test_5_arg_boost_array_buffers_async_write_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
#if defined(ASIO_HAS_BOOST_ARRAY)
asio::io_context ioc;
test_random_access_device s(ioc);
boost::array<asio::const_buffer, 2> buffers = { {
asio::buffer(write_data, 32),
asio::buffer(write_data) + 32 } };
s.reset();
bool called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write_at(s, 0, buffers, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
#endif // defined(ASIO_HAS_BOOST_ARRAY)
}
void test_5_arg_std_array_buffers_async_write_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
std::array<asio::const_buffer, 2> buffers = { {
asio::buffer(write_data, 32),
asio::buffer(write_data) + 32 } };
s.reset();
bool called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write_at(s, 0, buffers, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
}
void test_5_arg_vector_buffers_async_write_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
std::vector<asio::const_buffer> buffers;
buffers.push_back(asio::buffer(write_data, 32));
buffers.push_back(asio::buffer(write_data) + 32);
s.reset();
bool called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
int i = asio::async_write_at(s, 0, buffers, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, buffers, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
}
void test_5_arg_streambuf_async_write_at()
{
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
asio::io_context ioc;
test_random_access_device s(ioc);
asio::streambuf sb;
asio::const_buffer buffers
= asio::buffer(write_data, sizeof(write_data));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
bool called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_all(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_at_least(1),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_at_least(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 50));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_at_least(42),
bindns::bind(async_write_handler,
_1, _2, 50, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 50));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 1));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_exactly(1),
bindns::bind(async_write_handler,
_1, _2, 1, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 1));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_exactly(10),
bindns::bind(async_write_handler,
_1, _2, 10, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 10));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, sb,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, 42));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, sb,
asio::transfer_exactly(42),
bindns::bind(async_write_handler,
_1, _2, 42, &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, 42));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 0, sb, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 1234, sb, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, sb, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, sb, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, sb, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, sb, old_style_transfer_all,
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 0, sb, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
called = false;
asio::async_write_at(s, 1234, sb, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 0, sb, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(1);
called = false;
asio::async_write_at(s, 1234, sb, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 0, sb, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, sb, short_transfer(),
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
int i = asio::async_write_at(s, 0, sb, short_transfer(),
archetypes::lazy_handler());
ASIO_CHECK(i == 42);
ioc.restart();
ioc.run();
ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
s.reset();
sb.consume(sb.size());
sb.sputn(write_data, sizeof(write_data));
s.next_write_length(10);
called = false;
asio::async_write_at(s, 1234, sb, short_transfer())(
bindns::bind(async_write_handler,
_1, _2, sizeof(write_data), &called));
ioc.restart();
ioc.run();
ASIO_CHECK(called);
ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
}
ASIO_TEST_SUITE
(
"write_at",
ASIO_TEST_CASE(test_3_arg_const_buffer_write_at)
ASIO_TEST_CASE(test_3_arg_mutable_buffer_write_at)
ASIO_TEST_CASE(test_3_arg_vector_buffers_write_at)
ASIO_TEST_CASE(test_4_arg_nothrow_const_buffer_write_at)
ASIO_TEST_CASE(test_4_arg_nothrow_mutable_buffer_write_at)
ASIO_TEST_CASE(test_4_arg_nothrow_vector_buffers_write_at)
ASIO_TEST_CASE(test_4_arg_const_buffer_write_at)
ASIO_TEST_CASE(test_4_arg_mutable_buffer_write_at)
ASIO_TEST_CASE(test_4_arg_vector_buffers_write_at)
ASIO_TEST_CASE(test_5_arg_const_buffer_write_at)
ASIO_TEST_CASE(test_5_arg_mutable_buffer_write_at)
ASIO_TEST_CASE(test_5_arg_vector_buffers_write_at)
ASIO_TEST_CASE(test_4_arg_const_buffer_async_write_at)
ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_write_at)
ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_write_at)
ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_write_at)
ASIO_TEST_CASE(test_4_arg_vector_buffers_async_write_at)
ASIO_TEST_CASE(test_4_arg_streambuf_async_write_at)
ASIO_TEST_CASE(test_5_arg_const_buffer_async_write_at)
ASIO_TEST_CASE(test_5_arg_mutable_buffer_async_write_at)
ASIO_TEST_CASE(test_5_arg_boost_array_buffers_async_write_at)
ASIO_TEST_CASE(test_5_arg_std_array_buffers_async_write_at)
ASIO_TEST_CASE(test_5_arg_vector_buffers_async_write_at)
ASIO_TEST_CASE(test_5_arg_streambuf_async_write_at)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/co_composed.cpp | //
// co_composed.cpp
// ~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Prevent link dependency on the Boost.System library.
#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
#define BOOST_SYSTEM_NO_DEPRECATED
#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
// Test that header file is self-contained.
#include "asio/co_composed.hpp"
#include "unit_test.hpp"
#if defined(ASIO_HAS_CO_AWAIT)
#include "asio/bind_cancellation_slot.hpp"
#include "asio/deferred.hpp"
#include "asio/detached.hpp"
#include "asio/io_context.hpp"
#include "asio/post.hpp"
template <typename CompletionToken>
auto async_throw(CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void()>(
[](auto) { throw 42; }, token);
}
template <typename CompletionToken>
auto throw_first(CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void()>(
asio::co_composed(
[](auto state) -> void
{
throw 42;
co_yield state.complete();
}), token);
}
void test_throw_first()
{
try
{
throw_first(asio::detached);
ASIO_CHECK(0);
}
catch (int)
{
}
}
template <typename CompletionToken>
auto throw_after_await(asio::io_context& ctx, CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void()>(
asio::co_composed(
[](auto state, asio::io_context& ctx) -> void
{
co_await asio::post(ctx, asio::deferred);
throw 42;
co_yield state.complete();
}), token, std::ref(ctx));
}
void test_throw_after_await()
{
try
{
asio::io_context ctx(1);
throw_after_await(ctx, asio::detached);
ctx.run();
ASIO_CHECK(0);
}
catch (int)
{
}
}
template <typename CompletionToken>
auto throw_in_first_suspend(CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void()>(
asio::co_composed(
[](auto state) -> void
{
co_await async_throw(asio::deferred);
co_yield state.complete();
}), token);
}
void test_throw_in_first_suspend()
{
try
{
throw_in_first_suspend(asio::detached);
ASIO_CHECK(0);
}
catch (int)
{
}
}
template <typename CompletionToken>
auto throw_in_suspend_after_await(
asio::io_context& ctx, CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void()>(
asio::co_composed(
[](auto state, asio::io_context& ctx) -> void
{
co_await asio::post(ctx, asio::deferred);
co_await async_throw(asio::deferred);
co_yield state.complete();
}), token, std::ref(ctx));
}
void test_throw_in_suspend_after_await()
{
try
{
asio::io_context ctx(1);
throw_in_suspend_after_await(ctx, asio::detached);
ctx.run();
ASIO_CHECK(0);
}
catch (int)
{
}
}
template <typename CompletionToken>
auto post_loop(asio::io_context& ctx, CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void(int)>(
asio::co_composed(
[](auto state, asio::io_context& ctx) -> void
{
int i = 0;
for (; i < 100; ++i)
co_await asio::post(ctx, asio::deferred);
co_yield state.complete(i);
}, ctx), token, std::ref(ctx));
}
void test_post_loop()
{
asio::io_context ctx(1);
int count = 0;
post_loop(ctx, [&](int i){ count = i; });
ctx.run();
ASIO_CHECK(count == 100);
}
template <typename CompletionToken>
auto nested_post(asio::io_context& ctx, CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void()>(
asio::co_composed(
[](auto state, asio::io_context& ctx) -> void
{
co_await asio::post(ctx, asio::deferred);
co_yield state.complete();
}, ctx), token, std::ref(ctx));
}
template <typename CompletionToken>
auto nested_post_loop(asio::io_context& ctx, CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void(int)>(
asio::co_composed(
[](auto state, asio::io_context& ctx) -> void
{
int i = 0;
for (; i < 100; ++i)
co_await nested_post(ctx, asio::deferred);
co_yield state.complete(i);
}, ctx), token, std::ref(ctx));
}
void test_nested_post_loop()
{
asio::io_context ctx(1);
int count = 0;
nested_post_loop(ctx, [&](int i){ count = i; });
ctx.run();
ASIO_CHECK(count == 100);
}
template <typename CompletionToken>
auto post_loop_return_1_0(asio::io_context& ctx, CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void()>(
asio::co_composed<void()>(
[](auto, asio::io_context& ctx) -> void
{
int i = 0;
for (; i < 100; ++i)
co_await asio::post(ctx, asio::deferred);
co_return {};
}, ctx), token, std::ref(ctx));
}
void test_post_loop_return_1_0()
{
asio::io_context ctx(1);
bool done = false;
post_loop_return_1_0(ctx, [&]{ done = true; });
ctx.run();
ASIO_CHECK(done);
}
template <typename CompletionToken>
auto post_loop_return_1_1(asio::io_context& ctx, CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void(int)>(
asio::co_composed<void(int)>(
[](auto, asio::io_context& ctx) -> void
{
int i = 0;
for (; i < 100; ++i)
co_await asio::post(ctx, asio::deferred);
co_return {i};
}, ctx), token, std::ref(ctx));
}
void test_post_loop_return_1_1()
{
asio::io_context ctx(1);
int count = 0;
post_loop_return_1_1(ctx, [&](int i){ count = i; });
ctx.run();
ASIO_CHECK(count == 100);
}
template <typename CompletionToken>
auto post_loop_return_1_2(asio::io_context& ctx, CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void(int, char)>(
asio::co_composed<void(int, char)>(
[](auto, asio::io_context& ctx) -> void
{
int i = 0;
for (; i < 100; ++i)
co_await asio::post(ctx, asio::deferred);
co_return {i, 'A'};
}, ctx), token, std::ref(ctx));
}
void test_post_loop_return_1_2()
{
asio::io_context ctx(1);
int count = 0;
char ch = 0;
post_loop_return_1_2(ctx, [&](int i, char c){ count = i, ch = c; });
ctx.run();
ASIO_CHECK(count == 100);
ASIO_CHECK(ch == 'A');
}
template <typename CompletionToken>
auto post_loop_return_2(asio::io_context& ctx, CompletionToken&& token)
{
return asio::async_initiate<CompletionToken, void(), void(int)>(
asio::co_composed<void(), void(int)>(
[](auto, asio::io_context& ctx) -> void
{
int i = 0;
for (; i < 100; ++i)
co_await asio::post(ctx, asio::deferred);
co_return {i};
}, ctx), token, std::ref(ctx));
}
void test_post_loop_return_2()
{
asio::io_context ctx(1);
int count = 0;
post_loop_return_2(ctx, [&](int i = 0){ count = i; });
ctx.run();
ASIO_CHECK(count == 100);
}
template <typename CompletionToken>
auto complete_on_cancel(asio::io_context& ctx, CompletionToken&& token)
{
return asio::async_initiate<
CompletionToken, void(asio::error_code, int)>(
asio::co_composed<
void(asio::error_code, int)>(
[](auto state, asio::io_context& ctx) -> void
{
state.on_cancellation_complete_with(
asio::error::invalid_argument, 42);
int i = 0;
for (; i < 100; ++i)
co_await asio::post(ctx, asio::deferred);
co_return {asio::error::eof, i};
}, ctx), token, std::ref(ctx));
}
void test_complete_on_cancel()
{
asio::io_context ctx(1);
int count = 0;
asio::error_code ec;
asio::cancellation_signal cancel;
complete_on_cancel(ctx,
[&](asio::error_code e, int i)
{
ec = e;
count = i;
});
ctx.run();
ASIO_CHECK(ec == asio::error::eof);
ASIO_CHECK(count == 100);
complete_on_cancel(ctx,
asio::bind_cancellation_slot(cancel.slot(),
[&](asio::error_code e, int i)
{
ec = e;
count = i;
}));
ctx.restart();
ctx.run_one();
cancel.emit(asio::cancellation_type::all);
ctx.run();
ASIO_CHECK(ec == asio::error::invalid_argument);
ASIO_CHECK(count == 42);
complete_on_cancel(ctx,
asio::bind_cancellation_slot(cancel.slot(),
[&](asio::error_code e, int i)
{
ec = e;
count = i;
}));
ctx.restart();
ctx.run();
ASIO_CHECK(ec == asio::error::eof);
ASIO_CHECK(count == 100);
}
template <typename CompletionToken>
auto complete_with_default_on_cancel(
asio::io_context& ctx, CompletionToken&& token)
{
return asio::async_initiate<
CompletionToken, void(asio::error_code, int)>(
asio::co_composed<
void(asio::error_code, int)>(
[](auto, asio::io_context& ctx) -> void
{
int i = 0;
for (; i < 100; ++i)
co_await asio::post(ctx, asio::deferred);
co_return {asio::error::eof, i};
}, ctx), token, std::ref(ctx));
}
void test_complete_with_default_on_cancel()
{
asio::io_context ctx(1);
int count = 0;
asio::error_code ec;
asio::cancellation_signal cancel;
complete_with_default_on_cancel(ctx,
[&](asio::error_code e, int i)
{
ec = e;
count = i;
});
ctx.run();
ASIO_CHECK(ec == asio::error::eof);
ASIO_CHECK(count == 100);
complete_with_default_on_cancel(ctx,
asio::bind_cancellation_slot(cancel.slot(),
[&](asio::error_code e, int i)
{
ec = e;
count = i;
}));
ctx.restart();
ctx.run_one();
cancel.emit(asio::cancellation_type::all);
ctx.run();
ASIO_CHECK(ec == asio::error::operation_aborted);
ASIO_CHECK(count == 0);
complete_with_default_on_cancel(ctx,
asio::bind_cancellation_slot(cancel.slot(),
[&](asio::error_code e, int i)
{
ec = e;
count = i;
}));
ctx.restart();
ctx.run();
ASIO_CHECK(ec == asio::error::eof);
ASIO_CHECK(count == 100);
}
template <typename CompletionToken>
auto throw_on_cancel(asio::io_context& ctx, CompletionToken&& token)
{
return asio::async_initiate<
CompletionToken, void(asio::error_code, int)>(
asio::co_composed<
void(asio::error_code, int)>(
[](auto state, asio::io_context& ctx) -> void
{
try
{
state.throw_if_cancelled(true);
int i = 0;
for (; i < 100; ++i)
co_await asio::post(ctx, asio::deferred);
co_return {asio::error::eof, i};
}
catch (...)
{
co_return {asio::error::invalid_argument, 42};
}
}, ctx), token, std::ref(ctx));
}
void test_throw_on_cancel()
{
asio::io_context ctx(1);
int count = 0;
asio::error_code ec;
asio::cancellation_signal cancel;
throw_on_cancel(ctx,
[&](asio::error_code e, int i)
{
ec = e;
count = i;
});
ctx.run();
ASIO_CHECK(ec == asio::error::eof);
ASIO_CHECK(count == 100);
throw_on_cancel(ctx,
asio::bind_cancellation_slot(cancel.slot(),
[&](asio::error_code e, int i)
{
ec = e;
count = i;
}));
ctx.restart();
ctx.run_one();
cancel.emit(asio::cancellation_type::all);
ctx.run();
ASIO_CHECK(ec == asio::error::invalid_argument);
ASIO_CHECK(count == 42);
throw_on_cancel(ctx,
asio::bind_cancellation_slot(cancel.slot(),
[&](asio::error_code e, int i)
{
ec = e;
count = i;
}));
ctx.restart();
ctx.run();
ASIO_CHECK(ec == asio::error::eof);
ASIO_CHECK(count == 100);
}
void test_no_signatures_detached()
{
asio::io_context ctx(1);
int count1 = 0;
int count2 = 0;
asio::async_initiate(
asio::co_composed(
[](auto, asio::io_context& ctx, int& count1, int& count2) -> void
{
for (;;)
{
++count1;
co_await asio::post(ctx, asio::deferred);
++count2;
}
}), asio::detached, std::ref(ctx), std::ref(count1), std::ref(count2));
ASIO_ASSERT(count1 == 1);
ASIO_ASSERT(count2 == 0);
ctx.run_one();
ASIO_ASSERT(count1 == 2);
ASIO_ASSERT(count2 == 1);
ctx.restart();
ctx.run_one();
ASIO_ASSERT(count1 == 3);
ASIO_ASSERT(count2 == 2);
}
ASIO_TEST_SUITE
(
"co_composed",
ASIO_TEST_CASE(test_throw_first)
ASIO_TEST_CASE(test_throw_after_await)
ASIO_TEST_CASE(test_throw_in_first_suspend)
ASIO_TEST_CASE(test_throw_in_suspend_after_await)
ASIO_TEST_CASE(test_post_loop)
ASIO_TEST_CASE(test_nested_post_loop)
ASIO_TEST_CASE(test_post_loop_return_1_0)
ASIO_TEST_CASE(test_post_loop_return_1_1)
ASIO_TEST_CASE(test_post_loop_return_1_2)
ASIO_TEST_CASE(test_post_loop_return_2)
ASIO_TEST_CASE(test_complete_on_cancel)
ASIO_TEST_CASE(test_complete_with_default_on_cancel)
ASIO_TEST_CASE(test_throw_on_cancel)
ASIO_TEST_CASE(test_no_signatures_detached)
)
#else // defined(ASIO_HAS_CO_AWAIT)
ASIO_TEST_SUITE
(
"co_composed",
ASIO_TEST_CASE(null_test)
)
#endif // defined(ASIO_HAS_CO_AWAIT)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/unit_test.hpp | //
// unit_test.hpp
// ~~~~~~~~~~~~~
//
// 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)
//
#ifndef UNIT_TEST_HPP
#define UNIT_TEST_HPP
#include "asio/detail/config.hpp"
#include <iostream>
#include "asio/detail/atomic_count.hpp"
#if defined(__sun)
# include <stdlib.h> // Needed for lrand48.
#endif // defined(__sun)
#if defined(__BORLANDC__) && !defined(__clang__)
// Prevent use of intrinsic for strcmp.
# include <cstring>
# undef strcmp
// Suppress error about condition always being true.
# pragma option -w-ccc
#endif // defined(__BORLANDC__) && !defined(__clang__)
#if defined(ASIO_MSVC)
# pragma warning (disable:4127)
# pragma warning (push)
# pragma warning (disable:4244)
# pragma warning (disable:4702)
#endif // defined(ASIO_MSVC)
#if !defined(ASIO_TEST_IOSTREAM)
# define ASIO_TEST_IOSTREAM std::cerr
#endif // !defined(ASIO_TEST_IOSTREAM)
namespace asio {
namespace detail {
inline const char*& test_name()
{
static const char* name = 0;
return name;
}
inline atomic_count& test_errors()
{
static atomic_count errors(0);
return errors;
}
inline void begin_test_suite(const char* name)
{
asio::detail::test_name();
asio::detail::test_errors();
ASIO_TEST_IOSTREAM << name << " test suite begins" << std::endl;
}
inline int end_test_suite(const char* name)
{
ASIO_TEST_IOSTREAM << name << " test suite ends" << std::endl;
ASIO_TEST_IOSTREAM << "\n*** ";
long errors = asio::detail::test_errors();
if (errors == 0)
ASIO_TEST_IOSTREAM << "No errors detected.";
else if (errors == 1)
ASIO_TEST_IOSTREAM << "1 error detected.";
else
ASIO_TEST_IOSTREAM << errors << " errors detected." << std::endl;
ASIO_TEST_IOSTREAM << std::endl;
return errors == 0 ? 0 : 1;
}
template <void (*Test)()>
inline void run_test(const char* name)
{
test_name() = name;
long errors_before = asio::detail::test_errors();
Test();
if (test_errors() == errors_before)
ASIO_TEST_IOSTREAM << name << " passed" << std::endl;
else
ASIO_TEST_IOSTREAM << name << " failed" << std::endl;
}
template <void (*)()>
inline void compile_test(const char* name)
{
ASIO_TEST_IOSTREAM << name << " passed" << std::endl;
}
#if defined(ASIO_NO_EXCEPTIONS)
template <typename T>
void throw_exception(const T& t)
{
ASIO_TEST_IOSTREAM << "Exception: " << t.what() << std::endl;
std::abort();
}
#endif // defined(ASIO_NO_EXCEPTIONS)
} // namespace detail
} // namespace asio
#define ASIO_CHECK(expr) \
do { if (!(expr)) { \
ASIO_TEST_IOSTREAM << __FILE__ << "(" << __LINE__ << "): " \
<< asio::detail::test_name() << ": " \
<< "check '" << #expr << "' failed" << std::endl; \
++asio::detail::test_errors(); \
} } while (0)
#define ASIO_CHECK_MESSAGE(expr, msg) \
do { if (!(expr)) { \
ASIO_TEST_IOSTREAM << __FILE__ << "(" << __LINE__ << "): " \
<< asio::detail::test_name() << ": " \
<< msg << std::endl; \
++asio::detail::test_errors(); \
} } while (0)
#define ASIO_WARN_MESSAGE(expr, msg) \
do { if (!(expr)) { \
ASIO_TEST_IOSTREAM << __FILE__ << "(" << __LINE__ << "): " \
<< asio::detail::test_name() << ": " \
<< msg << std::endl; \
} } while (0)
#define ASIO_ERROR(msg) \
do { \
ASIO_TEST_IOSTREAM << __FILE__ << "(" << __LINE__ << "): " \
<< asio::detail::test_name() << ": " \
<< msg << std::endl; \
++asio::detail::test_errors(); \
} while (0)
#define ASIO_TEST_SUITE(name, tests) \
int main() \
{ \
asio::detail::begin_test_suite(name); \
tests \
return asio::detail::end_test_suite(name); \
}
#define ASIO_TEST_CASE(test) \
asio::detail::run_test<&test>(#test);
#define ASIO_TEST_CASE2(test1, test2) \
asio::detail::run_test<&test1, test2>(#test1 "," #test2);
#define ASIO_TEST_CASE3(test1, test2, test3) \
asio::detail::run_test<&test1, test2, test3>( \
#test1 "," #test2 "," #test3);
#define ASIO_TEST_CASE4(test1, test2, test3, test4) \
asio::detail::run_test<&test1, test2, test3, test4>( \
#test1 "," #test2 "," #test3 "," #test4);
#define ASIO_TEST_CASE5(test1, test2, test3, test4, test5) \
asio::detail::run_test<&test1, test2, test3, test4, test5>( \
#test1 "," #test2 "," #test3 "," #test4 "," #test5);
#define ASIO_COMPILE_TEST_CASE(test) \
asio::detail::compile_test<&test>(#test);
inline void null_test()
{
}
#if defined(__GNUC__) && defined(_AIX)
// AIX needs this symbol defined in asio, even if it doesn't do anything.
int test_main(int, char**)
{
}
#endif // defined(__GNUC__) && defined(_AIX)
#if defined(ASIO_MSVC)
# pragma warning (pop)
#endif // defined(ASIO_MSVC)
#endif // UNIT_TEST_HPP
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_waitable_timer.cpp | //
// basic_waitable_timer.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/basic_waitable_timer.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_waitable_timer",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/uses_executor.cpp | //
// uses_executor.cpp
// ~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/uses_executor.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"uses_executor",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_raw_socket.cpp | //
// basic_raw_socket.cpp
// ~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/basic_raw_socket.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_raw_socket",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/associated_cancellation_slot.cpp | //
// associated_cancellation_slot.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/associated_cancellation_slot.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"associated_cancellation_slot",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/connect_pipe.cpp | //
// connect_pipe.cpp
// ~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/connect_pipe.hpp"
#include <functional>
#include <string>
#include "asio/io_context.hpp"
#include "asio/read.hpp"
#include "asio/readable_pipe.hpp"
#include "asio/writable_pipe.hpp"
#include "asio/write.hpp"
#include "unit_test.hpp"
//------------------------------------------------------------------------------
// connect_pipe_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that all connect_pipe functions compile and link
// correctly. Runtime failures are ignored.
namespace connect_pipe_compile {
void test()
{
#if defined(ASIO_HAS_PIPE)
using namespace asio;
try
{
asio::io_context io_context;
asio::error_code ec1;
readable_pipe p1(io_context);
writable_pipe p2(io_context);
connect_pipe(p1, p2);
readable_pipe p3(io_context);
writable_pipe p4(io_context);
connect_pipe(p3, p4, ec1);
}
catch (std::exception&)
{
}
#endif // defined(ASIO_HAS_PIPE)
}
} // namespace connect_pipe_compile
//------------------------------------------------------------------------------
// connect_pipe_runtime test
// ~~~~~~~~~~~~~~~~~~~~~~~~~
// The following test checks that connect_pipe operates correctly at runtime.
namespace connect_pipe_runtime {
static const char write_data[]
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
void handle_read(const asio::error_code& err,
size_t bytes_transferred, bool* called)
{
*called = true;
ASIO_CHECK(!err);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
}
void handle_write(const asio::error_code& err,
size_t bytes_transferred, bool* called)
{
*called = true;
ASIO_CHECK(!err);
ASIO_CHECK(bytes_transferred == sizeof(write_data));
}
void test()
{
#if defined(ASIO_HAS_PIPE)
using namespace std; // For memcmp.
using namespace asio;
namespace bindns = std;
using bindns::placeholders::_1;
using bindns::placeholders::_2;
try
{
asio::io_context io_context;
asio::error_code ec1;
asio::error_code ec2;
readable_pipe p1(io_context);
writable_pipe p2(io_context);
connect_pipe(p1, p2);
std::string data1 = write_data;
asio::write(p2, asio::buffer(data1));
std::string data2;
data2.resize(data1.size());
asio::read(p1, asio::buffer(data2));
ASIO_CHECK(data1 == data2);
char read_buffer[sizeof(write_data)];
bool read_completed = false;
asio::async_read(p1,
asio::buffer(read_buffer),
bindns::bind(handle_read,
_1, _2, &read_completed));
bool write_completed = false;
asio::async_write(p2,
asio::buffer(write_data),
bindns::bind(handle_write,
_1, _2, &write_completed));
io_context.run();
ASIO_CHECK(read_completed);
ASIO_CHECK(write_completed);
ASIO_CHECK(memcmp(read_buffer, write_data, sizeof(write_data)) == 0);
}
catch (std::exception&)
{
ASIO_CHECK(false);
}
#endif // defined(ASIO_HAS_PIPE)
}
} // namespace connect_pipe_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"connect_pipe",
ASIO_COMPILE_TEST_CASE(connect_pipe_compile::test)
ASIO_TEST_CASE(connect_pipe_runtime::test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/executor.cpp | //
// executor.cpp
// ~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/executor.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"executor",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/serial_port_base.cpp | //
// serial_port_base.cpp
// ~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
// Copyright (c) 2008 Rep Invariant Systems, Inc. ([email protected])
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/serial_port_base.hpp"
#include "asio/io_context.hpp"
#include "asio/serial_port.hpp"
#include "unit_test.hpp"
//------------------------------------------------------------------------------
// serial_port_base_compile test
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Verify that all options and and their accessors compile. Runtime failures are
// ignored.
namespace serial_port_base_compile {
void test()
{
#if defined(ASIO_HAS_SERIAL_PORT)
using namespace asio;
try
{
io_context ioc;
serial_port port(ioc);
// baud_rate class.
serial_port_base::baud_rate baud_rate1(9600);
port.set_option(baud_rate1);
serial_port_base::baud_rate baud_rate2;
port.get_option(baud_rate2);
(void)static_cast<unsigned int>(baud_rate2.value());
// flow_control class.
serial_port_base::flow_control flow_control1(
serial_port_base::flow_control::none);
port.set_option(flow_control1);
serial_port_base::flow_control flow_control2;
port.get_option(flow_control2);
(void)static_cast<serial_port_base::flow_control::type>(
flow_control2.value());
// parity class.
serial_port_base::parity parity1(serial_port_base::parity::none);
port.set_option(parity1);
serial_port_base::parity parity2;
port.get_option(parity2);
(void)static_cast<serial_port_base::parity::type>(parity2.value());
// stop_bits class.
serial_port_base::stop_bits stop_bits1(serial_port_base::stop_bits::one);
port.set_option(stop_bits1);
serial_port_base::stop_bits stop_bits2;
port.get_option(stop_bits2);
(void)static_cast<serial_port_base::stop_bits::type>(stop_bits2.value());
// character_size class.
serial_port_base::character_size character_size1(8);
port.set_option(character_size1);
serial_port_base::character_size character_size2;
port.get_option(character_size2);
(void)static_cast<unsigned int>(character_size2.value());
}
catch (std::exception&)
{
}
#endif // defined(ASIO_HAS_SERIAL_PORT)
}
} // namespace serial_port_base_compile
//------------------------------------------------------------------------------
ASIO_TEST_SUITE
(
"serial_port_base",
ASIO_COMPILE_TEST_CASE(serial_port_base_compile::test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/error.cpp | //
// error.cpp
// ~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/error.hpp"
#include <sstream>
#include "unit_test.hpp"
void test_error_code(const asio::error_code& code)
{
asio::error_code error(code);
ASIO_CHECK(code == error);
ASIO_CHECK(!code || error);
ASIO_CHECK(!code || !!error);
asio::error_code error2(error);
ASIO_CHECK(error == error2);
ASIO_CHECK(!(error != error2));
asio::error_code error3;
error3 = error;
ASIO_CHECK(error == error3);
ASIO_CHECK(!(error != error3));
std::ostringstream os;
os << error;
ASIO_CHECK(!os.str().empty());
}
void error_test()
{
test_error_code(asio::error::access_denied);
test_error_code(asio::error::address_family_not_supported);
test_error_code(asio::error::address_in_use);
test_error_code(asio::error::already_connected);
test_error_code(asio::error::already_started);
test_error_code(asio::error::connection_aborted);
test_error_code(asio::error::connection_refused);
test_error_code(asio::error::connection_reset);
test_error_code(asio::error::bad_descriptor);
test_error_code(asio::error::eof);
test_error_code(asio::error::fault);
test_error_code(asio::error::host_not_found);
test_error_code(asio::error::host_not_found_try_again);
test_error_code(asio::error::host_unreachable);
test_error_code(asio::error::in_progress);
test_error_code(asio::error::interrupted);
test_error_code(asio::error::invalid_argument);
test_error_code(asio::error::message_size);
test_error_code(asio::error::network_down);
test_error_code(asio::error::network_reset);
test_error_code(asio::error::network_unreachable);
test_error_code(asio::error::no_descriptors);
test_error_code(asio::error::no_buffer_space);
test_error_code(asio::error::no_data);
test_error_code(asio::error::no_memory);
test_error_code(asio::error::no_permission);
test_error_code(asio::error::no_protocol_option);
test_error_code(asio::error::no_recovery);
test_error_code(asio::error::not_connected);
test_error_code(asio::error::not_socket);
test_error_code(asio::error::operation_aborted);
test_error_code(asio::error::operation_not_supported);
test_error_code(asio::error::service_not_found);
test_error_code(asio::error::shut_down);
test_error_code(asio::error::timed_out);
test_error_code(asio::error::try_again);
test_error_code(asio::error::would_block);
}
ASIO_TEST_SUITE
(
"error",
ASIO_TEST_CASE(error_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/basic_writable_pipe.cpp | //
// basic_writable_pipe.cpp
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/basic_writable_pipe.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"basic_writable_pipe",
ASIO_TEST_CASE(null_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/streambuf.cpp | //
// streambuf.cpp
// ~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/streambuf.hpp"
#include "asio/buffer.hpp"
#include "unit_test.hpp"
void streambuf_test()
{
asio::streambuf sb;
sb.sputn("abcd", 4);
ASIO_CHECK(sb.size() == 4);
for (int i = 0; i < 100; ++i)
{
sb.consume(3);
ASIO_CHECK(sb.size() == 1);
char buf[1];
sb.sgetn(buf, 1);
ASIO_CHECK(sb.size() == 0);
sb.sputn("ab", 2);
ASIO_CHECK(sb.size() == 2);
asio::buffer_copy(sb.prepare(10), asio::buffer("cd", 2));
sb.commit(2);
ASIO_CHECK(sb.size() == 4);
}
ASIO_CHECK(sb.size() == 4);
sb.consume(4);
ASIO_CHECK(sb.size() == 0);
}
ASIO_TEST_SUITE
(
"streambuf",
ASIO_TEST_CASE(streambuf_test)
)
|
0 | repos/asio/asio/src/tests | repos/asio/asio/src/tests/unit/placeholders.cpp | //
// placeholders.cpp
// ~~~~~~~~~~~~~~~~
//
// 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)
//
// Disable autolinking for unit tests.
#if !defined(BOOST_ALL_NO_LIB)
#define BOOST_ALL_NO_LIB 1
#endif // !defined(BOOST_ALL_NO_LIB)
// Test that header file is self-contained.
#include "asio/placeholders.hpp"
#include "unit_test.hpp"
ASIO_TEST_SUITE
(
"placeholders",
ASIO_TEST_CASE(null_test)
)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.