tests: posix: common: separate posix thread base into a standalone test

Pancakem · Pancakem · commit 06fea49ea208 · 2025-05-05T12:48:04.000+03:00
posix.common contains testsuites that can be separated into smaller
groups of tests. This change moves pthread into a singular
testsuite at tests/posix/thread_base app directory.

Signed-off-by: Marvin Ouma &lt;pancakesdeath@protonmail.com&gt;
diff --git a/tests/posix/threads_base/CMakeLists.txt b/tests/posix/threads_base/CMakeLists.txt
@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(posix_threads_base)
+
+FILE(GLOB app_sources src/*.c)
+
+target_sources(app PRIVATE ${app_sources})
+
+target_compile_options(app PRIVATE -U_POSIX_C_SOURCE -D_POSIX_C_SOURCE=200809L)
diff --git a/tests/posix/threads_base/prj.conf b/tests/posix/threads_base/prj.conf
@@ -0,0 +1,15 @@
+CONFIG_POSIX_API=y
+CONFIG_ZTEST=y
+
+CONFIG_POSIX_AEP_CHOICE_BASE=y
+CONFIG_POSIX_THREADS=y
+CONFIG_POSIX_PRIORITY_SCHEDULING=y
+CONFIG_POSIX_THREAD_PRIORITY_SCHEDULING=y
+CONFIG_THREAD_NAME=y
+CONFIG_DYNAMIC_THREAD=y
+CONFIG_THREAD_STACK_INFO=y
+CONFIG_DYNAMIC_THREAD_POOL_SIZE=6
+CONFIG_POSIX_THREAD_THREADS_MAX=6
+CONFIG_HEAP_MEM_POOL_SIZE=4096
+CONFIG_POSIX_THREAD_KEYS_MAX=512
+CONFIG_TEST_EXTRA_STACK_SIZE=4096
diff --git a/tests/posix/threads_base/src/cond.c b/tests/posix/threads_base/src/cond.c
@@ -13,7 +13,7 @@
  *
  * @details Exactly CONFIG_MAX_PTHREAD_COND_COUNT can be in use at once.
  */
-ZTEST(cond, test_cond_resource_exhausted)
+ZTEST(posix_threads_base, test_cond_resource_exhausted)
 {
 	size_t i;
 	pthread_cond_t m[CONFIG_MAX_PTHREAD_COND_COUNT + 1];
@@ -37,7 +37,7 @@ ZTEST(cond, test_cond_resource_exhausted)
  *
  * @details Demonstrate that condition variables may be used over and over again.
  */
-ZTEST(cond, test_cond_resource_leak)
+ZTEST(posix_threads_base, test_cond_resource_leak)
 {
 	pthread_cond_t cond;
 
@@ -47,7 +47,7 @@ ZTEST(cond, test_cond_resource_leak)
 	}
 }
 
-ZTEST(cond, test_pthread_condattr)
+ZTEST(posix_threads_base, test_pthread_condattr)
 {
 	clockid_t clock_id;
 	pthread_condattr_t att = {0};
diff --git a/tests/posix/threads_base/src/key.c b/tests/posix/threads_base/src/key.c
@@ -9,7 +9,7 @@
 #include <zephyr/sys/util.h>
 #include <zephyr/ztest.h>
 
-#define N_THR 2
+#define N_THR  2
 #define N_KEY  2
 #define BUFFSZ 48
 
@@ -74,7 +74,7 @@ static void make_keys(void)
  * multiple keys.
  */
 
-ZTEST(key, test_key_1toN_thread)
+ZTEST(posix_threads_base, test_key_1toN_thread)
 {
 	void *retval;
 	pthread_t newthread[N_THR];
@@ -95,7 +95,7 @@ ZTEST(key, test_key_1toN_thread)
 	zassert_ok(pthread_key_delete(key), "attempt to delete key failed");
 }
 
-ZTEST(key, test_key_Nto1_thread)
+ZTEST(posix_threads_base, test_key_Nto1_thread)
 {
 	pthread_t newthread;
 
@@ -113,7 +113,7 @@ ZTEST(key, test_key_Nto1_thread)
 	}
 }
 
-ZTEST(key, test_key_resource_leak)
+ZTEST(posix_threads_base, test_key_resource_leak)
 {
 	pthread_key_t key;
 
@@ -123,7 +123,7 @@ ZTEST(key, test_key_resource_leak)
 	}
 }
 
