diff options
Diffstat (limited to '3rdparty/asio/src/tests/unit/random_access_file.cpp')
-rw-r--r-- | 3rdparty/asio/src/tests/unit/random_access_file.cpp | 171 |
1 files changed, 171 insertions, 0 deletions
diff --git a/3rdparty/asio/src/tests/unit/random_access_file.cpp b/3rdparty/asio/src/tests/unit/random_access_file.cpp new file mode 100644 index 00000000000..be703cd395e --- /dev/null +++ b/3rdparty/asio/src/tests/unit/random_access_file.cpp @@ -0,0 +1,171 @@ +// +// random_access_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/random_access_file.hpp" + +#include "archetypes/async_result.hpp" +#include "asio/io_context.hpp" +#include "unit_test.hpp" + +// random_access_file_compile test +// ~~~~~~~~~~~~~~~~~~~~~~~~ +// The following test checks that all public member functions on the class +// random_access_file compile and link correctly. Runtime failures are ignored. + +namespace random_access_file_compile { + +struct write_some_at_handler +{ + write_some_at_handler() {} + void operator()(const asio::error_code&, std::size_t) {} + write_some_at_handler(write_some_at_handler&&) {} +private: + write_some_at_handler(const write_some_at_handler&); +}; + +struct read_some_at_handler +{ + read_some_at_handler() {} + void operator()(const asio::error_code&, std::size_t) {} + read_some_at_handler(read_some_at_handler&&) {} +private: + read_some_at_handler(const read_some_at_handler&); +}; + +void test() +{ +#if defined(ASIO_HAS_FILE) + 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; + const std::string path; + + // basic_random_access_file constructors. + + random_access_file file1(ioc); + random_access_file file2(ioc, "", random_access_file::read_only); + random_access_file file3(ioc, path, random_access_file::read_only); + random_access_file::native_handle_type native_file1 = file1.native_handle(); + random_access_file file4(ioc, native_file1); + + random_access_file file5(ioc_ex); + random_access_file file6(ioc_ex, "", random_access_file::read_only); + random_access_file file7(ioc_ex, path, random_access_file::read_only); + random_access_file::native_handle_type native_file2 = file1.native_handle(); + random_access_file file8(ioc_ex, native_file2); + + random_access_file file9(std::move(file8)); + + basic_random_access_file<io_context::executor_type> file10(ioc); + random_access_file file11(std::move(file10)); + + // basic_random_access_file operators. + + file1 = random_access_file(ioc); + file1 = std::move(file2); + file1 = std::move(file10); + + // basic_io_object functions. + + random_access_file::executor_type ex = file1.get_executor(); + (void)ex; + + // basic_random_access_file functions. + + file1.open("", random_access_file::read_only); + file1.open("", random_access_file::read_only, ec); + + file1.open(path, random_access_file::read_only); + file1.open(path, random_access_file::read_only, ec); + + random_access_file::native_handle_type native_file3 = file1.native_handle(); + file1.assign(native_file3); + random_access_file::native_handle_type native_file4 = file1.native_handle(); + file1.assign(native_file4, ec); + + bool is_open = file1.is_open(); + (void)is_open; + + file1.close(); + file1.close(ec); + + random_access_file::native_handle_type native_file5 = file1.native_handle(); + (void)native_file5; + + random_access_file::native_handle_type native_file6 = file1.release(); + (void)native_file6; + random_access_file::native_handle_type native_file7 = file1.release(ec); + (void)native_file7; + + file1.cancel(); + file1.cancel(ec); + + asio::uint64_t s1 = file1.size(); + (void)s1; + asio::uint64_t s2 = file1.size(ec); + (void)s2; + + file1.resize(asio::uint64_t(0)); + file1.resize(asio::uint64_t(0), ec); + + file1.sync_all(); + file1.sync_all(ec); + + file1.sync_data(); + file1.sync_data(ec); + + file1.write_some_at(0, buffer(mutable_char_buffer)); + file1.write_some_at(0, buffer(const_char_buffer)); + file1.write_some_at(0, buffer(mutable_char_buffer), ec); + file1.write_some_at(0, buffer(const_char_buffer), ec); + + file1.async_write_some_at(0, buffer(mutable_char_buffer), + write_some_at_handler()); + file1.async_write_some_at(0, buffer(const_char_buffer), + write_some_at_handler()); + int i1 = file1.async_write_some_at(0, buffer(mutable_char_buffer), lazy); + (void)i1; + int i2 = file1.async_write_some_at(0, buffer(const_char_buffer), lazy); + (void)i2; + + file1.read_some_at(0, buffer(mutable_char_buffer)); + file1.read_some_at(0, buffer(mutable_char_buffer), ec); + + file1.async_read_some_at(0, buffer(mutable_char_buffer), + read_some_at_handler()); + int i3 = file1.async_read_some_at(0, buffer(mutable_char_buffer), lazy); + (void)i3; + } + catch (std::exception&) + { + } +#endif // defined(ASIO_HAS_FILE) +} + +} // namespace random_access_file_compile + +ASIO_TEST_SUITE +( + "random_access_file", + ASIO_COMPILE_TEST_CASE(random_access_file_compile::test) +) |