Add unit tests for the basic tcp server functionality

Unit tests: put helpers in common/ folder, clean up CMake config

Author: tstenner

testing/CMakeLists.txt

@@ -9,18 +9,31 @@ enable_testing()
 option(LSL_BENCHMARKS "Enable benchmarks in unit tests" OFF)
 
 add_library(catch_main OBJECT catch_main.cpp)
-target_compile_features(catch_main PUBLIC cxx_std_11)
+target_compile_features(catch_main PUBLIC cxx_std_14)
 if(CMAKE_SYSTEM_NAME STREQUAL "Android")
 	target_link_libraries(catch_main PUBLIC log)
 endif()
+find_package(Threads REQUIRED)
+target_link_libraries(catch_main PUBLIC Threads::Threads)
 
 target_compile_definitions(catch_main PRIVATE LSL_VERSION_INFO="${LSL_VERSION_INFO}")
+target_include_directories(catch_main PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../thirdparty)
 if(LSL_BENCHMARKS)
 	target_compile_definitions(catch_main PUBLIC CATCH_CONFIG_ENABLE_BENCHMARKING)
 endif()
-target_include_directories(catch_main PUBLIC
+
+add_library(common OBJECT
+	common/bytecmp.cpp
+	common/bytecmp.hpp
+	common/create_streampair.hpp
+	common/lsltypes.hpp
+)
+target_compile_features(common PUBLIC cxx_std_14)
+target_include_directories(common PUBLIC
 	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../thirdparty>
-	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../src>)
+	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../src>
+)
+
 
 add_executable(lsl_test_exported
 	test_ext_DataType.cpp
@@ -29,10 +42,8 @@ add_executable(lsl_test_exported
 	test_ext_streaminfo.cpp
 	test_ext_time.cpp
 )
+target_link_libraries(lsl_test_exported PRIVATE lsl common catch_main)
 
-target_link_libraries(lsl_test_exported PRIVATE lsl catch_main Threads::Threads)
-
-find_package(Threads REQUIRED)
 
 add_executable(lsl_test_internal
 	test_int_inireader.cpp
@@ -43,28 +54,23 @@ add_executable(lsl_test_internal
 	test_int_samples.cpp
 	internal/postproc.cpp
 	internal/serialization_v100.cpp
+	internal/tcpserver.cpp
 )
-target_link_libraries(lsl_test_internal PRIVATE lslobj lslboost catch_main)
+target_link_libraries(lsl_test_internal PRIVATE lslobj lslboost common catch_main)
 
 if(LSL_BENCHMARKS)
 	# to get somewhat reproducible performance numbers:
-	# /usr/bin/time -v testing/lsl_bench_exported --benchmark-samples 100 bounce
-	# [unix only]     |   binary                  |    nr. of samples   | test name
-	add_executable(lsl_bench_exported
+	# /usr/bin/time -v testing/lsl_test_exported --benchmark-samples 100  bounce
+	# [unix only]     |   binary                |    nr. of samples      | test name
+	target_sources(lsl_test_exported PRIVATE
 		bench_ext_bounce.cpp
 		bench_ext_common.cpp
 		bench_ext_pushpull.cpp
 	)
-	target_link_libraries(lsl_bench_exported PRIVATE lsl catch_main Threads::Threads)
-	installLSLApp(lsl_bench_exported)
-
-	add_executable(lsl_bench_internal
+	target_sources(lsl_test_internal PRIVATE
 		bench_int_sleep.cpp
 		bench_int_timesync.cpp
 	)
-	target_link_libraries(lsl_bench_internal PRIVATE lslobj lslboost catch_main)
-	target_include_directories(lsl_test_internal PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../src/)
-	installLSLApp(lsl_bench_internal)
 endif()
 
 set(LSL_TESTS lsl_test_exported lsl_test_internal)

testing/bench_ext_bounce.cpp

@@ -1,4 +1,5 @@
-#include "helpers.h"
+#include "common/create_streampair.hpp"
+#include "common/lsltypes.hpp"
 #include <catch2/catch.hpp>
 #include <lsl_cpp.h>
 

testing/bench_ext_pushpull.cpp

@@ -1,5 +1,5 @@
-#include "helper_type.hpp"
-#include "helpers.h"
+#include "common/create_streampair.hpp"
+#include "common/lsltypes.hpp"
 #include <atomic>
 #include <catch2/catch.hpp>
 #include <list>

testing/bench_int_sleep.cpp

@@ -1,6 +1,6 @@
 #include <catch2/catch.hpp>
+#include <common.h>
 #include <thread>
-#include "../src/common.h"
 
 TEST_CASE("sleep") {
 	BENCHMARK("sleep1ms") { std::this_thread::sleep_for(std::chrono::milliseconds(1)); };

testing/common/bytecmp.cpp

@@ -0,0 +1,52 @@
+#include "bytecmp.hpp"
+#include <algorithm>
+#include <catch2/catch.hpp>
+#include <cctype>
+#include <iomanip>
+#include <map>
+#include <sstream>
+
+std::string bytes_to_hexstr(const std::string &str) {
+	const std::map<char, char> shortcuts{{0x07, 'a'}, {0x08, 'b'}, {0x09, 't'}, {0x0a, 'n'},
+		{0x0b, 'v'}, {0x0c, 'f'}, {0x0d, 'r'}, {0x5c, '\\'}, {0x22, '"'}, {0x27, '\''},
+		{0x0a, 'n'}};
+	std::ostringstream out;
+	out << std::setfill('0');
+
+	for (auto it = str.cbegin(); it != str.cend(); ++it) {
+		char c = *it;
+		char next = (it + 1) == str.cend() ? '\0' : *(it + 1);
+
+		auto scit = shortcuts.find(c);
+		if (scit != shortcuts.end())
+			out << '\\' << scit->second;
+		else if (std::isprint(c))
+			out << c;
+		else if (std::isxdigit(next))
+			out << '\\' << std::oct << std::setw(3) << static_cast<int>(c);
+		else if (c >= 0 && c < 8)
+			out << '\\' << std::oct << std::setw(0) << static_cast<int>(c);
+		else
+			out << "\\x" << std::hex << std::setw(0) << (static_cast<int>(c) & 0xff);
+	}
+	return out.str();
+}
+
+void cmp_binstr(const std::string &a, const std::string b) {
+	CHECK(a.size() == b.size());
+	const int context_bytes = 8;
+	auto diff = std::mismatch(a.begin(), a.end(), b.begin(), b.end());
+	if (diff.first == a.end() && diff.second == b.end()) return;
+	auto pos = diff.first - a.begin();
+	if (pos < context_bytes)
+		REQUIRE(bytes_to_hexstr(a.substr(0, context_bytes)) ==
+				bytes_to_hexstr(b.substr(0, context_bytes)));
+	else {
+		INFO("First mismatch offset: " << pos)
+		std::string cmp_a = bytes_to_hexstr(a.substr(0, context_bytes)) + " ... " +
+							bytes_to_hexstr(a.substr(pos - context_bytes, 2 * context_bytes));
+		std::string cmp_b = bytes_to_hexstr(b.substr(0, context_bytes)) + " ... " +
+							bytes_to_hexstr(b.substr(pos - context_bytes, 2 * context_bytes));
+		REQUIRE(cmp_a == cmp_b);
+	}
+}

testing/common/bytecmp.hpp

@@ -0,0 +1,7 @@
+#pragma once
+#include <string>
+
+/// convert a binary string to the equivalent C-escaped string, e.g. "Hello\xaf\xbcWorld\0"
+std::string bytes_to_hexstr(const std::string &str);
+/// compare two binary strings, printing the location around the first mismatch
+void cmp_binstr(const std::string &a, const std::string b);

testing/helpers.h renamed to testing/common/create_streampair.hpp

@@ -9,7 +9,7 @@ struct Streampair {
 		: out_(std::move(out)), in_(std::move(in)) {}
 };
 
-static Streampair create_streampair(const lsl::stream_info &info) {
+inline Streampair create_streampair(const lsl::stream_info &info) {
 	lsl::stream_outlet out(info);
 	auto found_stream_info(lsl::resolve_stream("name", info.name(), 1, 2.0));
 	if (found_stream_info.empty()) throw std::runtime_error("outlet not found");

testing/helper_type.hpp renamed to testing/common/lsltypes.hpp

@@ -0,0 +1,195 @@
+#include "../common/bytecmp.hpp"
+#include "sample.h"
+#include "send_buffer.h"
+#include "stream_info_impl.h"
+#include "tcp_server.h"
+#include <asio/read.hpp>
+#include <asio/read_until.hpp>
+#include <asio/write.hpp>
+#include <catch2/catch.hpp>
+#include <functional>
+#include <sstream>
+#include <thread>
+
+using namespace asio::ip;
+using err_t = const asio::error_code &;
+using sock_t = tcp::socket;
+using sock_p = std::shared_ptr<sock_t>;
+
+/// RAII wrapper that takes care of shutting down the IO thread when an exception happens
+class tcp_server_wrapper {
+	std::shared_ptr<lsl::tcp_server> srv;
+	std::shared_ptr<asio::io_context> srv_ctx;
+	std::unique_ptr<std::thread> thread;
+public:
+	tcp_server_wrapper(std::shared_ptr<lsl::stream_info_impl> info) {
+		auto sendbuf = std::make_shared<lsl::send_buffer>(10);
+		srv_ctx = std::make_shared<asio::io_context>(1);
+		auto factory =
+			std::make_shared<lsl::factory>(info->channel_format(), info->channel_count(), 10);
+		srv = std::make_shared<lsl::tcp_server>(info, srv_ctx, sendbuf, factory, tcp::v4(), 5);
+		srv->begin_serving();
+	}
+	~tcp_server_wrapper() noexcept {
+		srv->end_serving();
+		if (thread)
+			thread->join();
+		else
+			srv_ctx->run();
+	}
+	void run() {
+		thread = std::make_unique<std::thread>([this](){ this->srv_ctx->run(); });
+	}
+	lsl::tcp_server* operator->() { return srv.get(); }
+
+};
+
+// testpattern timestamp 123456.789
+#define TESTPAT_TIMESTAMP "\xc9v\xbe\x9f\f$\xfe@"
+// testpattern for two strings
+#define TESTPAT_STR "\1\00210\1\3-11"
+
+void send_request(asio::io_context &ctx, const tcp::endpoint &ep, asio::const_buffer request,
+	std::function<void(sock_p)> write_cb) {
+	auto sock = std::make_shared<sock_t>(ctx);
+	sock->async_connect(ep, [=](err_t connect_err) {
+		INFO(connect_err.message())
+		REQUIRE(connect_err.value() == 0);
+		asio::async_write(*sock, request,
+			[=, expected_bytes = request.size()](err_t write_err, std::size_t sent_bytes) {
+				INFO("Sent " << sent_bytes << " bytes, outcome: " << write_err.message())
+				REQUIRE(write_err.value() == 0);
+				REQUIRE(sent_bytes == expected_bytes);
+				write_cb(sock);
+			});
+	});
+}
+
+auto with_read_callback(const char *name, std::function<void(const std::string &)> fun) {
+	return [name, fun = std::move(fun)](sock_p sock) {
+		auto buf = std::make_shared<std::string>();
+		asio::async_read(*sock, asio::dynamic_buffer(*buf),
+			[sock, buf, name, fun = std::move(fun)](err_t read_err, std::size_t len) {
+				INFO("Test " << name << "\t– read " << len
+							 << " bytes, outcome: " << read_err.message())
+				if (read_err) REQUIRE(read_err == asio::error::eof);
+				fun(*buf);
+			});
+	};
+}
+
+void check_streamfeed_100_response(const std::string &res) {
+	REQUIRE(res.substr(0, 3) == "\x7f\x01\x09");
+	auto info_len = static_cast<std::size_t>((res[5] << 8) | res[4]);
+	REQUIRE(res.size() > 6 + info_len);
+
+	auto info = lsl::stream_info_impl();
+	info.from_fullinfo_message(res.substr(6, info_len));
+	REQUIRE(info.source_id() == "abc123");
+
+	// precomputed string pattern for 2 string channels, serialized with Boost.Archive
+	const char pat_str[] = "\0\0"
+						   "\1\2\b" TESTPAT_TIMESTAMP TESTPAT_STR  // first sample
+						   "\1\2\b" TESTPAT_TIMESTAMP TESTPAT_STR; // second, identical sample
+	const char pat_f32[] = "\0\0\1\2\b" TESTPAT_TIMESTAMP		   // first sample
+						   "\4\0\0\x80@"						   // 4 bytes, raw float data
+						   "\4\0\0\xa0\xc0"
+						   "\4\0\0\xc0@"
+						   "\1\2\b" TESTPAT_TIMESTAMP // second sample
+						   "\4\0\0\0@"
+						   "\4\0\0@\xc0"
+						   "\4\0\0\x80@";
+	const std::string pat = info.channel_format() == cft_string
+								? std::string(pat_str, sizeof(pat_str) - 1)
+								: std::string(pat_f32, sizeof(pat_f32) - 1);
+	cmp_binstr(res.substr(6 + info_len), pat);
+}
+
+TEST_CASE("tcpserver", "[network]") {
+
+	asio::io_context ctx(1);
+
+	auto info = std::make_shared<lsl::stream_info_impl>("TCP_str", "", 2, 4., cft_string, "abc123");
+	tcp_server_wrapper tcp_server(info);
+	tcp::endpoint ep(address_v4(0x7f000001), info->v4data_port());
+
+	send_request(ctx, ep, asio::buffer("LSL:streamfeed/110 \n\r\n\r\n"),
+		with_read_callback("basic", [](const std::string &res) {
+			REQUIRE(res.substr(0, 14) == "LSL/110 200 OK");
+			auto endofheader = res.find("\r\n\r\n");
+			REQUIRE(endofheader != std::string::npos);
+			std::string received_pattern = res.substr(endofheader + 4);
+			std::string expected = "\2" TESTPAT_TIMESTAMP TESTPAT_STR;
+			expected += expected;
+			cmp_binstr(expected, received_pattern);
+		}));
+
+	send_request(ctx, ep, asio::buffer("LSL:streamfeed/199 \nNative-byte-order:4321\r\n\r\n"),
+		with_read_callback("endian", [](const std::string &res) {
+			REQUIRE(res.substr(0, 14) == "LSL/110 200 OK");
+			REQUIRE(res.find("Byte-Order: 4321") != std::string::npos);
+		}));
+
+	send_request(ctx, ep, asio::buffer("LSL:streamfeed\n0 0\r\n"),
+		with_read_callback("streamfeed 100", check_streamfeed_100_response));
+
+	send_request(ctx, ep, asio::buffer("LSL:fullinfo\r\n"),
+		with_read_callback("fullinfo", [expected = info->to_fullinfo_message()](
+										   const std::string &res) { REQUIRE(res == expected); }));
+
+	tcp_server.run();
+	ctx.run();
+}
+
+TEST_CASE("tcpserver_float", "[network]") {
+	auto srv_ctx = std::make_shared<asio::io_context>(1);
+	asio::io_context ctx(1);
+
+	auto info =
+		std::make_shared<lsl::stream_info_impl>("TCP_f32", "", 3, 4., cft_float32, "abc123");
+	tcp_server_wrapper tcp_server(info);
+	tcp::endpoint ep(address_v4(0x7f000001), info->v4data_port());
+
+	send_request(ctx, ep, asio::buffer("LSL:streamfeed/199 \nsupports-subnormals: 0\r\n\r\n"),
+		with_read_callback("suppress-subnormals", [](const std::string &res) {
+			REQUIRE(res.substr(0, 14) == "LSL/110 200 OK");
+			REQUIRE(res.find("Suppress-Subnormals: 1") != std::string::npos);
+			auto endofheader = res.find("\r\n\r\n");
+			REQUIRE(endofheader != std::string::npos);
+			std::string received_pattern = res.substr(endofheader + 4);
+			const char expected[] = "\2" TESTPAT_TIMESTAMP // sample 1
+									"\0\0\x80@"
+									"\0\0\xa0\xc0"
+									"\0\0\xc0@"
+									"\2" TESTPAT_TIMESTAMP // sample 2
+									"\0\0\0@"
+									"\0\0@\xc0"
+									"\0\0\x80@";
+			cmp_binstr(std::string(expected, sizeof(expected) - 1), received_pattern);
+		}));
+
+	send_request(ctx, ep, asio::buffer("LSL:streamfeed/110 \nNative-byte-order:4321\r\n\r\n"),
+		with_read_callback("endian", [](const std::string &res) {
+			REQUIRE(res.substr(0, 14) == "LSL/110 200 OK");
+			REQUIRE(res.find("Byte-Order: 4321") != std::string::npos);
+			auto endofheader = res.find("\r\n\r\n");
+			REQUIRE(endofheader != std::string::npos);
+			std::string received_pattern = res.substr(endofheader + 4);
+
+			const char expected[] = "\2" "@\xfe$\f\x9f\xbev\xc9" // sample 1
+									"@\x80\0\0"
+									"\xc0\xa0\0\0"
+									"@\xc0\0\0"
+									"\2" "@\xfe$\f\x9f\xbev\xc9" // sample 2
+									"@\0\0\0"
+									"\xc0@\0\0"
+									"@\x80\0\0";
+			cmp_binstr(std::string(expected, sizeof(expected) - 1), received_pattern);
+		}));
+
+	send_request(ctx, ep, asio::buffer("LSL:streamfeed\n0 0\r\n"),
+		with_read_callback("streamfeed 100", check_streamfeed_100_response));
+
+	tcp_server.run();
+	ctx.run();
+}

testing/internal/tcpserver.cpp

@@ -1,5 +1,5 @@
-#include "helper_type.hpp"
-#include "helpers.h"
+#include "common/create_streampair.hpp"
+#include "common/lsltypes.hpp"
 #include <catch2/catch.hpp>
 #include <cstdint>
 #include <lsl_cpp.h>