-ZTEST(key, test_correct_key_is_deleted)
+ZTEST(posix_threads_base, test_correct_key_is_deleted)
 {
 	pthread_key_t key;
 	size_t j = CONFIG_POSIX_THREAD_KEYS_MAX - 1;
@@ -162,34 +162,21 @@ static void *setspecific_thread(void *count)
 	return NULL;
 }
 
-ZTEST(key, test_thread_specific_data_deallocation)
+ZTEST(posix_threads_base, test_thread_specific_data_deallocation)
 {
 	pthread_t thread;
 	static int alloc_count_t0;
 	static int alloc_count_t1;
 
 	zassert_ok(pthread_create(&thread, NULL, setspecific_thread, &alloc_count_t0),
-		"attempt to create thread failed");
+		   "attempt to create thread failed");
 	zassert_ok(pthread_join(thread, NULL), "failed to join thread");
 	printk("first thread allocated %d keys", alloc_count_t0);
 
 	zassert_ok(pthread_create(&thread, NULL, setspecific_thread, &alloc_count_t1),
-		"attempt to create thread failed");
+		   "attempt to create thread failed");
 	zassert_ok(pthread_join(thread, NULL), "failed to join thread");
 	printk("second thread allocated %d keys", alloc_count_t1);
 
-	zassert_equal(alloc_count_t0, alloc_count_t1,
-		"failed to deallocate thread specific data");
-}
-
-static void before(void *arg)
-{
-	ARG_UNUSED(arg);
-
-	if (!IS_ENABLED(CONFIG_DYNAMIC_THREAD)) {
-		/* skip redundant testing if there is no thread pool / heap allocation */
-		ztest_test_skip();
-	}
+	zassert_equal(alloc_count_t0, alloc_count_t1, "failed to deallocate thread specific data");
 }
-
-ZTEST_SUITE(key, NULL, NULL, before, NULL, NULL);
diff --git a/tests/posix/threads_base/src/main.c b/tests/posix/threads_base/src/main.c
@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2023, Meta
+ * Copyright (c) 2024, Marvin Ouma <pancakesdeath@protonmail.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr/ztest.h>
+
+extern void before(void *arg);
+extern void after(void *arg);
+
+ZTEST_SUITE(posix_threads_base, NULL, NULL, before, after, NULL);
diff --git a/tests/posix/threads_base/src/mutex.c b/tests/posix/threads_base/src/mutex.c
@@ -85,7 +85,7 @@ static void test_mutex_common(int type, void *(*entry)(void *arg))
 	zassert_ok(pthread_mutex_destroy(&mutex), "Destroying mutex is failed");
 }
 
