1 files changed, 82 insertions, 0 deletions
diff --git a/src/seastar/tests/unit/socket_test.cc b/src/seastar/tests/unit/socket_test.cc
new file mode 100644
index 000000000..b4640bbfc
--- /dev/null
+++ b/src/seastar/tests/unit/socket_test.cc
@@ -0,0 +1,82 @@
+/*
+ * This file is open source software, licensed to you under the terms
+ * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
+ * distributed with this work for additional information regarding copyright
+ * ownership.  You may not use this file except in compliance with the License.
+ *
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/*
+ * Copyright (C) 2019 Elazar Leibovich
+ */
+
+#include <seastar/core/reactor.hh>
+#include <seastar/core/seastar.hh>
+#include <seastar/core/app-template.hh>
+#include <seastar/core/print.hh>
+#include <seastar/core/memory.hh>
+#include <seastar/util/std-compat.hh>
+
+#include <seastar/net/posix-stack.hh>
+
+using namespace seastar;
+
+future<> handle_connection(connected_socket s) {
+    auto in = s.input();
+    auto out = s.output();
+    return do_with(std::move(in), std::move(out), [](auto& in, auto& out) {
+        return do_until([&in]() { return in.eof(); },
+            [&in, &out] {
+                return in.read().then([&out](auto buf) {
+                    return out.write(std::move(buf)).then([&out]() { return out.close(); });
+                });
+            });
+    });
+}
+
+future<> echo_server_loop() {
+    return do_with(
+        server_socket(listen(make_ipv4_address({1234}), listen_options{.reuse_address = true})), [](auto& listener) {
+              // Connect asynchronously in background.
+              (void)connect(make_ipv4_address({"127.0.0.1", 1234})).then([](connected_socket&& socket) {
+                  socket.shutdown_output();
+              });
+              return listener.accept().then(
+                  [](accept_result ar) {
+                      connected_socket s = std::move(ar.connection);
+                      return handle_connection(std::move(s));
+                  }).then([l = std::move(listener)]() mutable { return l.abort_accept(); });
+        });
+}
+
+class my_malloc_allocator : public std::pmr::memory_resource {
+public:
+    int allocs;
+    int frees;
+    void* do_allocate(std::size_t bytes, std::size_t alignment) override { allocs++; return malloc(bytes); }
+    void do_deallocate(void *ptr, std::size_t bytes, std::size_t alignment) override { frees++; return free(ptr); }
+    virtual bool do_is_equal(const std::pmr::memory_resource& __other) const noexcept override { abort(); }
+};
+
+my_malloc_allocator malloc_allocator;
+std::pmr::polymorphic_allocator<char> allocator{&malloc_allocator};
+
+int main(int ac, char** av) {
+    register_network_stack("posix", boost::program_options::options_description(),
+        [](boost::program_options::variables_map ops) {
+            return smp::main_thread() ? net::posix_network_stack::create(ops, &allocator)
+                : net::posix_ap_network_stack::create(ops);
+        }, true);
+    return app_template().run_deprecated(ac, av, [] {
+       return echo_server_loop().finally([](){ engine().exit((malloc_allocator.allocs == malloc_allocator.frees) ? 0 : 1); });
+    });
+}