Adding upstream version 14.2.21.upstream/14.2.21upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

9 files changed, 666 insertions, 0 deletions

diff --git a/src/boost/libs/asio/test/windows/basic_object_handle.cpp b/src/boost/libs/asio/test/windows/basic_object_handle.cpp
new file mode 100644
index 00000000..68e6ae7a
--- /dev/null
+++ b/src/boost/libs/asio/test/windows/basic_object_handle.cpp
@@ -0,0 +1,25 @@
+//
+// basic_object_handle.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2019 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 <boost/asio/windows/basic_object_handle.hpp>
+
+#include "../unit_test.hpp"
+
+BOOST_ASIO_TEST_SUITE
+(
+  "basic_object_handle",
+  BOOST_ASIO_TEST_CASE(null_test)
+)
diff --git a/src/boost/libs/asio/test/windows/basic_overlapped_handle.cpp b/src/boost/libs/asio/test/windows/basic_overlapped_handle.cpp
new file mode 100644
index 00000000..464fc8bd
--- /dev/null
+++ b/src/boost/libs/asio/test/windows/basic_overlapped_handle.cpp
@@ -0,0 +1,25 @@
+//
+// basic_overlapped_handle.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2019 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 <boost/asio/windows/basic_overlapped_handle.hpp>
+
+#include "../unit_test.hpp"
+
+BOOST_ASIO_TEST_SUITE
+(
+  "basic_overlapped_handle",
+  BOOST_ASIO_TEST_CASE(null_test)
+)
diff --git a/src/boost/libs/asio/test/windows/basic_random_access_handle.cpp b/src/boost/libs/asio/test/windows/basic_random_access_handle.cpp
new file mode 100644
index 00000000..0a4df9a2
--- /dev/null
+++ b/src/boost/libs/asio/test/windows/basic_random_access_handle.cpp
@@ -0,0 +1,25 @@
+//
+// basic_random_access_handle.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2019 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 <boost/asio/windows/basic_random_access_handle.hpp>
+
+#include "../unit_test.hpp"
+
+BOOST_ASIO_TEST_SUITE
+(
+  "basic_random_access_handle",
+  BOOST_ASIO_TEST_CASE(null_test)
+)
diff --git a/src/boost/libs/asio/test/windows/basic_stream_handle.cpp b/src/boost/libs/asio/test/windows/basic_stream_handle.cpp
new file mode 100644
index 00000000..8f845727
--- /dev/null
+++ b/src/boost/libs/asio/test/windows/basic_stream_handle.cpp
@@ -0,0 +1,25 @@
+//
+// basic_stream_handle.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2019 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 <boost/asio/windows/basic_stream_handle.hpp>
+
+#include "../unit_test.hpp"
+
+BOOST_ASIO_TEST_SUITE
+(
+  "basic_stream_handle",
+  BOOST_ASIO_TEST_CASE(null_test)
+)
diff --git a/src/boost/libs/asio/test/windows/object_handle.cpp b/src/boost/libs/asio/test/windows/object_handle.cpp
new file mode 100644
index 00000000..ec8c237e
--- /dev/null
+++ b/src/boost/libs/asio/test/windows/object_handle.cpp
@@ -0,0 +1,130 @@
+//
+// object_handle.cpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2019 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 <boost/asio/windows/object_handle.hpp>
+
+#include <boost/asio/io_context.hpp>
+#include "../archetypes/async_result.hpp"
+#include "../unit_test.hpp"
+
+//------------------------------------------------------------------------------
+
+// windows_object_handle_compile test
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// The following test checks that all public member functions on the class
+// windows::object_handle compile and link correctly. Runtime failures are
+// ignored.
+
+namespace windows_object_handle_compile {
+
+void wait_handler(const boost::system::error_code&)
+{
+}
+
+void test()
+{
+#if defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE)
+  using namespace boost::asio;
+  namespace win = boost::asio::windows;
+
+  try
+  {
+    io_context ioc;
+    const io_context::executor_type ioc_ex = ioc.get_executor();
+    archetypes::lazy_handler lazy;
+    boost::system::error_code ec;
+
+    // basic_object_handle constructors.
+
+    win::object_handle handle1(ioc);
+    HANDLE native_handle1 = INVALID_HANDLE_VALUE;
+#if defined(BOOST_ASIO_MSVC) && (_MSC_VER < 1910)
+    // Skip this on older MSVC due to mysterious ambiguous overload errors.
+#else
+    win::object_handle handle2(ioc, native_handle1);
+#endif
+
+    win::object_handle handle3(ioc_ex);
+    HANDLE native_handle2 = INVALID_HANDLE_VALUE;
+    win::object_handle handle4(ioc_ex, native_handle2);
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    win::object_handle handle5(std::move(handle4));
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    // basic_object_handle operators.
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    handle1 = win::object_handle(ioc);
+    handle1 = std::move(handle3);
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    // basic_io_object functions.
+
+    win::object_handle::executor_type ex = handle1.get_executor();
+    (void)ex;
+
+    // basic_handle functions.
+
+    win::object_handle::lowest_layer_type& lowest_layer
+      = handle1.lowest_layer();
+    (void)lowest_layer;
+
+    const win::object_handle& handle6 = handle1;
+    const win::object_handle::lowest_layer_type& lowest_layer3
+      = handle6.lowest_layer();
+    (void)lowest_layer3;
+
+    HANDLE native_handle4 = INVALID_HANDLE_VALUE;
+    handle1.assign(native_handle4);
+
+    bool is_open = handle1.is_open();
+    (void)is_open;
+
+    handle1.close();
+    handle1.close(ec);
+
+    win::object_handle::native_handle_type native_handle3
+      = handle1.native_handle();
+    (void)native_handle3;
+
+    handle1.cancel();
+    handle1.cancel(ec);
+
+    // basic_object_handle functions.
+
+    handle1.wait();
+    handle1.wait(ec);
+
+    handle1.async_wait(&wait_handler);
+    int i1 = handle1.async_wait(lazy);
+    (void)i1;
+  }
+  catch (std::exception&)
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE)
+}
+
+} // namespace windows_object_handle_compile
+
+//------------------------------------------------------------------------------
+
+BOOST_ASIO_TEST_SUITE
+(
+  "windows/object_handle",
+  BOOST_ASIO_TEST_CASE(windows_object_handle_compile::test)
+)
diff --git a/src/boost/libs/asio/test/windows/overlapped_handle.cpp b/src/boost/libs/asio/test/windows/overlapped_handle.cpp
new file mode 100644
index 00000000..261aa7df
--- /dev/null
+++ b/src/boost/libs/asio/test/windows/overlapped_handle.cpp
@@ -0,0 +1,26 @@
+//
+// overlapped_handle.cpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2019 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 <boost/asio/windows/overlapped_handle.hpp>
+
+#include <boost/asio.hpp>
+#include "../unit_test.hpp"
+
+BOOST_ASIO_TEST_SUITE
+(
+  "windows/overlapped_handle",
+  BOOST_ASIO_TEST_CASE(null_test)
+)
diff --git a/src/boost/libs/asio/test/windows/overlapped_ptr.cpp b/src/boost/libs/asio/test/windows/overlapped_ptr.cpp
new file mode 100644
index 00000000..5d03447b
--- /dev/null
+++ b/src/boost/libs/asio/test/windows/overlapped_ptr.cpp
@@ -0,0 +1,107 @@
+//
+// overlapped_ptr.cpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2019 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 <boost/asio/windows/overlapped_ptr.hpp>
+
+#include <boost/asio/executor.hpp>
+#include <boost/asio/io_context.hpp>
+#include "../unit_test.hpp"
+
+//------------------------------------------------------------------------------
+
+// windows_overlapped_ptr_compile test
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// The following test checks that all public member functions on the class
+// windows::overlapped_ptr compile and link correctly. Runtime failures are
+// ignored.
+
+namespace windows_overlapped_ptr_compile {
+
+void overlapped_handler_1(const boost::system::error_code&, std::size_t)
+{
+}
+
+struct overlapped_handler_2
+{
+  void operator()(const boost::system::error_code&, std::size_t)
+  {
+  }
+};
+
+void test()
+{
+#if defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
+  using namespace boost::asio;
+  namespace win = boost::asio::windows;
+
+  try
+  {
+    io_context ioc;
+    boost::asio::executor ex(ioc.get_executor());
+
+    // basic_overlapped_ptr constructors.
+
+    win::overlapped_ptr ptr1;
+
+    win::overlapped_ptr ptr2(ioc, &overlapped_handler_1);
+    win::overlapped_ptr ptr3(ioc, overlapped_handler_2());
+
+    win::overlapped_ptr ptr4(ioc.get_executor(), &overlapped_handler_1);
+    win::overlapped_ptr ptr5(ioc.get_executor(), overlapped_handler_2());
+    win::overlapped_ptr ptr6(ex, &overlapped_handler_1);
+    win::overlapped_ptr ptr7(ex, overlapped_handler_2());
+
+    // overlapped_ptr functions.
+
+    ptr1.reset();
+
+    ptr2.reset(ioc, &overlapped_handler_1);
+    ptr3.reset(ioc, overlapped_handler_2());
+
+    ptr2.reset(ioc.get_executor(), &overlapped_handler_1);
+    ptr3.reset(ioc.get_executor(), overlapped_handler_2());
+    ptr2.reset(ex, &overlapped_handler_1);
+    ptr3.reset(ex, overlapped_handler_2());
+
+    OVERLAPPED* ov1 = ptr1.get();
+    (void)ov1;
+
+    const win::overlapped_ptr& ptr8(ptr1);
+    const OVERLAPPED* ov2 = ptr4.get();
+    (void)ov2;
+
+    OVERLAPPED* ov3 = ptr1.release();
+    (void)ov3;
+
+    boost::system::error_code ec;
+    std::size_t bytes_transferred = 0;
+    ptr1.complete(ec, bytes_transferred);
+  }
+  catch (std::exception&)
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
+}
+
+} // namespace windows_overlapped_ptr_compile
+
+//------------------------------------------------------------------------------
+
+BOOST_ASIO_TEST_SUITE
+(
+  "windows/overlapped_ptr",
+  BOOST_ASIO_TEST_CASE(windows_overlapped_ptr_compile::test)
+)
diff --git a/src/boost/libs/asio/test/windows/random_access_handle.cpp b/src/boost/libs/asio/test/windows/random_access_handle.cpp
new file mode 100644
index 00000000..4b39345e
--- /dev/null
+++ b/src/boost/libs/asio/test/windows/random_access_handle.cpp
@@ -0,0 +1,155 @@
+//
+// random_access_handle.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2019 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 <boost/asio/windows/random_access_handle.hpp>
+
+#include <boost/asio/io_context.hpp>
+#include "../archetypes/async_result.hpp"
+#include "../unit_test.hpp"
+
+//------------------------------------------------------------------------------
+
+// windows_random_access_handle_compile test
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// The following test checks that all public member functions on the class
+// windows::random_access_handle compile and link correctly. Runtime failures
+// are ignored.
+
+namespace windows_random_access_handle_compile {
+
+void write_some_handler(const boost::system::error_code&, std::size_t)
+{
+}
+
+void read_some_handler(const boost::system::error_code&, std::size_t)
+{
+}
+
+void test()
+{
+#if defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
+  using namespace boost::asio;
+  namespace win = boost::asio::windows;
+
+  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] = "";
+    boost::asio::uint64_t offset = 0;
+    archetypes::lazy_handler lazy;
+    boost::system::error_code ec;
+
+    // basic_random_access_handle constructors.
+
+    win::random_access_handle handle1(ioc);
+    HANDLE native_handle1 = INVALID_HANDLE_VALUE;
+#if defined(BOOST_ASIO_MSVC) && (_MSC_VER < 1910)
+    // Skip this on older MSVC due to mysterious ambiguous overload errors.
+#else
+    win::random_access_handle handle2(ioc, native_handle1);
+#endif
+
+    win::random_access_handle handle3(ioc_ex);
+    HANDLE native_handle2 = INVALID_HANDLE_VALUE;
+    win::random_access_handle handle4(ioc_ex, native_handle2);
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    win::random_access_handle handle5(std::move(handle4));
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    // basic_random_access_handle operators.
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    handle1 = win::random_access_handle(ioc);
+    handle1 = std::move(handle4);
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    // basic_io_object functions.
+
+    windows::random_access_handle::executor_type ex = handle1.get_executor();
+    (void)ex;
+
+    // basic_overlapped_handle functions.
+
+    win::random_access_handle::lowest_layer_type& lowest_layer
+      = handle1.lowest_layer();
+    (void)lowest_layer;
+
+    const win::random_access_handle& handle6 = handle1;
+    const win::random_access_handle::lowest_layer_type& lowest_layer2
+      = handle6.lowest_layer();
+    (void)lowest_layer2;
+
+    HANDLE native_handle3 = INVALID_HANDLE_VALUE;
+    handle1.assign(native_handle3);
+
+    bool is_open = handle1.is_open();
+    (void)is_open;
+
+    handle1.close();
+    handle1.close(ec);
+
+    win::random_access_handle::native_handle_type native_handle4
+      = handle1.native_handle();
+    (void)native_handle4;
+
+    handle1.cancel();
+    handle1.cancel(ec);
+
+    // basic_random_access_handle functions.
+
+    handle1.write_some_at(offset, buffer(mutable_char_buffer));
+    handle1.write_some_at(offset, buffer(const_char_buffer));
+    handle1.write_some_at(offset, buffer(mutable_char_buffer), ec);
+    handle1.write_some_at(offset, buffer(const_char_buffer), ec);
+
+    handle1.async_write_some_at(offset,
+        buffer(mutable_char_buffer), &write_some_handler);
+    handle1.async_write_some_at(offset,
+        buffer(const_char_buffer), &write_some_handler);
+    int i1 = handle1.async_write_some_at(offset,
+        buffer(mutable_char_buffer), lazy);
+    (void)i1;
+    int i2 = handle1.async_write_some_at(offset,
+        buffer(const_char_buffer), lazy);
+    (void)i2;
+
+    handle1.read_some_at(offset, buffer(mutable_char_buffer));
+    handle1.read_some_at(offset, buffer(mutable_char_buffer), ec);
+
+    handle1.async_read_some_at(offset,
+        buffer(mutable_char_buffer), &read_some_handler);
+    int i3 = handle1.async_read_some_at(offset,
+        buffer(mutable_char_buffer), lazy);
+    (void)i3;
+  }
+  catch (std::exception&)
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
+}
+
+} // namespace windows_random_access_handle_compile
+
+//------------------------------------------------------------------------------
+
+BOOST_ASIO_TEST_SUITE
+(
+  "windows/random_access_handle",
+  BOOST_ASIO_TEST_CASE(windows_random_access_handle_compile::test)
+)
diff --git a/src/boost/libs/asio/test/windows/stream_handle.cpp b/src/boost/libs/asio/test/windows/stream_handle.cpp
new file mode 100644
index 00000000..c916adfd
--- /dev/null
+++ b/src/boost/libs/asio/test/windows/stream_handle.cpp
@@ -0,0 +1,148 @@
+//
+// stream_handle.cpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2019 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 <boost/asio/windows/stream_handle.hpp>
+
+#include <boost/asio/io_context.hpp>
+#include "../archetypes/async_result.hpp"
+#include "../unit_test.hpp"
+
+//------------------------------------------------------------------------------
+
+// windows_stream_handle_compile test
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// The following test checks that all public member functions on the class
+// windows::stream_handle compile and link correctly. Runtime failures are
+// ignored.
+
+namespace windows_stream_handle_compile {
+
+void write_some_handler(const boost::system::error_code&, std::size_t)
+{
+}
+
+void read_some_handler(const boost::system::error_code&, std::size_t)
+{
+}
+
+void test()
+{
+#if defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE)
+  using namespace boost::asio;
+  namespace win = boost::asio::windows;
+
+  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;
+    boost::system::error_code ec;
+
+    // basic_stream_handle constructors.
+
+    win::stream_handle handle1(ioc);
+    HANDLE native_handle1 = INVALID_HANDLE_VALUE;
+#if defined(BOOST_ASIO_MSVC) && (_MSC_VER < 1910)
+    // Skip this on older MSVC due to mysterious ambiguous overload errors.
+#else
+    win::stream_handle handle2(ioc, native_handle1);
+#endif
+
+    win::stream_handle handle3(ioc_ex);
+    HANDLE native_handle2 = INVALID_HANDLE_VALUE;
+    win::stream_handle handle4(ioc_ex, native_handle2);
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    win::stream_handle handle5(std::move(handle4));
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    // basic_stream_handle operators.
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+    handle1 = win::stream_handle(ioc);
+    handle1 = std::move(handle4);
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+    // basic_io_object functions.
+
+    windows::stream_handle::executor_type ex = handle1.get_executor();
+    (void)ex;
+
+    // basic_overlapped_handle functions.
+
+    win::stream_handle::lowest_layer_type& lowest_layer
+      = handle1.lowest_layer();
+    (void)lowest_layer;
+
+    const win::stream_handle& handle6 = handle1;
+    const win::stream_handle::lowest_layer_type& lowest_layer2
+      = handle6.lowest_layer();
+    (void)lowest_layer2;
+
+    HANDLE native_handle3 = INVALID_HANDLE_VALUE;
+    handle1.assign(native_handle3);
+
+    bool is_open = handle1.is_open();
+    (void)is_open;
+
+    handle1.close();
+    handle1.close(ec);
+
+    win::stream_handle::native_handle_type native_handle4
+      = handle1.native_handle();
+    (void)native_handle4;
+
+    handle1.cancel();
+    handle1.cancel(ec);
+
+    // basic_stream_handle functions.
+
+    handle1.write_some(buffer(mutable_char_buffer));
+    handle1.write_some(buffer(const_char_buffer));
+    handle1.write_some(buffer(mutable_char_buffer), ec);
+    handle1.write_some(buffer(const_char_buffer), ec);
+
+    handle1.async_write_some(buffer(mutable_char_buffer), &write_some_handler);
+    handle1.async_write_some(buffer(const_char_buffer), &write_some_handler);
+    int i1 = handle1.async_write_some(buffer(mutable_char_buffer), lazy);
+    (void)i1;
+    int i2 = handle1.async_write_some(buffer(const_char_buffer), lazy);
+    (void)i2;
+
+    handle1.read_some(buffer(mutable_char_buffer));
+    handle1.read_some(buffer(mutable_char_buffer), ec);
+
+    handle1.async_read_some(buffer(mutable_char_buffer), &read_some_handler);
+    int i3 = handle1.async_read_some(buffer(mutable_char_buffer), lazy);
+    (void)i3;
+  }
+  catch (std::exception&)
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE)
+}
+
+} // namespace windows_stream_handle_compile
+
+//------------------------------------------------------------------------------
+
+BOOST_ASIO_TEST_SUITE
+(
+  "windows/stream_handle",
+  BOOST_ASIO_TEST_CASE(windows_stream_handle_compile::test)
+)