-ZTEST(mutex, test_mutex_prioceiling_stubs)
+ZTEST(posix_threads_base, test_mutex_prioceiling_stubs)
 {
 #ifdef CONFIG_POSIX_THREAD_PRIO_PROTECT
 	zassert_equal(pthread_mutex_getprioceiling(NULL, NULL), ENOSYS);
@@ -104,7 +104,7 @@ ZTEST(mutex, test_mutex_prioceiling_stubs)
  *	    and pthread_mutex_lock are tested with mutex type being
  *	    normal.
  */
-ZTEST(mutex, test_mutex_normal)
+ZTEST(posix_threads_base, test_mutex_normal)
 {
 	test_mutex_common(PTHREAD_MUTEX_NORMAL, normal_mutex_entry);
 }
@@ -116,7 +116,7 @@ ZTEST(mutex, test_mutex_normal)
  *	    twice and unlocked for the same number of time.
  *
  */
-ZTEST(mutex, test_mutex_recursive)
+ZTEST(posix_threads_base, test_mutex_recursive)
 {
 	test_mutex_common(PTHREAD_MUTEX_RECURSIVE, recursive_mutex_entry);
 }
@@ -126,7 +126,7 @@ ZTEST(mutex, test_mutex_recursive)
  *
  * @details Exactly CONFIG_MAX_PTHREAD_MUTEX_COUNT can be in use at once.
  */
-ZTEST(mutex, test_mutex_resource_exhausted)
+ZTEST(posix_threads_base, test_mutex_resource_exhausted)
 {
 	size_t i;
 	pthread_mutex_t m[CONFIG_MAX_PTHREAD_MUTEX_COUNT + 1];
@@ -150,7 +150,7 @@ ZTEST(mutex, test_mutex_resource_exhausted)
  *
  * @details Demonstrate that mutexes may be used over and over again.
  */
-ZTEST(mutex, test_mutex_resource_leak)
+ZTEST(posix_threads_base, test_mutex_resource_leak)
 {
 	pthread_mutex_t m;
 
@@ -189,7 +189,7 @@ static void *test_mutex_timedlock_fn(void *arg)
 }
 
 /** @brief Test to verify @ref pthread_mutex_timedlock returns ETIMEDOUT */
-ZTEST(mutex, test_mutex_timedlock)
+ZTEST(posix_threads_base, test_mutex_timedlock)
 {
 	void *ret;
 	pthread_t th;
@@ -215,15 +215,3 @@ ZTEST(mutex, test_mutex_timedlock)
 
 	zassert_ok(pthread_mutex_destroy(&mutex));
 }
-
-static void before(void *arg)
-{
-	ARG_UNUSED(arg);
-
-	if (!IS_ENABLED(CONFIG_DYNAMIC_THREAD)) {
-		/* skip redundant testing if there is no thread pool / heap allocation */
-		ztest_test_skip();
-	}
-}
-
-ZTEST_SUITE(mutex, NULL, NULL, before, NULL, NULL);
diff --git a/tests/posix/threads_base/src/mutex_attr.c b/tests/posix/threads_base/src/mutex_attr.c
@@ -9,7 +9,7 @@
 
 #include <zephyr/ztest.h>
 
-ZTEST(mutex_attr, test_pthread_mutexattr_init)
+ZTEST(posix_threads_base, test_pthread_mutexattr_init)
 {
 	pthread_mutexattr_t attr;
 
@@ -22,7 +22,7 @@ ZTEST(mutex_attr, test_pthread_mutexattr_init)
 	zassert_ok(pthread_mutexattr_destroy(&attr));
 }
 
-ZTEST(mutex_attr, test_pthread_mutexattr_destroy)
+ZTEST(posix_threads_base, test_pthread_mutexattr_destroy)
 {
 	pthread_mutexattr_t attr;
 
@@ -42,5 +42,3 @@ ZTEST(mutex_attr, test_pthread_mutexattr_destroy)
 		zassert_equal(EINVAL, pthread_mutexattr_destroy(&attr));
 	}
 }
-
-ZTEST_SUITE(mutex_attr, NULL, NULL, NULL, NULL, NULL);
diff --git a/tests/posix/threads_base/src/pthread.c b/tests/posix/threads_base/src/pthread.c
@@ -226,7 +226,7 @@ static void *thread_top_term(void *p1)
 /* Test the internal priority conversion functions */
 int zephyr_to_posix_priority(int z_prio, int *policy);
 int posix_to_zephyr_priority(int priority, int policy);
-ZTEST(pthread, test_pthread_priority_conversion)
+ZTEST(posix_threads_base, test_pthread_priority_conversion)
 {
 	/*
 	 *    ZEPHYR [-CONFIG_NUM_COOP_PRIORITIES, -1]
@@ -256,7 +256,7 @@ ZTEST(pthread, test_pthread_priority_conversion)
 	}
 }
 
-ZTEST(pthread, test_pthread_execution)
+ZTEST(posix_threads_base, test_pthread_execution)
 {
 	int i, ret;
 	pthread_t newthread[N_THR_E];
@@ -346,7 +346,7 @@ ZTEST(pthread, test_pthread_execution)
 	printk("Barrier test OK\n");
 }
 
-ZTEST(pthread, test_pthread_termination)
+ZTEST(posix_threads_base, test_pthread_termination)
 {
 	int32_t i, ret;
 	pthread_t newthread[N_THR_T] = {0};
@@ -376,7 +376,7 @@ ZTEST(pthread, test_pthread_termination)
 	zassert_equal(ret, ESRCH, "cancelled a terminated thread!");
 }
 
-ZTEST(pthread, test_pthread_tryjoin)
+ZTEST(posix_threads_base, test_pthread_tryjoin)
 {
 	pthread_t th = {0};
 	int sleep_duration_ms = 200;
@@ -396,7 +396,7 @@ ZTEST(pthread, test_pthread_tryjoin)
 	zassert_ok(pthread_tryjoin_np(th, &retval));
 }
 
-ZTEST(pthread, test_pthread_timedjoin)
+ZTEST(posix_threads_base, test_pthread_timedjoin)
 {
 	pthread_t th = {0};
 	int sleep_duration_ms = 200;
@@ -444,7 +444,7 @@ static void *create_thread1(void *p1)
 	return NULL;
 }
 
-ZTEST(pthread, test_pthread_descriptor_leak)
+ZTEST(posix_threads_base, test_pthread_descriptor_leak)
 {
 	pthread_t pthread1;
 
@@ -456,7 +456,7 @@ ZTEST(pthread, test_pthread_descriptor_leak)
 	}
 }
 
-ZTEST(pthread, test_pthread_equal)
+ZTEST(posix_threads_base, test_pthread_equal)
 {
 	zassert_true(pthread_equal(pthread_self(), pthread_self()));
 	zassert_false(pthread_equal(pthread_self(), (pthread_t)4242));
@@ -484,7 +484,7 @@ static void *test_pthread_cleanup_entry(void *arg)
 	return NULL;
 }
 
-ZTEST(pthread, test_pthread_cleanup)
+ZTEST(posix_threads_base, test_pthread_cleanup)
 {
 	pthread_t th;
 
@@ -522,7 +522,7 @@ static void *test_pthread_cancel_fn(void *arg)
 	return NULL;
 }
 
-ZTEST(pthread, test_pthread_testcancel)
+ZTEST(posix_threads_base, test_pthread_testcancel)
 {
 	pthread_t th;
 
@@ -550,22 +550,10 @@ static void *test_pthread_setschedprio_fn(void *arg)
 	return NULL;
 }
 
-ZTEST(pthread, test_pthread_setschedprio)
+ZTEST(posix_threads_base, test_pthread_setschedprio)
 {
 	pthread_t th;
 
 	zassert_ok(pthread_create(&th, NULL, test_pthread_setschedprio_fn, NULL));
 	zassert_ok(pthread_join(th, NULL));
 }
-
-static void before(void *arg)
-{
-	ARG_UNUSED(arg);
-
-	if (!IS_ENABLED(CONFIG_DYNAMIC_THREAD)) {
-		/* skip redundant testing if there is no thread pool / heap allocation */
-		ztest_test_skip();
-	}
-}
-
-ZTEST_SUITE(pthread, NULL, NULL, before, NULL, NULL);
diff --git a/tests/posix/threads_base/src/pthread_attr.c b/tests/posix/threads_base/src/pthread_attr.c
diff --git a/tests/posix/threads_base/testcase.yaml b/tests/posix/threads_base/testcase.yaml

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@`
`13`	`13`	`*`
`14`	`14`	`* @details Exactly CONFIG_MAX_PTHREAD_COND_COUNT can be in use at once.`
`15`	`15`	`*/`
`16`		`-ZTEST(cond, test_cond_resource_exhausted)`
	`16`	`+ZTEST(posix_threads_base, test_cond_resource_exhausted)`
`17`	`17`	`{`
`18`	`18`	`size_t i;`
`19`	`19`	`pthread_cond_t m[CONFIG_MAX_PTHREAD_COND_COUNT + 1];`
`@@ -37,7 +37,7 @@ ZTEST(cond, test_cond_resource_exhausted)`
`37`	`37`	`*`
`38`	`38`	`* @details Demonstrate that condition variables may be used over and over again.`
`39`	`39`	`*/`
`40`		`-ZTEST(cond, test_cond_resource_leak)`
	`40`	`+ZTEST(posix_threads_base, test_cond_resource_leak)`
`41`	`41`	`{`
`42`	`42`	`pthread_cond_t cond;`
`43`	`43`
`@@ -47,7 +47,7 @@ ZTEST(cond, test_cond_resource_leak)`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`		`-ZTEST(cond, test_pthread_condattr)`
	`50`	`+ZTEST(posix_threads_base, test_pthread_condattr)`
`51`	`51`	`{`
`52`	`52`	`clockid_t clock_id;`
`53`	`53`	`pthread_condattr_t att = {0};`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ static void test_mutex_common(int type, void (entry)(void *arg))`
`85`	`85`	`zassert_ok(pthread_mutex_destroy(&mutex), "Destroying mutex is failed");`
`86`	`86`	`}`
`87`	`87`
`88`		`-ZTEST(mutex, test_mutex_prioceiling_stubs)`
	`88`	`+ZTEST(posix_threads_base, test_mutex_prioceiling_stubs)`
`89`	`89`	`{`
`90`	`90`	`#ifdef CONFIG_POSIX_THREAD_PRIO_PROTECT`
`91`	`91`	`zassert_equal(pthread_mutex_getprioceiling(NULL, NULL), ENOSYS);`
`@@ -104,7 +104,7 @@ ZTEST(mutex, test_mutex_prioceiling_stubs)`
`104`	`104`	`* and pthread_mutex_lock are tested with mutex type being`
`105`	`105`	`* normal.`
`106`	`106`	`*/`
`107`		`-ZTEST(mutex, test_mutex_normal)`
	`107`	`+ZTEST(posix_threads_base, test_mutex_normal)`
`108`	`108`	`{`
`109`	`109`	`test_mutex_common(PTHREAD_MUTEX_NORMAL, normal_mutex_entry);`
`110`	`110`	`}`
`@@ -116,7 +116,7 @@ ZTEST(mutex, test_mutex_normal)`
`116`	`116`	`* twice and unlocked for the same number of time.`
`117`	`117`	`*`
`118`	`118`	`*/`
`119`		`-ZTEST(mutex, test_mutex_recursive)`
	`119`	`+ZTEST(posix_threads_base, test_mutex_recursive)`
`120`	`120`	`{`
`121`	`121`	`test_mutex_common(PTHREAD_MUTEX_RECURSIVE, recursive_mutex_entry);`
`122`	`122`	`}`
`@@ -126,7 +126,7 @@ ZTEST(mutex, test_mutex_recursive)`
`126`	`126`	`*`
`127`	`127`	`* @details Exactly CONFIG_MAX_PTHREAD_MUTEX_COUNT can be in use at once.`
`128`	`128`	`*/`
`129`		`-ZTEST(mutex, test_mutex_resource_exhausted)`
	`129`	`+ZTEST(posix_threads_base, test_mutex_resource_exhausted)`
`130`	`130`	`{`
`131`	`131`	`size_t i;`
`132`	`132`	`pthread_mutex_t m[CONFIG_MAX_PTHREAD_MUTEX_COUNT + 1];`
`@@ -150,7 +150,7 @@ ZTEST(mutex, test_mutex_resource_exhausted)`
`150`	`150`	`*`
`151`	`151`	`* @details Demonstrate that mutexes may be used over and over again.`
`152`	`152`	`*/`
`153`		`-ZTEST(mutex, test_mutex_resource_leak)`
	`153`	`+ZTEST(posix_threads_base, test_mutex_resource_leak)`
`154`	`154`	`{`
`155`	`155`	`pthread_mutex_t m;`
`156`	`156`
`@@ -189,7 +189,7 @@ static void test_mutex_timedlock_fn(void arg)`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`/** @brief Test to verify @ref pthread_mutex_timedlock returns ETIMEDOUT */`
`192`		`-ZTEST(mutex, test_mutex_timedlock)`
	`192`	`+ZTEST(posix_threads_base, test_mutex_timedlock)`
`193`	`193`	`{`
`194`	`194`	`void *ret;`
`195`	`195`	`pthread_t th;`
`@@ -215,15 +215,3 @@ ZTEST(mutex, test_mutex_timedlock)`
`215`	`215`
`216`	`216`	`zassert_ok(pthread_mutex_destroy(&mutex));`
`217`	`217`	`}`
`218`		`-`
`219`		`-static void before(void *arg)`
`220`		`-{`
`221`		`- ARG_UNUSED(arg);`
`222`		`-`
`223`		`- if (!IS_ENABLED(CONFIG_DYNAMIC_THREAD)) {`
`224`		`- /* skip redundant testing if there is no thread pool / heap allocation */`
`225`		`- ztest_test_skip();`
`226`		`- }`
`227`		`-}`
`228`		`-`
`229`		`-ZTEST_SUITE(mutex, NULL, NULL, before, NULL, NULL);`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`
`10`	`10`	`#include <zephyr/ztest.h>`
`11`	`11`
`12`		`-ZTEST(mutex_attr, test_pthread_mutexattr_init)`
	`12`	`+ZTEST(posix_threads_base, test_pthread_mutexattr_init)`
`13`	`13`	`{`
`14`	`14`	`pthread_mutexattr_t attr;`
`15`	`15`
`@@ -22,7 +22,7 @@ ZTEST(mutex_attr, test_pthread_mutexattr_init)`
`22`	`22`	`zassert_ok(pthread_mutexattr_destroy(&attr));`
`23`	`23`	`}`
`24`	`24`
`25`		`-ZTEST(mutex_attr, test_pthread_mutexattr_destroy)`
	`25`	`+ZTEST(posix_threads_base, test_pthread_mutexattr_destroy)`
`26`	`26`	`{`
`27`	`27`	`pthread_mutexattr_t attr;`
`28`	`28`
`@@ -42,5 +42,3 @@ ZTEST(mutex_attr, test_pthread_mutexattr_destroy)`
`42`	`42`	`zassert_equal(EINVAL, pthread_mutexattr_destroy(&attr));`
`43`	`43`	`}`
`44`	`44`	`}`
`45`		`-`
`46`		`-ZTEST_SUITE(mutex_attr, NULL, NULL, NULL, NULL, NULL);`
Original file line number	Diff line number	Diff line change
`@@ -226,7 +226,7 @@ static void thread_top_term(void p1)`
`226`	`226`	`/* Test the internal priority conversion functions */`
`227`	`227`	`int zephyr_to_posix_priority(int z_prio, int *policy);`
`228`	`228`	`int posix_to_zephyr_priority(int priority, int policy);`
`229`		`-ZTEST(pthread, test_pthread_priority_conversion)`
	`229`	`+ZTEST(posix_threads_base, test_pthread_priority_conversion)`
`230`	`230`	`{`
`231`	`231`	`/*`
`232`	`232`	`* ZEPHYR [-CONFIG_NUM_COOP_PRIORITIES, -1]`
`@@ -256,7 +256,7 @@ ZTEST(pthread, test_pthread_priority_conversion)`
`256`	`256`	`}`
`257`	`257`	`}`
`258`	`258`
`259`		`-ZTEST(pthread, test_pthread_execution)`
	`259`	`+ZTEST(posix_threads_base, test_pthread_execution)`
`260`	`260`	`{`
`261`	`261`	`int i, ret;`
`262`	`262`	`pthread_t newthread[N_THR_E];`
`@@ -346,7 +346,7 @@ ZTEST(pthread, test_pthread_execution)`
`346`	`346`	`printk("Barrier test OK\n");`
`347`	`347`	`}`
`348`	`348`
`349`		`-ZTEST(pthread, test_pthread_termination)`
	`349`	`+ZTEST(posix_threads_base, test_pthread_termination)`
`350`	`350`	`{`
`351`	`351`	`int32_t i, ret;`
`352`	`352`	`pthread_t newthread[N_THR_T] = {0};`
`@@ -376,7 +376,7 @@ ZTEST(pthread, test_pthread_termination)`
`376`	`376`	`zassert_equal(ret, ESRCH, "cancelled a terminated thread!");`
`377`	`377`	`}`
`378`	`378`
`379`		`-ZTEST(pthread, test_pthread_tryjoin)`
	`379`	`+ZTEST(posix_threads_base, test_pthread_tryjoin)`
`380`	`380`	`{`
`381`	`381`	`pthread_t th = {0};`
`382`	`382`	`int sleep_duration_ms = 200;`
`@@ -396,7 +396,7 @@ ZTEST(pthread, test_pthread_tryjoin)`
`396`	`396`	`zassert_ok(pthread_tryjoin_np(th, &retval));`
`397`	`397`	`}`
`398`	`398`
`399`		`-ZTEST(pthread, test_pthread_timedjoin)`
	`399`	`+ZTEST(posix_threads_base, test_pthread_timedjoin)`
`400`	`400`	`{`
`401`	`401`	`pthread_t th = {0};`
`402`	`402`	`int sleep_duration_ms = 200;`
`@@ -444,7 +444,7 @@ static void create_thread1(void p1)`
`444`	`444`	`return NULL;`
`445`	`445`	`}`
`446`	`446`
`447`		`-ZTEST(pthread, test_pthread_descriptor_leak)`
	`447`	`+ZTEST(posix_threads_base, test_pthread_descriptor_leak)`
`448`	`448`	`{`
`449`	`449`	`pthread_t pthread1;`
`450`	`450`
`@@ -456,7 +456,7 @@ ZTEST(pthread, test_pthread_descriptor_leak)`
`456`	`456`	`}`
`457`	`457`	`}`
`458`	`458`
`459`		`-ZTEST(pthread, test_pthread_equal)`
	`459`	`+ZTEST(posix_threads_base, test_pthread_equal)`
`460`	`460`	`{`
`461`	`461`	`zassert_true(pthread_equal(pthread_self(), pthread_self()));`
`462`	`462`	`zassert_false(pthread_equal(pthread_self(), (pthread_t)4242));`
`@@ -484,7 +484,7 @@ static void test_pthread_cleanup_entry(void arg)`
`484`	`484`	`return NULL;`
`485`	`485`	`}`
`486`	`486`
`487`		`-ZTEST(pthread, test_pthread_cleanup)`
	`487`	`+ZTEST(posix_threads_base, test_pthread_cleanup)`
`488`	`488`	`{`
`489`	`489`	`pthread_t th;`
`490`	`490`
`@@ -522,7 +522,7 @@ static void test_pthread_cancel_fn(void arg)`
`522`	`522`	`return NULL;`
`523`	`523`	`}`
`524`	`524`
`525`		`-ZTEST(pthread, test_pthread_testcancel)`
	`525`	`+ZTEST(posix_threads_base, test_pthread_testcancel)`
`526`	`526`	`{`
`527`	`527`	`pthread_t th;`
`528`	`528`
`@@ -550,22 +550,10 @@ static void test_pthread_setschedprio_fn(void arg)`
`550`	`550`	`return NULL;`
`551`	`551`	`}`
`552`	`552`
`553`		`-ZTEST(pthread, test_pthread_setschedprio)`
	`553`	`+ZTEST(posix_threads_base, test_pthread_setschedprio)`
`554`	`554`	`{`
`555`	`555`	`pthread_t th;`
`556`	`556`
`557`	`557`	`zassert_ok(pthread_create(&th, NULL, test_pthread_setschedprio_fn, NULL));`
`558`	`558`	`zassert_ok(pthread_join(th, NULL));`
`559`	`559`	`}`
`560`		`-`
`561`		`-static void before(void *arg)`
`562`		`-{`
`563`		`- ARG_UNUSED(arg);`
`564`		`-`
`565`		`- if (!IS_ENABLED(CONFIG_DYNAMIC_THREAD)) {`
`566`		`- /* skip redundant testing if there is no thread pool / heap allocation */`
`567`		`- ztest_test_skip();`
`568`		`- }`
`569`		`-}`
`570`		`-`
`571`		`-ZTEST_SUITE(pthread, NULL, NULL, before, NULL, NULL);`