tests: cpp: tests for std::thread and std::this_thread

This commit adds tests for std::thread and std::this_thread.

Fixes #25569

Signed-off-by: Christopher Friedt <[email protected]>

tests/subsys/cpp/thread/CMakeLists.txt

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.13.1)
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(thread)
+
+FILE(GLOB_RECURSE app_sources src/*.cpp)
+target_sources(app PRIVATE ${app_sources})

tests/subsys/cpp/thread/prj.conf

@@ -0,0 +1,6 @@
+CONFIG_NEWLIB_LIBC=y
+CONFIG_CPLUSPLUS=y
+CONFIG_LIB_CPLUSPLUS=y
+CONFIG_STD_CPP17=y
+CONFIG_ZTEST=y
+CONFIG_EXCEPTIONS=y

tests/subsys/cpp/thread/src/main.cpp

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020 Friedt Professional Engineering Services, Inc
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <ztest.h>
+
+BUILD_ASSERT(__cplusplus == 201703);
+
+extern void test_this_thread_get_id(void);
+extern void test_this_thread_yield(void);
+extern void test_this_thread_sleep_until(void);
+extern void test_this_thread_sleep_for(void);
+
+extern void test_thread_get_id(void);
+extern void test_thread_native_handle(void);
+extern void test_thread_hardware_concurrency(void);
+extern void test_thread_join(void);
+extern void test_thread_detach(void);
+extern void test_thread_swap(void);
+
+void test_main(void)
+{
+	TC_PRINT("version %u\n", (uint32_t)__cplusplus);
+	ztest_test_suite(std_thread_tests, ztest_unit_test(test_this_thread_get_id),
+			 ztest_unit_test(test_this_thread_yield),
+			 ztest_unit_test(test_this_thread_sleep_until),
+			 ztest_unit_test(test_this_thread_sleep_for),
+
+			 ztest_unit_test(test_thread_get_id),
+			 ztest_unit_test(test_thread_native_handle),
+			 ztest_unit_test(test_thread_hardware_concurrency),
+			 ztest_unit_test(test_thread_join), ztest_unit_test(test_thread_detach),
+			 ztest_unit_test(test_thread_swap));
+
+	ztest_run_test_suite(std_thread_tests);
+}

tests/subsys/cpp/thread/src/this_thread.cpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Friedt Professional Engineering Services, Inc
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <chrono>
+#include <system_error>
+#include <thread>
+#include <ztest.h>
+
+BUILD_ASSERT(__cplusplus == 201703);
+
+using namespace std;
+using namespace std::chrono_literals;
+
+auto now()
+{
+	return chrono::steady_clock::now();
+}
+
+void test_this_thread_get_id(void)
+{
+	thread::id id = this_thread::get_id();
+}
+
+void test_this_thread_yield(void)
+{
+	this_thread::yield();
+}
+
+void test_this_thread_sleep_until(void)
+{
+	this_thread::sleep_until(now() + 10ms);
+}
+
+void test_this_thread_sleep_for(void)
+{
+	this_thread::sleep_for(10ms);
+}

tests/subsys/cpp/thread/src/thread.cpp

@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2020 Friedt Professional Engineering Services, Inc
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <system_error>
+#include <thread>
+#include <ztest.h>
+
+BUILD_ASSERT(__cplusplus == 201703);
+
+using namespace std;
+
+void test_thread_joinable(void)
+{
+	if (!IS_ENABLED(CONFIG_ARCH_POSIX)) {
+		// cannot autoallocate thread stacks yet in Zephyr
+		ztest_test_skip();
+	}
+
+	// implicitly tests the move assignment operator (operator=)
+	thread th = thread([]() {});
+	zassert_true(th.joinable(), "non-default constructed thread should be joinable");
+
+	if (IS_ENABLED(__cpp_exceptions)) {
+		try {
+			th.join();
+		} catch (const system_error &e) {
+			zassert_true(false, "joinable thread should join");
+		}
+	} else {
+		th.join();
+	}
+
+	zassert_false(th.joinable(), "previously joined thread should not be joinable");
+
+	th = thread([]() {});
+	th.detach();
+	zassert_false(th.joinable(), "detached thread should not be joinable");
+}
+
+void test_thread_get_id(void)
+{
+	thread::id tid = this_thread::get_id();
+}
+
+void test_thread_native_handle(void)
+{
+	if (!IS_ENABLED(CONFIG_ARCH_POSIX)) {
+		// cannot autoallocate thread stacks yet in Zephyr
+		ztest_test_skip();
+	}
+
+	thread th([]() {});
+	th.native_handle();
+	th.join();
+}
+
+void test_thread_hardware_concurrency(void)
+{
+	if (IS_ENABLED(CONFIG_ARCH_POSIX)) {
+		zassert_true(thread::hardware_concurrency() >= 1, "actual: %u, expected: >= 1",
+			     thread::hardware_concurrency());
+	} else {
+		zassert_equal(thread::hardware_concurrency(), CONFIG_MP_NUM_CPUS,
+			      "actual: %u, expected: %u", thread::hardware_concurrency(),
+			      CONFIG_MP_NUM_CPUS);
+	}
+}
+
+void test_thread_join(void)
+{
+	thread th;
+	bool caught = false;
+
+	if (IS_ENABLED(__cpp_exceptions)) {
+		try {
+			th.join();
+		} catch (const system_error &e) {
+			caught = true;
+			zassert_equal(e.code(), errc::no_such_process,
+				      "expected errc::no_such_process");
+		}
+		zassert_true(caught, "join of default-constructed thread should throw");
+	}
+
+	if (!IS_ENABLED(CONFIG_ARCH_POSIX)) {
+		// cannot autoallocate thread stacks yet in Zephyr
+		ztest_test_skip();
+	}
+
+	th = thread([]() {});
+	if (IS_ENABLED(__cpp_exceptions)) {
+		caught = false;
+		try {
+			th.join();
+		} catch (const system_error &e) {
+			caught = true;
+		}
+		zassert_false(caught, "join() should not throw");
+	} else {
+		th.join();
+	}
+
+	if (IS_ENABLED(__cpp_exceptions)) {
+		caught = false;
+		try {
+			th.join();
+		} catch (const system_error &e) {
+			caught = true;
+			zassert_equal(e.code(), errc::invalid_argument,
+				      "expected errc::invalid_argument");
+		}
+		zassert_true(caught, "join should throw with already-joined thread");
+	}
+}
+
+void test_thread_detach(void)
+{
+	thread th;
+	bool caught = false;
+
+	if (IS_ENABLED(__cpp_exceptions)) {
+		// this is the behaviour in linux for detach() with an invalid thread object
+		caught = false;
+		try {
+			th.detach();
+		} catch (const system_error &e) {
+			caught = true;
+			zassert_equal(e.code(), errc::invalid_argument,
+				      "expected errc::invalid_argument");
+		}
+		zassert_true(caught, "detach should throw with default-constructed thread");
+	}
+
+	if (!IS_ENABLED(CONFIG_ARCH_POSIX)) {
+		// cannot autoallocate thread stacks yet in Zephyr
+		ztest_test_skip();
+	}
+
+	th = thread([]() {});
+	if (IS_ENABLED(__cpp_exceptions)) {
+		caught = false;
+		try {
+			th.detach();
+		} catch (const system_error &e) {
+			caught = true;
+		}
+		zassert_false(caught, "detach on a valid thread should not throw");
+	} else {
+		th.detach();
+	}
+
+	if (IS_ENABLED(__cpp_exceptions)) {
+		caught = false;
+		try {
+			th.detach();
+		} catch (const system_error &e) {
+			caught = true;
+		}
+		zassert_true(caught, "detach on an already-detached thread should throw");
+	}
+}
+
+void test_thread_swap(void)
+{
+	thread th1;
+	thread th2;
+
+	if (IS_ENABLED(__cpp_exceptions)) {
+		bool caught = false;
+		try {
+			th1.swap(th2);
+		} catch (...) {
+			caught = true;
+		}
+		zassert_false(caught, "thread::swap() is noexcept");
+	}
+
+	if (!IS_ENABLED(CONFIG_ARCH_POSIX)) {
+		// cannot autoallocate thread stacks yet in Zephyr
+		ztest_test_skip();
+	}
+
+	th1 = thread([]() {});
+	th2 = thread([]() {});
+
+	thread::id th1_id = th1.get_id();
+	thread::id th2_id = th2.get_id();
+
+	th1.swap(th2);
+
+	zassert_equal(th2.get_id(), th1_id, "expected ids to be swapped");
+
+	zassert_equal(th1.get_id(), th2_id, "expected ids to be swapped");
+
+	th1.join();
+	th2.join();
+}

tests/subsys/cpp/thread/testcase.yaml

@@ -0,0 +1,7 @@
+tests:
+  cpp.thread:
+    tags: cpp
+  cpp.thread.exceptions:
+    tags: cpp
+    extra_configs:
+      - CONFIG_EXCEPTIONS=y