summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asio/src/tests/unit/ssl/stream.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asio/src/tests/unit/ssl/stream.cpp')
-rw-r--r--3rdparty/asio/src/tests/unit/ssl/stream.cpp199
1 files changed, 199 insertions, 0 deletions
diff --git a/3rdparty/asio/src/tests/unit/ssl/stream.cpp b/3rdparty/asio/src/tests/unit/ssl/stream.cpp
new file mode 100644
index 00000000000..542949eb60c
--- /dev/null
+++ b/3rdparty/asio/src/tests/unit/ssl/stream.cpp
@@ -0,0 +1,199 @@
+//
+// stream.cpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2003-2016 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/ssl/stream.hpp"
+
+#include "asio.hpp"
+#include "asio/ssl.hpp"
+#include "../archetypes/async_result.hpp"
+#include "../unit_test.hpp"
+
+//------------------------------------------------------------------------------
+
+// ssl_stream_compile test
+// ~~~~~~~~~~~~~~~~~~~~~~~
+// The following test checks that all public member functions on the class
+// ssl::stream::socket compile and link correctly. Runtime failures are ignored.
+
+namespace ssl_stream_compile {
+
+bool verify_callback(bool, asio::ssl::verify_context&)
+{
+ return false;
+}
+
+void handshake_handler(const asio::error_code&)
+{
+}
+
+void buffered_handshake_handler(const asio::error_code&, std::size_t)
+{
+}
+
+void shutdown_handler(const asio::error_code&)
+{
+}
+
+void write_some_handler(const asio::error_code&, std::size_t)
+{
+}
+
+void read_some_handler(const asio::error_code&, std::size_t)
+{
+}
+
+void test()
+{
+ using namespace asio;
+ namespace ip = asio::ip;
+
+ try
+ {
+ io_context ioc;
+ char mutable_char_buffer[128] = "";
+ const char const_char_buffer[128] = "";
+ asio::ssl::context context(asio::ssl::context::sslv23);
+ archetypes::lazy_handler lazy;
+ asio::error_code ec;
+
+ // ssl::stream constructors.
+
+ ssl::stream<ip::tcp::socket> stream1(ioc, context);
+ ip::tcp::socket socket1(ioc, ip::tcp::v4());
+ ssl::stream<ip::tcp::socket&> stream2(socket1, context);
+
+ // basic_io_object functions.
+
+ ssl::stream<ip::tcp::socket>::executor_type ex = stream1.get_executor();
+ (void)ex;
+
+#if !defined(ASIO_NO_DEPRECATED)
+ io_context& ioc_ref = stream1.get_io_context();
+ (void)ioc_ref;
+
+ io_context& ioc_ref2 = stream1.get_io_service();
+ (void)ioc_ref2;
+#endif // !defined(ASIO_NO_DEPRECATED)
+
+ // ssl::stream functions.
+
+ SSL* ssl1 = stream1.native_handle();
+ (void)ssl1;
+
+ ssl::stream<ip::tcp::socket>::lowest_layer_type& lowest_layer
+ = stream1.lowest_layer();
+ (void)lowest_layer;
+
+ const ssl::stream<ip::tcp::socket>& stream3 = stream1;
+ const ssl::stream<ip::tcp::socket>::lowest_layer_type& lowest_layer2
+ = stream3.lowest_layer();
+ (void)lowest_layer2;
+
+ stream1.set_verify_mode(ssl::verify_none);
+ stream1.set_verify_mode(ssl::verify_none, ec);
+
+ stream1.set_verify_depth(1);
+ stream1.set_verify_depth(1, ec);
+
+ stream1.set_verify_callback(verify_callback);
+ stream1.set_verify_callback(verify_callback, ec);
+
+ stream1.handshake(ssl::stream_base::client);
+ stream1.handshake(ssl::stream_base::server);
+ stream1.handshake(ssl::stream_base::client, ec);
+ stream1.handshake(ssl::stream_base::server, ec);
+
+ stream1.handshake(ssl::stream_base::client, buffer(mutable_char_buffer));
+ stream1.handshake(ssl::stream_base::server, buffer(mutable_char_buffer));
+ stream1.handshake(ssl::stream_base::client, buffer(const_char_buffer));
+ stream1.handshake(ssl::stream_base::server, buffer(const_char_buffer));
+ stream1.handshake(ssl::stream_base::client,
+ buffer(mutable_char_buffer), ec);
+ stream1.handshake(ssl::stream_base::server,
+ buffer(mutable_char_buffer), ec);
+ stream1.handshake(ssl::stream_base::client,
+ buffer(const_char_buffer), ec);
+ stream1.handshake(ssl::stream_base::server,
+ buffer(const_char_buffer), ec);
+
+ stream1.async_handshake(ssl::stream_base::client, handshake_handler);
+ stream1.async_handshake(ssl::stream_base::server, handshake_handler);
+ int i1 = stream1.async_handshake(ssl::stream_base::client, lazy);
+ (void)i1;
+ int i2 = stream1.async_handshake(ssl::stream_base::server, lazy);
+ (void)i2;
+
+ stream1.async_handshake(ssl::stream_base::client,
+ buffer(mutable_char_buffer), buffered_handshake_handler);
+ stream1.async_handshake(ssl::stream_base::server,
+ buffer(mutable_char_buffer), buffered_handshake_handler);
+ stream1.async_handshake(ssl::stream_base::client,
+ buffer(const_char_buffer), buffered_handshake_handler);
+ stream1.async_handshake(ssl::stream_base::server,
+ buffer(const_char_buffer), buffered_handshake_handler);
+ int i3 = stream1.async_handshake(ssl::stream_base::client,
+ buffer(mutable_char_buffer), lazy);
+ (void)i3;
+ int i4 = stream1.async_handshake(ssl::stream_base::server,
+ buffer(mutable_char_buffer), lazy);
+ (void)i4;
+ int i5 = stream1.async_handshake(ssl::stream_base::client,
+ buffer(const_char_buffer), lazy);
+ (void)i5;
+ int i6 = stream1.async_handshake(ssl::stream_base::server,
+ buffer(const_char_buffer), lazy);
+ (void)i6;
+
+ stream1.shutdown();
+ stream1.shutdown(ec);
+
+ stream1.async_shutdown(shutdown_handler);
+ int i7 = stream1.async_shutdown(lazy);
+ (void)i7;
+
+ stream1.write_some(buffer(mutable_char_buffer));
+ stream1.write_some(buffer(const_char_buffer));
+ stream1.write_some(buffer(mutable_char_buffer), ec);
+ stream1.write_some(buffer(const_char_buffer), ec);
+
+ stream1.async_write_some(buffer(mutable_char_buffer), write_some_handler);
+ stream1.async_write_some(buffer(const_char_buffer), write_some_handler);
+ int i8 = stream1.async_write_some(buffer(mutable_char_buffer), lazy);
+ (void)i8;
+ int i9 = stream1.async_write_some(buffer(const_char_buffer), lazy);
+ (void)i9;
+
+ stream1.read_some(buffer(mutable_char_buffer));
+ stream1.read_some(buffer(mutable_char_buffer), ec);
+
+ stream1.async_read_some(buffer(mutable_char_buffer), read_some_handler);
+ int i10 = stream1.async_read_some(buffer(mutable_char_buffer), lazy);
+ (void)i10;
+ }
+ catch (std::exception&)
+ {
+ }
+}
+
+} // namespace ssl_stream_compile
+
+//------------------------------------------------------------------------------
+
+ASIO_TEST_SUITE
+(
+ "ssl/stream",
+ ASIO_TEST_CASE(ssl_stream_compile::test)
+)