diff libstdc++-v3/testsuite/experimental/net/socket/basic_socket.cc @ 19:2b5abeee2509 default tip

update gcc11
author anatofuz
date Mon, 25 May 2020 07:50:57 +0900
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libstdc++-v3/testsuite/experimental/net/socket/basic_socket.cc	Mon May 25 07:50:57 2020 +0900
@@ -0,0 +1,129 @@
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-do compile { target c++14 } }
+
+#include <experimental/socket>
+
+namespace net = std::experimental::net;
+using namespace std;
+
+namespace test
+{
+}
+
+void
+test01(net::io_context& io)
+{
+  struct proto
+  {
+    struct endpoint
+    {
+      using protocol_type = proto;
+      protocol_type protocol() const { return {}; }
+
+      void* data() { return nullptr; }
+      const void* data() const { return nullptr; }
+      std::size_t size() const { return 0; }
+      void resize(std::size_t) { }
+      std::size_t capacity() const { return 0; }
+    };
+
+    int family() const { return 0; }
+    int type() const { return 0; }
+    int protocol() const { return 0; }
+  };
+
+  static_assert( ! is_default_constructible<net::basic_socket<proto>>::value,
+		 "no default ctor" );
+  static_assert( ! is_copy_constructible<net::basic_socket<proto>>::value,
+		 "copy ctor is deleted" );
+  static_assert( ! is_move_constructible<net::basic_socket<proto>>::value,
+		 "move ctor is protected" );
+  static_assert( ! is_move_assignable<net::basic_socket<proto>>::value,
+		 "move assignment op is protected" );
+
+  struct socket : net::basic_socket<proto>
+  {
+    explicit
+    socket(net::io_context& io)
+    : basic_socket(io) { }
+
+    socket(net::io_context& io, const proto& p)
+    : basic_socket(io, p) { }
+
+    socket(net::io_context& io, const proto::endpoint& e)
+    : basic_socket(io, e) { }
+
+    socket(net::io_context& io, const proto& p, int n)
+    : basic_socket(io, p, n) { }
+  };
+
+  static_assert( ! is_copy_constructible<socket>::value, "deleted" );
+  static_assert( is_move_constructible<socket>::value, "" );
+  static_assert( is_move_assignable<socket>::value, "" );
+
+  error_code ec;
+  proto p;
+  proto::endpoint e;
+
+  socket s(io);
+  s = socket(io, p);
+  s = socket(io, e);
+  s = socket(io, p, s.release());
+
+  static_assert( is_same<decltype(s.get_executor()),
+			 net::io_context::executor_type>::value, "" );
+  static_assert( noexcept(s.get_executor()), "" );
+  static_assert( is_same<decltype(s.native_handle()),
+			 socket::native_handle_type>::value, "" );
+  static_assert( noexcept(s.native_handle()), "GNU extension" );
+
+  s.open();
+  s.open(p);
+  s.open(p, ec);
+
+  s.assign(p, s.release());
+  s.assign(p, s.release(ec), ec);
+
+  static_assert( is_same<decltype(const_cast<const socket&>(s).is_open()),
+			 bool>::value, "" );
+  static_assert( noexcept(const_cast<const socket&>(s).is_open()), "" );
+
+  s.close();
+  s.close(ec);
+
+  s.cancel();
+  s.cancel(ec);
+
+  s.bind(e);
+  s.bind(e, ec);
+
+  s.shutdown(net::socket_base::shutdown_both);
+  s.shutdown(net::socket_base::shutdown_both, ec);
+
+  e = s.local_endpoint();
+  e = s.local_endpoint(ec);
+  e = s.remote_endpoint();
+  e = s.remote_endpoint(ec);
+
+  s.connect(e);
+  s.connect(e, ec);
+
+  s.wait(net::socket_base::wait_read);
+  s.wait(net::socket_base::wait_read, ec);
+}