This is an automated email from the ASF dual-hosted git repository.

xiaoxiang781216 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx-apps.git


The following commit(s) were added to refs/heads/master by this push:
     new d3fcc57fc testing/libc/ring: add cmocka tests for the lock-free ring
d3fcc57fc is described below

commit d3fcc57fcb1e938293c39751a878ea275b565125
Author: Bowen Wang <[email protected]>
AuthorDate: Fri Nov 13 21:06:21 2026 +0800

    testing/libc/ring: add cmocka tests for the lock-free ring
    
    Add a cmocka suite for include/nuttx/ring.h covering all four modes
    (SPSC/MPSC/SPMC/MPMC): basic and batch enqueue/dequeue, full and empty
    boundaries, partial batches, index wraparound, non-power-of-two
    capacities, ring_alloc(), overwrite, skip, init and warm-restart
    recovery (rewind, corrupted or resized blob, interrupted MP commit,
    SPSC slave, concurrent init), and pthread producer/consumer stress.
    
    Enable CONFIG_TESTING_RING and run "ring_test" from nsh.
    
    Signed-off-by: wangjianyu3 <[email protected]>
    Signed-off-by: Bowen Wang <[email protected]>
---
 testing/libc/ring/CMakeLists.txt |   39 +
 testing/libc/ring/Kconfig        |   30 +
 testing/libc/ring/Make.defs      |   25 +
 testing/libc/ring/Makefile       |   37 +
 testing/libc/ring/ring_main.c    |   42 ++
 testing/libc/ring/ring_mpmc.c    | 1074 ++++++++++++++++++++++++++++
 testing/libc/ring/ring_mpsc.c    |  511 +++++++++++++
 testing/libc/ring/ring_spmc.c    |  520 ++++++++++++++
 testing/libc/ring/ring_spsc.c    | 1462 ++++++++++++++++++++++++++++++++++++++
 testing/libc/ring/ring_test.h    |  176 +++++
 10 files changed, 3916 insertions(+)

diff --git a/testing/libc/ring/CMakeLists.txt b/testing/libc/ring/CMakeLists.txt
new file mode 100644
index 000000000..742491a7e
--- /dev/null
+++ b/testing/libc/ring/CMakeLists.txt
@@ -0,0 +1,39 @@
+# 
##############################################################################
+# apps/testing/libc/ring/CMakeLists.txt
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more 
contributor
+# license agreements.  See the NOTICE file distributed with this work for
+# additional information regarding copyright ownership.  The ASF licenses this
+# file to you under the Apache License, Version 2.0 (the "License"); 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.
+#
+# 
##############################################################################
+
+if(CONFIG_TESTING_RING)
+  nuttx_add_application(
+    NAME
+    ${CONFIG_TESTING_RING_PROGNAME}
+    PRIORITY
+    ${CONFIG_TESTING_RING_PRIORITY}
+    STACKSIZE
+    ${CONFIG_TESTING_RING_STACKSIZE}
+    MODULE
+    ${CONFIG_TESTING_RING}
+    SRCS
+    ring_main.c
+    ring_spsc.c
+    ring_mpsc.c
+    ring_spmc.c
+    ring_mpmc.c)
+endif()
diff --git a/testing/libc/ring/Kconfig b/testing/libc/ring/Kconfig
new file mode 100644
index 000000000..8ba96af9e
--- /dev/null
+++ b/testing/libc/ring/Kconfig
@@ -0,0 +1,30 @@
+#
+# For a description of the syntax of this configuration file,
+# see the file kconfig-language.txt in the NuttX tools repository.
+#
+
+config TESTING_RING
+       tristate "cmocka ring queue test"
+       default n
+       depends on TESTING_CMOCKA
+       ---help---
+               Enable the lock-free ring queue testing using cmocka framework.
+
+if TESTING_RING
+
+config TESTING_RING_PROGNAME
+       string "Program name"
+       default "ring_test"
+       ---help---
+               This is the name of the program that will be used when the NSH 
ELF
+               program is installed.
+
+config TESTING_RING_PRIORITY
+       int "Ring test task priority"
+       default 100
+
+config TESTING_RING_STACKSIZE
+       int "Ring test stack size"
+       default 8192
+
+endif
diff --git a/testing/libc/ring/Make.defs b/testing/libc/ring/Make.defs
new file mode 100644
index 000000000..daf733d84
--- /dev/null
+++ b/testing/libc/ring/Make.defs
@@ -0,0 +1,25 @@
+############################################################################
+# apps/testing/libc/ring/Make.defs
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); 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.
+#
+############################################################################
+
+ifneq ($(CONFIG_TESTING_RING),)
+CONFIGURED_APPS += $(APPDIR)/testing/libc/ring
+endif
diff --git a/testing/libc/ring/Makefile b/testing/libc/ring/Makefile
new file mode 100644
index 000000000..7a0a1e6ba
--- /dev/null
+++ b/testing/libc/ring/Makefile
@@ -0,0 +1,37 @@
+############################################################################
+# apps/testing/libc/ring/Makefile
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); 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.
+#
+############################################################################
+
+include $(APPDIR)/Make.defs
+
+# Ring test built-in application info
+
+PROGNAME  = $(CONFIG_TESTING_RING_PROGNAME)
+PRIORITY  = $(CONFIG_TESTING_RING_PRIORITY)
+STACKSIZE = $(CONFIG_TESTING_RING_STACKSIZE)
+MODULE    = $(CONFIG_TESTING_RING)
+
+# Ring test sources
+
+CSRCS   = ring_spsc.c ring_mpsc.c ring_spmc.c ring_mpmc.c
+MAINSRC = ring_main.c
+
+include $(APPDIR)/Application.mk
diff --git a/testing/libc/ring/ring_main.c b/testing/libc/ring/ring_main.c
new file mode 100644
index 000000000..6a41ce967
--- /dev/null
+++ b/testing/libc/ring/ring_main.c
@@ -0,0 +1,42 @@
+/****************************************************************************
+ * apps/testing/libc/ring/ring_main.c
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.  The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); 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.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include "ring_test.h"
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+int main(int argc, FAR char *argv[])
+{
+  int fail = 0;
+
+  fail += ring_test_spsc_local();
+  fail += ring_test_mpsc_local();
+  fail += ring_test_spmc_local();
+  fail += ring_test_mpmc_local();
+  return fail;
+}
diff --git a/testing/libc/ring/ring_mpmc.c b/testing/libc/ring/ring_mpmc.c
new file mode 100644
index 000000000..7483a1463
--- /dev/null
+++ b/testing/libc/ring/ring_mpmc.c
@@ -0,0 +1,1074 @@
+/****************************************************************************
+ * apps/testing/libc/ring/ring_mpmc.c
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.  The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); 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.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include "ring_test.h"
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/* Per-test static rings, kept off the test stack */
+
+RING_TEST_DEFINE(g_mpmc_basic, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_mpmc_batch, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_mpmc_full, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_mpmc_typed, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_mpmc_boundary, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_mpmc_partial, uint32_t, 8);
+RING_TEST_DEFINE(g_mpmc_wrap, uint32_t, 8);
+RING_TEST_DEFINE(g_mpmc_cap2, uint32_t, 2);
+RING_TEST_DEFINE(g_mpmc_count, uint32_t, 8);
+RING_TEST_DEFINE(g_mpmc_conc, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_mpmc_ow, uint32_t, 8);
+RING_TEST_DEFINE(g_mpmc_ow_wrap, uint32_t, 8);
+RING_TEST_DEFINE(g_mpmc_ow_batch, uint32_t, 8);
+RING_TEST_DEFINE(g_mpmc_ow_cap, uint32_t, 8);
+RING_TEST_DEFINE(g_mpmc_ow_conc, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_mpmc_skip_conc, uint32_t, RING_TEST_CAP);
+
+/****************************************************************************
+ * Private Functions - Single-core functional test
+ ****************************************************************************/
+
+static void test_mpmc_basic(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_basic);
+
+  for (i = 0; i < 16; i++)
+    {
+      val = i + 500;
+      n = rt_mpmc_enqueue(&g_mpmc_basic, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  assert_int_equal(rt_count(&g_mpmc_basic), 16);
+
+  for (i = 0; i < 16; i++)
+    {
+      n = rt_mpmc_dequeue(&g_mpmc_basic, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i + 500);
+    }
+}
+
+static void test_mpmc_batch(FAR void **state)
+{
+  uint32_t buf[RING_TEST_BATCH];
+  uint32_t out[RING_TEST_BATCH];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_batch);
+
+  for (i = 0; i < RING_TEST_BATCH; i++)
+    {
+      buf[i] = i + 200;
+    }
+
+  n = rt_mpmc_enqueue(&g_mpmc_batch, buf, RING_TEST_BATCH);
+  assert_int_equal(n, RING_TEST_BATCH);
+  n = rt_mpmc_dequeue(&g_mpmc_batch, out, RING_TEST_BATCH);
+  assert_int_equal(n, RING_TEST_BATCH);
+
+  for (i = 0; i < RING_TEST_BATCH; i++)
+    {
+      assert_int_equal(out[i], i + 200);
+    }
+}
+
+static void test_mpmc_full(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_full);
+
+  for (i = 0; i < RING_TEST_CAP; i++)
+    {
+      val = i;
+      n = rt_mpmc_enqueue(&g_mpmc_full, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  val = 999;
+  n = rt_mpmc_enqueue(&g_mpmc_full, &val, 1);
+  assert_int_equal(n, 0);
+
+  for (i = 0; i < RING_TEST_CAP; i++)
+    {
+      n = rt_mpmc_dequeue(&g_mpmc_full, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i);
+    }
+
+  assert_int_equal(rt_count(&g_mpmc_full), 0);
+}
+
+static void test_mpmc_typed_api(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t batch[4];
+  uint32_t obatch[4];
+  uint32_t n;
+  uint32_t i;
+
+  ring_test_init(&g_mpmc_typed);
+
+  val = 42;
+  n = rt_mpmc_enqueue(&g_mpmc_typed, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_mpmc_dequeue(&g_mpmc_typed, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 42);
+
+  for (i = 0; i < 4; i++)
+    {
+      batch[i] = i + 500;
+    }
+
+  n = rt_mpmc_enqueue(&g_mpmc_typed, batch, 4);
+  assert_int_equal(n, 4);
+  n = rt_mpmc_dequeue(&g_mpmc_typed, obatch, 4);
+  assert_int_equal(n, 4);
+
+  for (i = 0; i < 4; i++)
+    {
+      assert_int_equal(obatch[i], i + 500);
+    }
+}
+
+static void test_mpmc_alloc_free(FAR void **state)
+{
+  struct ring_test_s t;
+  FAR struct ring_test_s *r = &t;
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+
+  assert_non_null(ring_test_alloc(r, RING_TEST_CAP, sizeof(uint32_t)));
+
+  val = 77;
+  n = rt_mpmc_enqueue(r, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_mpmc_dequeue(r, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 77);
+
+  ring_free(r->r);
+}
+
+/****************************************************************************
+ * Private Functions - Boundary condition tests (MP enqueue, MC dequeue)
+ ****************************************************************************/
+
+static void test_mpmc_enqueue_dequeue_boundary(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_boundary);
+
+  /* Dequeue from empty ring (MC CAS path) */
+
+  n = rt_mpmc_dequeue(&g_mpmc_boundary, &out, 1);
+  assert_int_equal(n, 0);
+
+  /* Enqueue count=0 (MP CAS path) */
+
+  val = 42;
+  n = rt_mpmc_enqueue(&g_mpmc_boundary, &val, 0);
+  assert_int_equal(n, 0);
+  assert_int_equal(rt_count(&g_mpmc_boundary), 0);
+
+  /* Dequeue count=0 */
+
+  n = rt_mpmc_dequeue(&g_mpmc_boundary, &out, 0);
+  assert_int_equal(n, 0);
+
+  /* Fill ring (MP CAS path), then try one more */
+
+  for (i = 0; i < RING_TEST_CAP; i++)
+    {
+      val = i;
+      n = rt_mpmc_enqueue(&g_mpmc_boundary, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  assert_int_equal(rt_count(&g_mpmc_boundary), RING_TEST_CAP);
+
+  val = 999;
+  n = rt_mpmc_enqueue(&g_mpmc_boundary, &val, 1);
+  assert_int_equal(n, 0);
+}
+
+static void test_mpmc_partial_batch(FAR void **state)
+{
+  uint32_t buf[16];
+  uint32_t out[16];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_partial);
+
+  /* Batch enqueue larger than capacity (MP CAS path) */
+
+  for (i = 0; i < 16; i++)
+    {
+      buf[i] = i + 1;
+    }
+
+  n = rt_mpmc_enqueue(&g_mpmc_partial, buf, 16);
+  assert_int_equal(n, 8);
+
+  /* Batch dequeue larger than available (MC CAS path) */
+
+  n = rt_mpmc_dequeue(&g_mpmc_partial, out, 16);
+  assert_int_equal(n, 8);
+
+  for (i = 0; i < 8; i++)
+    {
+      assert_int_equal(out[i], i + 1);
+    }
+
+  /* Partial enqueue when partially full */
+
+  for (i = 0; i < 6; i++)
+    {
+      buf[i] = i + 100;
+    }
+
+  n = rt_mpmc_enqueue(&g_mpmc_partial, buf, 6);
+  assert_int_equal(n, 6);
+
+  for (i = 0; i < 4; i++)
+    {
+      buf[i] = i + 200;
+    }
+
+  n = rt_mpmc_enqueue(&g_mpmc_partial, buf, 4);
+  assert_int_equal(n, 2);
+  assert_int_equal(rt_count(&g_mpmc_partial), 8);
+
+  /* Partial dequeue (MC CAS path) */
+
+  n = rt_mpmc_dequeue(&g_mpmc_partial, out, 5);
+  assert_int_equal(n, 5);
+  assert_int_equal(rt_count(&g_mpmc_partial), 3);
+
+  n = rt_mpmc_dequeue(&g_mpmc_partial, out, 3);
+  assert_int_equal(n, 3);
+  assert_int_equal(rt_count(&g_mpmc_partial), 0);
+}
+
+static void test_mpmc_wraparound_batch(FAR void **state)
+{
+  uint32_t buf[8];
+  uint32_t out[8];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_wrap);
+
+  /* Advance indices to force wraparound */
+
+  for (i = 0; i < 6; i++)
+    {
+      buf[i] = i;
+    }
+
+  n = rt_mpmc_enqueue(&g_mpmc_wrap, buf, 6);
+  assert_int_equal(n, 6);
+  n = rt_mpmc_dequeue(&g_mpmc_wrap, out, 6);
+  assert_int_equal(n, 6);
+
+  /* Enqueue 8 items wrapping around (MP CAS path) */
+
+  for (i = 0; i < 8; i++)
+    {
+      buf[i] = i + 1000;
+    }
+
+  n = rt_mpmc_enqueue(&g_mpmc_wrap, buf, 8);
+  assert_int_equal(n, 8);
+
+  /* Dequeue wrapping around (MC CAS path) */
+
+  memset(out, 0, sizeof(out));
+  n = rt_mpmc_dequeue(&g_mpmc_wrap, out, 8);
+  assert_int_equal(n, 8);
+
+  for (i = 0; i < 8; i++)
+    {
+      assert_int_equal(out[i], i + 1000);
+    }
+}
+
+static void test_mpmc_capacity_two(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_cap2);
+
+  assert_int_equal(rt_capacity(&g_mpmc_cap2), 2);
+
+  val = 10;
+  n = rt_mpmc_enqueue(&g_mpmc_cap2, &val, 1);
+  assert_int_equal(n, 1);
+
+  val = 20;
+  n = rt_mpmc_enqueue(&g_mpmc_cap2, &val, 1);
+  assert_int_equal(n, 1);
+
+  /* Full (MP CAS path) */
+
+  val = 30;
+  n = rt_mpmc_enqueue(&g_mpmc_cap2, &val, 1);
+  assert_int_equal(n, 0);
+
+  /* MC dequeue */
+
+  n = rt_mpmc_dequeue(&g_mpmc_cap2, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 10);
+
+  n = rt_mpmc_dequeue(&g_mpmc_cap2, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 20);
+
+  /* Empty (MC CAS path) */
+
+  n = rt_mpmc_dequeue(&g_mpmc_cap2, &out, 1);
+  assert_int_equal(n, 0);
+}
+
+static void test_mpmc_count_boundary(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out[8];
+  uint32_t i;
+
+  ring_test_init(&g_mpmc_count);
+
+  assert_int_equal(rt_count(&g_mpmc_count), 0);
+
+  for (i = 0; i < 3; i++)
+    {
+      val = i;
+      rt_mpmc_enqueue(&g_mpmc_count, &val, 1);
+    }
+
+  assert_int_equal(rt_count(&g_mpmc_count), 3);
+
+  for (i = 3; i < 8; i++)
+    {
+      val = i;
+      rt_mpmc_enqueue(&g_mpmc_count, &val, 1);
+    }
+
+  assert_int_equal(rt_count(&g_mpmc_count), 8);
+
+  rt_mpmc_dequeue(&g_mpmc_count, out, 1);
+  assert_int_equal(rt_count(&g_mpmc_count), 7);
+
+  rt_mpmc_dequeue(&g_mpmc_count, out, 7);
+  assert_int_equal(rt_count(&g_mpmc_count), 0);
+}
+
+/****************************************************************************
+ * Private Functions - Overwrite enqueue tests
+ ****************************************************************************/
+
+static void test_mpmc_overwrite_basic(FAR void **state)
+{
+  uint32_t out[8];
+  uint32_t val;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_ow);
+
+  for (i = 0; i < 8; i++)
+    {
+      val = i;
+      rt_mpmc_overwrite(&g_mpmc_ow, &val, 1);
+    }
+
+  assert_int_equal(rt_count(&g_mpmc_ow), 8);
+
+  /* Overwrite: push one more, oldest (0) discarded */
+
+  val = 100;
+  n = rt_mpmc_overwrite(&g_mpmc_ow, &val, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(rt_count(&g_mpmc_ow), 8);
+
+  n = rt_mpmc_dequeue(&g_mpmc_ow, out, 8);
+  assert_int_equal(n, 8);
+  for (i = 0; i < 7; i++)
+    {
+      assert_int_equal(out[i], i + 1);
+    }
+
+  assert_int_equal(out[7], 100);
+}
+
+static void test_mpmc_overwrite_wrap(FAR void **state)
+{
+  uint32_t out[8];
+  uint32_t val;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_ow_wrap);
+
+  /* Advance indices to force wraparound */
+
+  for (i = 0; i < 6; i++)
+    {
+      val = i;
+      rt_mpmc_overwrite(&g_mpmc_ow_wrap, &val, 1);
+    }
+
+  rt_mpmc_dequeue(&g_mpmc_ow_wrap, out, 6);
+
+  /* Fill ring (indices start at 6, wraps at 8) */
+
+  for (i = 0; i < 8; i++)
+    {
+      val = i + 10;
+      rt_mpmc_overwrite(&g_mpmc_ow_wrap, &val, 1);
+    }
+
+  /* Overwrite 3 more: discards 10,11,12 */
+
+  for (i = 0; i < 3; i++)
+    {
+      val = i + 200;
+      rt_mpmc_overwrite(&g_mpmc_ow_wrap, &val, 1);
+    }
+
+  assert_int_equal(rt_count(&g_mpmc_ow_wrap), 8);
+
+  n = rt_mpmc_dequeue(&g_mpmc_ow_wrap, out, 8);
+  assert_int_equal(n, 8);
+
+  for (i = 0; i < 5; i++)
+    {
+      assert_int_equal(out[i], i + 13);
+    }
+
+  for (i = 0; i < 3; i++)
+    {
+      assert_int_equal(out[i + 5], i + 200);
+    }
+}
+
+static void test_mpmc_overwrite_batch(FAR void **state)
+{
+  uint32_t in[4];
+  uint32_t out[8];
+  uint32_t val;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_ow_batch);
+
+  for (i = 0; i < 8; i++)
+    {
+      val = i;
+      rt_mpmc_overwrite(&g_mpmc_ow_batch, &val, 1);
+    }
+
+  /* Batch overwrite 4 items: discards 0,1,2,3 */
+
+  for (i = 0; i < 4; i++)
+    {
+      in[i] = i + 100;
+    }
+
+  n = rt_mpmc_overwrite(&g_mpmc_ow_batch, in, 4);
+  assert_int_equal(n, 4);
+  assert_int_equal(rt_count(&g_mpmc_ow_batch), 8);
+
+  n = rt_mpmc_dequeue(&g_mpmc_ow_batch, out, 8);
+  assert_int_equal(n, 8);
+
+  for (i = 0; i < 4; i++)
+    {
+      assert_int_equal(out[i], i + 4);
+    }
+
+  for (i = 0; i < 4; i++)
+    {
+      assert_int_equal(out[i + 4], i + 100);
+    }
+}
+
+static void test_mpmc_overwrite_exceed_cap(FAR void **state)
+{
+  uint32_t in[16];
+  uint32_t out[8];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_ow_cap);
+
+  for (i = 0; i < 16; i++)
+    {
+      in[i] = i;
+    }
+
+  n = rt_mpmc_overwrite(&g_mpmc_ow_cap, in, 16);
+  assert_int_equal(n, 8);
+  assert_int_equal(rt_count(&g_mpmc_ow_cap), 8);
+
+  n = rt_mpmc_dequeue(&g_mpmc_ow_cap, out, 8);
+  assert_int_equal(n, 8);
+
+  for (i = 0; i < 8; i++)
+    {
+      assert_int_equal(out[i], i + 8);
+    }
+}
+
+static void test_mpmc_overwrite_not_full(FAR void **state)
+{
+  uint32_t out[8];
+  uint32_t val;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_ow);
+
+  for (i = 0; i < 4; i++)
+    {
+      val = i;
+      rt_mpmc_overwrite(&g_mpmc_ow, &val, 1);
+    }
+
+  val = 99;
+  n = rt_mpmc_overwrite(&g_mpmc_ow, &val, 1);
+  assert_int_equal(n, 0);
+  assert_int_equal(rt_count(&g_mpmc_ow), 5);
+
+  n = rt_mpmc_dequeue(&g_mpmc_ow, out, 5);
+  assert_int_equal(n, 5);
+  for (i = 0; i < 4; i++)
+    {
+      assert_int_equal(out[i], i);
+    }
+
+  assert_int_equal(out[4], 99);
+}
+
+/****************************************************************************
+ * Private Functions - Dequeue skip tests
+ ****************************************************************************/
+
+static void test_mpmc_dequeue_skip_basic(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_ow);
+
+  for (i = 0; i < 8; i++)
+    {
+      val = i;
+      rt_mpmc_enqueue(&g_mpmc_ow, &val, 1);
+    }
+
+  n = rt_mpmc_skip(&g_mpmc_ow, 3);
+  assert_int_equal(n, 3);
+  assert_int_equal(rt_count(&g_mpmc_ow), 5);
+
+  n = rt_mpmc_dequeue(&g_mpmc_ow, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 3);
+}
+
+static void test_mpmc_dequeue_skip_all(FAR void **state)
+{
+  uint32_t val;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_ow);
+
+  for (i = 0; i < 8; i++)
+    {
+      val = i;
+      rt_mpmc_enqueue(&g_mpmc_ow, &val, 1);
+    }
+
+  n = rt_mpmc_skip(&g_mpmc_ow, 8);
+  assert_int_equal(n, 8);
+  assert_int_equal(rt_count(&g_mpmc_ow), 0);
+}
+
+static void test_mpmc_dequeue_skip_more_than_avail(FAR void **state)
+{
+  uint32_t val;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_ow);
+
+  for (i = 0; i < 4; i++)
+    {
+      val = i;
+      rt_mpmc_enqueue(&g_mpmc_ow, &val, 1);
+    }
+
+  n = rt_mpmc_skip(&g_mpmc_ow, 8);
+  assert_int_equal(n, 4);
+  assert_int_equal(rt_count(&g_mpmc_ow), 0);
+}
+
+static void test_mpmc_dequeue_skip_empty(FAR void **state)
+{
+  uint32_t n;
+
+  ring_test_init(&g_mpmc_ow);
+
+  n = rt_mpmc_skip(&g_mpmc_ow, 5);
+  assert_int_equal(n, 0);
+}
+
+/****************************************************************************
+ * Private Functions - Single-core multi-thread concurrent test
+ *
+ * MPMC: N producer threads + N consumer threads.
+ * Uses pthread + sched_yield() for single-core safety.
+ ****************************************************************************/
+
+struct mpmc_prod_ctx_s
+{
+  FAR struct ring_test_s *ring;
+  int items;
+  atomic_t *start;
+};
+
+struct mpmc_cons_ctx_s
+{
+  FAR struct ring_test_s *ring;
+  FAR atomic_t *consumed;
+  int total;
+  atomic_t *start;
+};
+
+static FAR void *mpmc_producer_thread(FAR void *arg)
+{
+  FAR struct mpmc_prod_ctx_s *ctx = (FAR struct mpmc_prod_ctx_s *)arg;
+  uint32_t val;
+  int sent = 0;
+
+  while (atomic_read(ctx->start) == 0)
+    {
+      sched_yield();
+    }
+
+  while (sent < ctx->items)
+    {
+      val = (uint32_t)sent;
+      if (rt_mpmc_enqueue(ctx->ring, &val, 1) == 1)
+        {
+          sent++;
+        }
+      else
+        {
+          sched_yield();
+        }
+    }
+
+  return NULL;
+}
+
+static FAR void *mpmc_consumer_thread(FAR void *arg)
+{
+  FAR struct mpmc_cons_ctx_s *ctx = (FAR struct mpmc_cons_ctx_s *)arg;
+  uint32_t out = 0;
+
+  while (atomic_read(ctx->start) == 0)
+    {
+      sched_yield();
+    }
+
+  while (atomic_read(ctx->consumed) < ctx->total)
+    {
+      if (rt_mpmc_dequeue(ctx->ring, &out, 1) == 1)
+        {
+          atomic_add(ctx->consumed, 1);
+        }
+      else
+        {
+          sched_yield();
+        }
+    }
+
+  return NULL;
+}
+
+static void test_mpmc_concurrent(FAR void **state)
+{
+  struct mpmc_prod_ctx_s pctx[RING_TEST_THREADS];
+  struct mpmc_cons_ctx_s cctx[RING_TEST_THREADS];
+  pthread_t prod_threads[RING_TEST_THREADS];
+  pthread_t cons_threads[RING_TEST_THREADS];
+  atomic_t consumed = 0;
+  atomic_t start = 0;
+  int total;
+  int i;
+
+  ring_test_init(&g_mpmc_conc);
+
+  total = RING_TEST_ITEMS * RING_TEST_THREADS;
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      pctx[i].ring = &g_mpmc_conc;
+      pctx[i].items = RING_TEST_ITEMS;
+      pctx[i].start = &start;
+      pthread_create(&prod_threads[i], NULL,
+                     mpmc_producer_thread, &pctx[i]);
+    }
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      cctx[i].ring = &g_mpmc_conc;
+      cctx[i].consumed = &consumed;
+      cctx[i].total = total;
+      cctx[i].start = &start;
+      pthread_create(&cons_threads[i], NULL,
+                     mpmc_consumer_thread, &cctx[i]);
+    }
+
+  /* Signal all threads to start */
+
+  atomic_set(&start, 1);
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      pthread_join(prod_threads[i], NULL);
+    }
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      pthread_join(cons_threads[i], NULL);
+    }
+
+  assert_int_equal(atomic_read(&consumed), total);
+  assert_int_equal(rt_count(&g_mpmc_conc), 0);
+}
+
+/****************************************************************************
+ * Private Functions - Overwrite concurrent test
+ *
+ * MPMC overwrite: N overwrite-producer threads + N consumer threads.
+ * Producers continuously overwrite; consumers dequeue.
+ * Invariant: consumed <= produced, ring empty at end.
+ ****************************************************************************/
+
+struct mpmc_ow_prod_ctx_s
+{
+  FAR struct ring_test_s    *ring;
+  int                   items;
+  FAR atomic_t         *start;
+  FAR atomic_t         *produced;
+};
+
+struct mpmc_ow_cons_ctx_s
+{
+  FAR struct ring_test_s    *ring;
+  FAR atomic_t         *start;
+  FAR atomic_t         *consumed;
+  FAR atomic_t         *prod_done;
+};
+
+static FAR void *mpmc_ow_producer_thread(FAR void *arg)
+{
+  FAR struct mpmc_ow_prod_ctx_s *ctx =
+    (FAR struct mpmc_ow_prod_ctx_s *)arg;
+  uint32_t val;
+  int sent = 0;
+
+  while (atomic_read(ctx->start) == 0)
+    {
+      sched_yield();
+    }
+
+  while (sent < ctx->items)
+    {
+      val = (uint32_t)sent;
+      rt_mpmc_overwrite(ctx->ring, &val, 1);
+      atomic_add(ctx->produced, 1);
+      sent++;
+    }
+
+  return NULL;
+}
+
+static FAR void *mpmc_ow_consumer_thread(FAR void *arg)
+{
+  FAR struct mpmc_ow_cons_ctx_s *ctx =
+    (FAR struct mpmc_ow_cons_ctx_s *)arg;
+  uint32_t out = 0;
+
+  while (atomic_read(ctx->start) == 0)
+    {
+      sched_yield();
+    }
+
+  for (; ; )
+    {
+      if (rt_mpmc_dequeue(ctx->ring, &out, 1) == 1)
+        {
+          atomic_add(ctx->consumed, 1);
+        }
+      else if (atomic_read(ctx->prod_done) ==
+               RING_TEST_THREADS)
+        {
+          if (rt_mpmc_dequeue(ctx->ring, &out, 1) == 0)
+            {
+              break;
+            }
+
+          atomic_add(ctx->consumed, 1);
+        }
+      else
+        {
+          sched_yield();
+        }
+    }
+
+  return NULL;
+}
+
+static void test_mpmc_overwrite_concurrent(FAR void **state)
+{
+  struct mpmc_ow_prod_ctx_s pctx[RING_TEST_THREADS];
+  struct mpmc_ow_cons_ctx_s cctx[RING_TEST_THREADS];
+  pthread_t prod_threads[RING_TEST_THREADS];
+  pthread_t cons_threads[RING_TEST_THREADS];
+  atomic_t produced = 0;
+  atomic_t consumed = 0;
+  atomic_t prod_done = 0;
+  atomic_t start = 0;
+  int i;
+
+  ring_test_init(&g_mpmc_ow_conc);
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      pctx[i].ring = &g_mpmc_ow_conc;
+      pctx[i].items = RING_TEST_ITEMS;
+      pctx[i].start = &start;
+      pctx[i].produced = &produced;
+      pthread_create(&prod_threads[i], NULL,
+                     mpmc_ow_producer_thread, &pctx[i]);
+    }
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      cctx[i].ring = &g_mpmc_ow_conc;
+      cctx[i].start = &start;
+      cctx[i].consumed = &consumed;
+      cctx[i].prod_done = &prod_done;
+      pthread_create(&cons_threads[i], NULL,
+                     mpmc_ow_consumer_thread, &cctx[i]);
+    }
+
+  atomic_set(&start, 1);
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      pthread_join(prod_threads[i], NULL);
+      atomic_add(&prod_done, 1);
+    }
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      pthread_join(cons_threads[i], NULL);
+    }
+
+  assert_true(atomic_read(&consumed) <= atomic_read(&produced));
+  assert_int_equal(rt_count(&g_mpmc_ow_conc), 0);
+}
+
+/****************************************************************************
+ * Private Functions - Skip concurrent test
+ *
+ * MPMC skip: N producer threads + N skip-consumer threads.
+ * Producers enqueue normally; consumers use skip.
+ * Invariant: total_skipped == total_produced, ring empty at end.
+ ****************************************************************************/
+
+struct mpmc_skip_cons_ctx_s
+{
+  FAR struct ring_test_s    *ring;
+  FAR atomic_t         *start;
+  FAR atomic_t         *skipped;
+  FAR atomic_t         *prod_done;
+};
+
+static FAR void *mpmc_skip_consumer_thread(FAR void *arg)
+{
+  FAR struct mpmc_skip_cons_ctx_s *ctx =
+    (FAR struct mpmc_skip_cons_ctx_s *)arg;
+  uint32_t n;
+
+  while (atomic_read(ctx->start) == 0)
+    {
+      sched_yield();
+    }
+
+  for (; ; )
+    {
+      n = rt_mpmc_skip(ctx->ring, 1);
+      if (n > 0)
+        {
+          atomic_add(ctx->skipped, n);
+        }
+      else if (atomic_read(ctx->prod_done) ==
+               RING_TEST_THREADS)
+        {
+          n = rt_mpmc_skip(ctx->ring, 1);
+          if (n == 0)
+            {
+              break;
+            }
+
+          atomic_add(ctx->skipped, n);
+        }
+      else
+        {
+          sched_yield();
+        }
+    }
+
+  return NULL;
+}
+
+static void test_mpmc_skip_concurrent(FAR void **state)
+{
+  struct mpmc_prod_ctx_s pctx[RING_TEST_THREADS];
+  struct mpmc_skip_cons_ctx_s cctx[RING_TEST_THREADS];
+  pthread_t prod_threads[RING_TEST_THREADS];
+  pthread_t cons_threads[RING_TEST_THREADS];
+  atomic_t skipped = 0;
+  atomic_t prod_done = 0;
+  atomic_t start = 0;
+  int total;
+  int i;
+
+  ring_test_init(&g_mpmc_skip_conc);
+
+  total = RING_TEST_ITEMS * RING_TEST_THREADS;
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      pctx[i].ring = &g_mpmc_skip_conc;
+      pctx[i].items = RING_TEST_ITEMS;
+      pctx[i].start = &start;
+      pthread_create(&prod_threads[i], NULL,
+                     mpmc_producer_thread, &pctx[i]);
+    }
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      cctx[i].ring = &g_mpmc_skip_conc;
+      cctx[i].start = &start;
+      cctx[i].skipped = &skipped;
+      cctx[i].prod_done = &prod_done;
+      pthread_create(&cons_threads[i], NULL,
+                     mpmc_skip_consumer_thread, &cctx[i]);
+    }
+
+  atomic_set(&start, 1);
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      pthread_join(prod_threads[i], NULL);
+      atomic_add(&prod_done, 1);
+    }
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      pthread_join(cons_threads[i], NULL);
+    }
+
+  assert_int_equal(atomic_read(&skipped), total);
+  assert_int_equal(rt_count(&g_mpmc_skip_conc), 0);
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+static const struct CMUnitTest g_mpmc_local_tests[] =
+{
+  cmocka_unit_test(test_mpmc_basic),
+  cmocka_unit_test(test_mpmc_batch),
+  cmocka_unit_test(test_mpmc_full),
+  cmocka_unit_test(test_mpmc_typed_api),
+  cmocka_unit_test(test_mpmc_alloc_free),
+  cmocka_unit_test(test_mpmc_enqueue_dequeue_boundary),
+  cmocka_unit_test(test_mpmc_partial_batch),
+  cmocka_unit_test(test_mpmc_wraparound_batch),
+  cmocka_unit_test(test_mpmc_capacity_two),
+  cmocka_unit_test(test_mpmc_count_boundary),
+  cmocka_unit_test(test_mpmc_concurrent),
+  cmocka_unit_test(test_mpmc_overwrite_basic),
+  cmocka_unit_test(test_mpmc_overwrite_wrap),
+  cmocka_unit_test(test_mpmc_overwrite_batch),
+  cmocka_unit_test(test_mpmc_overwrite_exceed_cap),
+  cmocka_unit_test(test_mpmc_overwrite_not_full),
+  cmocka_unit_test(test_mpmc_dequeue_skip_basic),
+  cmocka_unit_test(test_mpmc_dequeue_skip_all),
+  cmocka_unit_test(test_mpmc_dequeue_skip_more_than_avail),
+  cmocka_unit_test(test_mpmc_dequeue_skip_empty),
+  cmocka_unit_test(test_mpmc_overwrite_concurrent),
+  cmocka_unit_test(test_mpmc_skip_concurrent),
+};
+
+int ring_test_mpmc_local(void)
+{
+  return cmocka_run_group_tests(g_mpmc_local_tests, NULL, NULL);
+}
diff --git a/testing/libc/ring/ring_mpsc.c b/testing/libc/ring/ring_mpsc.c
new file mode 100644
index 000000000..9c19e6b4c
--- /dev/null
+++ b/testing/libc/ring/ring_mpsc.c
@@ -0,0 +1,511 @@
+/****************************************************************************
+ * apps/testing/libc/ring/ring_mpsc.c
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.  The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); 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.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include "ring_test.h"
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/* Per-test static rings, kept off the test stack */
+
+RING_TEST_DEFINE(g_mpsc_basic, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_mpsc_batch, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_mpsc_full, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_mpsc_typed, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_mpsc_boundary, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_mpsc_partial, uint32_t, 8);
+RING_TEST_DEFINE(g_mpsc_wrap, uint32_t, 8);
+RING_TEST_DEFINE(g_mpsc_cap2, uint32_t, 2);
+RING_TEST_DEFINE(g_mpsc_count, uint32_t, 8);
+RING_TEST_DEFINE(g_mpsc_concurrent, uint32_t, RING_TEST_CAP);
+
+/****************************************************************************
+ * Private Functions - Single-core functional test
+ ****************************************************************************/
+
+static void test_mpsc_basic(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpsc_basic);
+
+  for (i = 0; i < 16; i++)
+    {
+      val = i + 300;
+      n = rt_mpsc_enqueue(&g_mpsc_basic, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  assert_int_equal(rt_count(&g_mpsc_basic), 16);
+
+  for (i = 0; i < 16; i++)
+    {
+      n = rt_mpsc_dequeue(&g_mpsc_basic, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i + 300);
+    }
+}
+
+static void test_mpsc_batch(FAR void **state)
+{
+  uint32_t buf[RING_TEST_BATCH];
+  uint32_t out[RING_TEST_BATCH];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpsc_batch);
+
+  for (i = 0; i < RING_TEST_BATCH; i++)
+    {
+      buf[i] = i + 200;
+    }
+
+  n = rt_mpsc_enqueue(&g_mpsc_batch, buf, RING_TEST_BATCH);
+  assert_int_equal(n, RING_TEST_BATCH);
+  n = rt_mpsc_dequeue(&g_mpsc_batch, out, RING_TEST_BATCH);
+  assert_int_equal(n, RING_TEST_BATCH);
+
+  for (i = 0; i < RING_TEST_BATCH; i++)
+    {
+      assert_int_equal(out[i], i + 200);
+    }
+}
+
+static void test_mpsc_full(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpsc_full);
+
+  for (i = 0; i < RING_TEST_CAP; i++)
+    {
+      val = i;
+      n = rt_mpsc_enqueue(&g_mpsc_full, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  val = 999;
+  n = rt_mpsc_enqueue(&g_mpsc_full, &val, 1);
+  assert_int_equal(n, 0);
+
+  for (i = 0; i < RING_TEST_CAP; i++)
+    {
+      n = rt_mpsc_dequeue(&g_mpsc_full, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i);
+    }
+
+  assert_int_equal(rt_count(&g_mpsc_full), 0);
+}
+
+static void test_mpsc_typed_api(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t batch[4];
+  uint32_t obatch[4];
+  uint32_t n;
+  uint32_t i;
+
+  ring_test_init(&g_mpsc_typed);
+
+  val = 42;
+  n = rt_mpsc_enqueue(&g_mpsc_typed, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_mpsc_dequeue(&g_mpsc_typed, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 42);
+
+  for (i = 0; i < 4; i++)
+    {
+      batch[i] = i + 500;
+    }
+
+  n = rt_mpsc_enqueue(&g_mpsc_typed, batch, 4);
+  assert_int_equal(n, 4);
+  n = rt_mpsc_dequeue(&g_mpsc_typed, obatch, 4);
+  assert_int_equal(n, 4);
+
+  for (i = 0; i < 4; i++)
+    {
+      assert_int_equal(obatch[i], i + 500);
+    }
+}
+
+static void test_mpsc_alloc_free(FAR void **state)
+{
+  struct ring_test_s t;
+  FAR struct ring_test_s *r = &t;
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+
+  assert_non_null(ring_test_alloc(r, RING_TEST_CAP, sizeof(uint32_t)));
+
+  val = 77;
+  n = rt_mpsc_enqueue(r, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_mpsc_dequeue(r, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 77);
+
+  ring_free(r->r);
+}
+
+/****************************************************************************
+ * Private Functions - Boundary condition tests (MP enqueue, SC dequeue)
+ ****************************************************************************/
+
+static void test_mpsc_enqueue_dequeue_boundary(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpsc_boundary);
+
+  /* Dequeue from empty ring */
+
+  n = rt_mpsc_dequeue(&g_mpsc_boundary, &out, 1);
+  assert_int_equal(n, 0);
+
+  /* Enqueue count=0 */
+
+  val = 42;
+  n = rt_mpsc_enqueue(&g_mpsc_boundary, &val, 0);
+  assert_int_equal(n, 0);
+  assert_int_equal(rt_count(&g_mpsc_boundary), 0);
+
+  /* Dequeue count=0 */
+
+  n = rt_mpsc_dequeue(&g_mpsc_boundary, &out, 0);
+  assert_int_equal(n, 0);
+
+  /* Fill ring, then try one more (MP CAS path) */
+
+  for (i = 0; i < RING_TEST_CAP; i++)
+    {
+      val = i;
+      n = rt_mpsc_enqueue(&g_mpsc_boundary, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  assert_int_equal(rt_count(&g_mpsc_boundary), RING_TEST_CAP);
+
+  val = 999;
+  n = rt_mpsc_enqueue(&g_mpsc_boundary, &val, 1);
+  assert_int_equal(n, 0);
+}
+
+static void test_mpsc_partial_batch(FAR void **state)
+{
+  uint32_t buf[16];
+  uint32_t out[16];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpsc_partial);
+
+  /* Batch enqueue larger than capacity */
+
+  for (i = 0; i < 16; i++)
+    {
+      buf[i] = i + 1;
+    }
+
+  n = rt_mpsc_enqueue(&g_mpsc_partial, buf, 16);
+  assert_int_equal(n, 8);
+  assert_int_equal(rt_count(&g_mpsc_partial), 8);
+
+  /* Batch dequeue larger than available */
+
+  n = rt_mpsc_dequeue(&g_mpsc_partial, out, 16);
+  assert_int_equal(n, 8);
+
+  for (i = 0; i < 8; i++)
+    {
+      assert_int_equal(out[i], i + 1);
+    }
+
+  /* Partial enqueue when partially full */
+
+  for (i = 0; i < 6; i++)
+    {
+      buf[i] = i + 100;
+    }
+
+  n = rt_mpsc_enqueue(&g_mpsc_partial, buf, 6);
+  assert_int_equal(n, 6);
+
+  for (i = 0; i < 4; i++)
+    {
+      buf[i] = i + 200;
+    }
+
+  n = rt_mpsc_enqueue(&g_mpsc_partial, buf, 4);
+  assert_int_equal(n, 2);
+  assert_int_equal(rt_count(&g_mpsc_partial), 8);
+
+  n = rt_mpsc_dequeue(&g_mpsc_partial, out, 8);
+  assert_int_equal(n, 8);
+  assert_int_equal(rt_count(&g_mpsc_partial), 0);
+}
+
+static void test_mpsc_wraparound_batch(FAR void **state)
+{
+  uint32_t buf[8];
+  uint32_t out[8];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_mpsc_wrap);
+
+  /* Advance indices to force wraparound */
+
+  for (i = 0; i < 6; i++)
+    {
+      buf[i] = i;
+    }
+
+  n = rt_mpsc_enqueue(&g_mpsc_wrap, buf, 6);
+  assert_int_equal(n, 6);
+  n = rt_mpsc_dequeue(&g_mpsc_wrap, out, 6);
+  assert_int_equal(n, 6);
+
+  /* Enqueue 8 items wrapping around (MP CAS path) */
+
+  for (i = 0; i < 8; i++)
+    {
+      buf[i] = i + 1000;
+    }
+
+  n = rt_mpsc_enqueue(&g_mpsc_wrap, buf, 8);
+  assert_int_equal(n, 8);
+
+  memset(out, 0, sizeof(out));
+  n = rt_mpsc_dequeue(&g_mpsc_wrap, out, 8);
+  assert_int_equal(n, 8);
+
+  for (i = 0; i < 8; i++)
+    {
+      assert_int_equal(out[i], i + 1000);
+    }
+}
+
+static void test_mpsc_capacity_two(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+
+  ring_test_init(&g_mpsc_cap2);
+
+  assert_int_equal(rt_capacity(&g_mpsc_cap2), 2);
+
+  val = 10;
+  n = rt_mpsc_enqueue(&g_mpsc_cap2, &val, 1);
+  assert_int_equal(n, 1);
+
+  val = 20;
+  n = rt_mpsc_enqueue(&g_mpsc_cap2, &val, 1);
+  assert_int_equal(n, 1);
+
+  /* Full */
+
+  val = 30;
+  n = rt_mpsc_enqueue(&g_mpsc_cap2, &val, 1);
+  assert_int_equal(n, 0);
+
+  n = rt_mpsc_dequeue(&g_mpsc_cap2, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 10);
+
+  n = rt_mpsc_dequeue(&g_mpsc_cap2, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 20);
+
+  /* Empty */
+
+  n = rt_mpsc_dequeue(&g_mpsc_cap2, &out, 1);
+  assert_int_equal(n, 0);
+}
+
+static void test_mpsc_count_boundary(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out[8];
+  uint32_t i;
+
+  ring_test_init(&g_mpsc_count);
+
+  assert_int_equal(rt_count(&g_mpsc_count), 0);
+
+  for (i = 0; i < 3; i++)
+    {
+      val = i;
+      rt_mpsc_enqueue(&g_mpsc_count, &val, 1);
+    }
+
+  assert_int_equal(rt_count(&g_mpsc_count), 3);
+
+  for (i = 3; i < 8; i++)
+    {
+      val = i;
+      rt_mpsc_enqueue(&g_mpsc_count, &val, 1);
+    }
+
+  assert_int_equal(rt_count(&g_mpsc_count), 8);
+
+  rt_mpsc_dequeue(&g_mpsc_count, out, 1);
+  assert_int_equal(rt_count(&g_mpsc_count), 7);
+
+  rt_mpsc_dequeue(&g_mpsc_count, out, 7);
+  assert_int_equal(rt_count(&g_mpsc_count), 0);
+}
+
+/****************************************************************************
+ * Private Functions - Single-core multi-thread concurrent test
+ *
+ * MPSC: multiple producer threads + main thread as single consumer.
+ * Uses pthread + sched_yield() for single-core safety.
+ ****************************************************************************/
+
+struct mpsc_thread_ctx_s
+{
+  FAR struct ring_test_s *ring;
+  int items;
+  atomic_t *start;
+};
+
+static FAR void *mpsc_producer_thread(FAR void *arg)
+{
+  FAR struct mpsc_thread_ctx_s *ctx = (FAR struct mpsc_thread_ctx_s *)arg;
+  uint32_t val;
+  int sent = 0;
+
+  /* Wait for start signal */
+
+  while (atomic_read(ctx->start) == 0)
+    {
+      sched_yield();
+    }
+
+  while (sent < ctx->items)
+    {
+      val = (uint32_t)sent;
+      if (rt_mpsc_enqueue(ctx->ring, &val, 1) == 1)
+        {
+          sent++;
+        }
+      else
+        {
+          sched_yield();
+        }
+    }
+
+  return NULL;
+}
+
+static void test_mpsc_concurrent(FAR void **state)
+{
+  struct mpsc_thread_ctx_s ctx[RING_TEST_THREADS];
+  pthread_t threads[RING_TEST_THREADS];
+  atomic_t start = 0;
+  uint32_t out = 0;
+  int total;
+  int received = 0;
+  int i;
+
+  ring_test_init(&g_mpsc_concurrent);
+
+  total = RING_TEST_ITEMS * RING_TEST_THREADS;
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      ctx[i].ring = &g_mpsc_concurrent;
+      ctx[i].items = RING_TEST_ITEMS;
+      ctx[i].start = &start;
+      pthread_create(&threads[i], NULL, mpsc_producer_thread, &ctx[i]);
+    }
+
+  /* Signal all producers to start */
+
+  atomic_set(&start, 1);
+
+  /* Main thread: single consumer */
+
+  while (received < total)
+    {
+      if (rt_mpsc_dequeue(&g_mpsc_concurrent, &out, 1) == 1)
+        {
+          received++;
+        }
+      else
+        {
+          sched_yield();
+        }
+    }
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      pthread_join(threads[i], NULL);
+    }
+
+  assert_int_equal(received, total);
+  assert_int_equal(rt_count(&g_mpsc_concurrent), 0);
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+static const struct CMUnitTest g_mpsc_local_tests[] =
+{
+  cmocka_unit_test(test_mpsc_basic),
+  cmocka_unit_test(test_mpsc_batch),
+  cmocka_unit_test(test_mpsc_full),
+  cmocka_unit_test(test_mpsc_typed_api),
+  cmocka_unit_test(test_mpsc_alloc_free),
+  cmocka_unit_test(test_mpsc_enqueue_dequeue_boundary),
+  cmocka_unit_test(test_mpsc_partial_batch),
+  cmocka_unit_test(test_mpsc_wraparound_batch),
+  cmocka_unit_test(test_mpsc_capacity_two),
+  cmocka_unit_test(test_mpsc_count_boundary),
+  cmocka_unit_test(test_mpsc_concurrent),
+};
+
+int ring_test_mpsc_local(void)
+{
+  return cmocka_run_group_tests(g_mpsc_local_tests, NULL, NULL);
+}
diff --git a/testing/libc/ring/ring_spmc.c b/testing/libc/ring/ring_spmc.c
new file mode 100644
index 000000000..93d34e7d0
--- /dev/null
+++ b/testing/libc/ring/ring_spmc.c
@@ -0,0 +1,520 @@
+/****************************************************************************
+ * apps/testing/libc/ring/ring_spmc.c
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.  The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); 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.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include "ring_test.h"
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+RING_TEST_DEFINE(g_spmc_basic, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_spmc_batch, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_spmc_full, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_spmc_typed, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_spmc_boundary, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_spmc_partial, uint32_t, 8);
+RING_TEST_DEFINE(g_spmc_wrap, uint32_t, 8);
+RING_TEST_DEFINE(g_spmc_cap2, uint32_t, 2);
+RING_TEST_DEFINE(g_spmc_count, uint32_t, 8);
+RING_TEST_DEFINE(g_spmc_concurrent, uint32_t, RING_TEST_CAP);
+
+/****************************************************************************
+ * Private Functions - Single-core functional test
+ ****************************************************************************/
+
+static void test_spmc_basic(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spmc_basic);
+
+  for (i = 0; i < 16; i++)
+    {
+      val = i + 400;
+      n = rt_spmc_enqueue(&g_spmc_basic, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  assert_int_equal(rt_count(&g_spmc_basic), 16);
+
+  for (i = 0; i < 16; i++)
+    {
+      n = rt_spmc_dequeue(&g_spmc_basic, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i + 400);
+    }
+}
+
+static void test_spmc_batch(FAR void **state)
+{
+  uint32_t buf[RING_TEST_BATCH];
+  uint32_t out[RING_TEST_BATCH];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spmc_batch);
+
+  for (i = 0; i < RING_TEST_BATCH; i++)
+    {
+      buf[i] = i + 200;
+    }
+
+  n = rt_spmc_enqueue(&g_spmc_batch, buf, RING_TEST_BATCH);
+  assert_int_equal(n, RING_TEST_BATCH);
+  n = rt_spmc_dequeue(&g_spmc_batch, out, RING_TEST_BATCH);
+  assert_int_equal(n, RING_TEST_BATCH);
+
+  for (i = 0; i < RING_TEST_BATCH; i++)
+    {
+      assert_int_equal(out[i], i + 200);
+    }
+}
+
+static void test_spmc_full(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spmc_full);
+
+  for (i = 0; i < RING_TEST_CAP; i++)
+    {
+      val = i;
+      n = rt_spmc_enqueue(&g_spmc_full, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  val = 999;
+  n = rt_spmc_enqueue(&g_spmc_full, &val, 1);
+  assert_int_equal(n, 0);
+
+  for (i = 0; i < RING_TEST_CAP; i++)
+    {
+      n = rt_spmc_dequeue(&g_spmc_full, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i);
+    }
+
+  assert_int_equal(rt_count(&g_spmc_full), 0);
+}
+
+static void test_spmc_typed_api(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t batch[4];
+  uint32_t obatch[4];
+  uint32_t n;
+  uint32_t i;
+
+  ring_test_init(&g_spmc_typed);
+
+  val = 42;
+  n = rt_spmc_enqueue(&g_spmc_typed, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_spmc_dequeue(&g_spmc_typed, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 42);
+
+  for (i = 0; i < 4; i++)
+    {
+      batch[i] = i + 500;
+    }
+
+  n = rt_spmc_enqueue(&g_spmc_typed, batch, 4);
+  assert_int_equal(n, 4);
+  n = rt_spmc_dequeue(&g_spmc_typed, obatch, 4);
+  assert_int_equal(n, 4);
+
+  for (i = 0; i < 4; i++)
+    {
+      assert_int_equal(obatch[i], i + 500);
+    }
+}
+
+static void test_spmc_alloc_free(FAR void **state)
+{
+  struct ring_test_s t;
+  FAR struct ring_test_s *r = &t;
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+
+  assert_non_null(ring_test_alloc(r, RING_TEST_CAP, sizeof(uint32_t)));
+
+  val = 77;
+  n = rt_spmc_enqueue(r, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_spmc_dequeue(r, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 77);
+
+  ring_free(r->r);
+}
+
+/****************************************************************************
+ * Private Functions - Boundary condition tests (SP enqueue, MC dequeue)
+ ****************************************************************************/
+
+static void test_spmc_enqueue_dequeue_boundary(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spmc_boundary);
+
+  /* Dequeue from empty ring (MC CAS path) */
+
+  n = rt_spmc_dequeue(&g_spmc_boundary, &out, 1);
+  assert_int_equal(n, 0);
+
+  /* Enqueue count=0 */
+
+  val = 42;
+  n = rt_spmc_enqueue(&g_spmc_boundary, &val, 0);
+  assert_int_equal(n, 0);
+  assert_int_equal(rt_count(&g_spmc_boundary), 0);
+
+  /* Dequeue count=0 */
+
+  n = rt_spmc_dequeue(&g_spmc_boundary, &out, 0);
+  assert_int_equal(n, 0);
+
+  /* Fill ring, then try one more */
+
+  for (i = 0; i < RING_TEST_CAP; i++)
+    {
+      val = i;
+      n = rt_spmc_enqueue(&g_spmc_boundary, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  assert_int_equal(rt_count(&g_spmc_boundary), RING_TEST_CAP);
+
+  val = 999;
+  n = rt_spmc_enqueue(&g_spmc_boundary, &val, 1);
+  assert_int_equal(n, 0);
+}
+
+static void test_spmc_partial_batch(FAR void **state)
+{
+  uint32_t buf[16];
+  uint32_t out[16];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spmc_partial);
+
+  /* Batch enqueue larger than capacity */
+
+  for (i = 0; i < 16; i++)
+    {
+      buf[i] = i + 1;
+    }
+
+  n = rt_spmc_enqueue(&g_spmc_partial, buf, 16);
+  assert_int_equal(n, 8);
+
+  /* Batch dequeue larger than available (MC CAS path) */
+
+  n = rt_spmc_dequeue(&g_spmc_partial, out, 16);
+  assert_int_equal(n, 8);
+
+  for (i = 0; i < 8; i++)
+    {
+      assert_int_equal(out[i], i + 1);
+    }
+
+  /* Partial enqueue when partially full */
+
+  for (i = 0; i < 6; i++)
+    {
+      buf[i] = i + 100;
+    }
+
+  n = rt_spmc_enqueue(&g_spmc_partial, buf, 6);
+  assert_int_equal(n, 6);
+
+  for (i = 0; i < 4; i++)
+    {
+      buf[i] = i + 200;
+    }
+
+  n = rt_spmc_enqueue(&g_spmc_partial, buf, 4);
+  assert_int_equal(n, 2);
+  assert_int_equal(rt_count(&g_spmc_partial), 8);
+
+  /* Partial dequeue (MC CAS path) */
+
+  n = rt_spmc_dequeue(&g_spmc_partial, out, 5);
+  assert_int_equal(n, 5);
+  assert_int_equal(rt_count(&g_spmc_partial), 3);
+
+  n = rt_spmc_dequeue(&g_spmc_partial, out, 3);
+  assert_int_equal(n, 3);
+  assert_int_equal(rt_count(&g_spmc_partial), 0);
+}
+
+static void test_spmc_wraparound_batch(FAR void **state)
+{
+  uint32_t buf[8];
+  uint32_t out[8];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spmc_wrap);
+
+  /* Advance indices to force wraparound */
+
+  for (i = 0; i < 6; i++)
+    {
+      buf[i] = i;
+    }
+
+  n = rt_spmc_enqueue(&g_spmc_wrap, buf, 6);
+  assert_int_equal(n, 6);
+  n = rt_spmc_dequeue(&g_spmc_wrap, out, 6);
+  assert_int_equal(n, 6);
+
+  /* Enqueue 8 items wrapping around */
+
+  for (i = 0; i < 8; i++)
+    {
+      buf[i] = i + 1000;
+    }
+
+  n = rt_spmc_enqueue(&g_spmc_wrap, buf, 8);
+  assert_int_equal(n, 8);
+
+  /* Dequeue wrapping around (MC CAS path) */
+
+  memset(out, 0, sizeof(out));
+  n = rt_spmc_dequeue(&g_spmc_wrap, out, 8);
+  assert_int_equal(n, 8);
+
+  for (i = 0; i < 8; i++)
+    {
+      assert_int_equal(out[i], i + 1000);
+    }
+}
+
+static void test_spmc_capacity_two(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+
+  ring_test_init(&g_spmc_cap2);
+
+  assert_int_equal(rt_capacity(&g_spmc_cap2), 2);
+
+  val = 10;
+  n = rt_spmc_enqueue(&g_spmc_cap2, &val, 1);
+  assert_int_equal(n, 1);
+
+  val = 20;
+  n = rt_spmc_enqueue(&g_spmc_cap2, &val, 1);
+  assert_int_equal(n, 1);
+
+  /* Full */
+
+  val = 30;
+  n = rt_spmc_enqueue(&g_spmc_cap2, &val, 1);
+  assert_int_equal(n, 0);
+
+  /* MC dequeue */
+
+  n = rt_spmc_dequeue(&g_spmc_cap2, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 10);
+
+  n = rt_spmc_dequeue(&g_spmc_cap2, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 20);
+
+  /* Empty */
+
+  n = rt_spmc_dequeue(&g_spmc_cap2, &out, 1);
+  assert_int_equal(n, 0);
+}
+
+static void test_spmc_count_boundary(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out[8];
+  uint32_t i;
+
+  ring_test_init(&g_spmc_count);
+
+  assert_int_equal(rt_count(&g_spmc_count), 0);
+
+  for (i = 0; i < 3; i++)
+    {
+      val = i;
+      rt_spmc_enqueue(&g_spmc_count, &val, 1);
+    }
+
+  assert_int_equal(rt_count(&g_spmc_count), 3);
+
+  for (i = 3; i < 8; i++)
+    {
+      val = i;
+      rt_spmc_enqueue(&g_spmc_count, &val, 1);
+    }
+
+  assert_int_equal(rt_count(&g_spmc_count), 8);
+
+  rt_spmc_dequeue(&g_spmc_count, out, 1);
+  assert_int_equal(rt_count(&g_spmc_count), 7);
+
+  rt_spmc_dequeue(&g_spmc_count, out, 7);
+  assert_int_equal(rt_count(&g_spmc_count), 0);
+}
+
+/****************************************************************************
+ * Private Functions - Single-core multi-thread concurrent test
+ *
+ * SPMC: main thread as single producer + multiple consumer threads.
+ * Uses pthread + sched_yield() for single-core safety.
+ ****************************************************************************/
+
+struct spmc_thread_ctx_s
+{
+  FAR struct ring_test_s *ring;
+  FAR atomic_t *consumed;
+  int total;
+  atomic_t *start;
+};
+
+static FAR void *spmc_consumer_thread(FAR void *arg)
+{
+  FAR struct spmc_thread_ctx_s *ctx = (FAR struct spmc_thread_ctx_s *)arg;
+  uint32_t out = 0;
+
+  /* Wait for start signal */
+
+  while (atomic_read(ctx->start) == 0)
+    {
+      sched_yield();
+    }
+
+  while (atomic_read(ctx->consumed) < ctx->total)
+    {
+      if (rt_spmc_dequeue(ctx->ring, &out, 1) == 1)
+        {
+          atomic_add(ctx->consumed, 1);
+        }
+      else
+        {
+          sched_yield();
+        }
+    }
+
+  return NULL;
+}
+
+static void test_spmc_concurrent(FAR void **state)
+{
+  struct spmc_thread_ctx_s ctx[RING_TEST_THREADS];
+  pthread_t threads[RING_TEST_THREADS];
+  atomic_t consumed = 0;
+  atomic_t start = 0;
+  uint32_t val;
+  int total;
+  int sent = 0;
+  int i;
+
+  ring_test_init(&g_spmc_concurrent);
+
+  total = RING_TEST_ITEMS;
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      ctx[i].ring = &g_spmc_concurrent;
+      ctx[i].consumed = &consumed;
+      ctx[i].total = total;
+      ctx[i].start = &start;
+      pthread_create(&threads[i], NULL, spmc_consumer_thread, &ctx[i]);
+    }
+
+  /* Signal all consumers to start */
+
+  atomic_set(&start, 1);
+
+  /* Main thread: single producer */
+
+  while (sent < total)
+    {
+      val = (uint32_t)sent;
+      if (rt_spmc_enqueue(&g_spmc_concurrent, &val, 1) == 1)
+        {
+          sent++;
+        }
+      else
+        {
+          sched_yield();
+        }
+    }
+
+  for (i = 0; i < RING_TEST_THREADS; i++)
+    {
+      pthread_join(threads[i], NULL);
+    }
+
+  assert_int_equal(atomic_read(&consumed), total);
+  assert_int_equal(rt_count(&g_spmc_concurrent), 0);
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+static const struct CMUnitTest g_spmc_local_tests[] =
+{
+  cmocka_unit_test(test_spmc_basic),
+  cmocka_unit_test(test_spmc_batch),
+  cmocka_unit_test(test_spmc_full),
+  cmocka_unit_test(test_spmc_typed_api),
+  cmocka_unit_test(test_spmc_alloc_free),
+  cmocka_unit_test(test_spmc_enqueue_dequeue_boundary),
+  cmocka_unit_test(test_spmc_partial_batch),
+  cmocka_unit_test(test_spmc_wraparound_batch),
+  cmocka_unit_test(test_spmc_capacity_two),
+  cmocka_unit_test(test_spmc_count_boundary),
+  cmocka_unit_test(test_spmc_concurrent),
+};
+
+int ring_test_spmc_local(void)
+{
+  return cmocka_run_group_tests(g_spmc_local_tests, NULL, NULL);
+}
diff --git a/testing/libc/ring/ring_spsc.c b/testing/libc/ring/ring_spsc.c
new file mode 100644
index 000000000..c1a9e5484
--- /dev/null
+++ b/testing/libc/ring/ring_spsc.c
@@ -0,0 +1,1462 @@
+/****************************************************************************
+ * apps/testing/libc/ring/ring_spsc.c
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.  The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); 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.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include "ring_test.h"
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+struct large_elem
+{
+  uint32_t a;
+  uint32_t b;
+  uint64_t c;
+  char     name[16];
+};
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/* Per-test rings (moved from stack to avoid overflow on embedded) */
+
+RING_TEST_DEFINE(g_spsc_basic, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_spsc_batch, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_spsc_full, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_spsc_typed, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_spsc_boundary, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_spsc_partial, uint32_t, 8);
+RING_TEST_DEFINE(g_spsc_wrap, uint32_t, 8);
+RING_TEST_DEFINE(g_spsc_cap2, uint32_t, 2);
+RING_TEST_DEFINE(g_spsc_large, struct large_elem, 8);
+RING_TEST_DEFINE(g_spsc_count, uint32_t, 8);
+RING_TEST_DEFINE(g_spsc_concurrent, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_spsc_init, uint32_t, RING_TEST_CAP);
+RING_TEST_DEFINE(g_spsc_ow, uint32_t, 8);
+RING_TEST_DEFINE(g_spsc_ow_wrap, uint32_t, 8);
+RING_TEST_DEFINE(g_spsc_ow_batch, uint32_t, 8);
+RING_TEST_DEFINE(g_spsc_ow_cap, uint32_t, 8);
+
+/* Per-test large element arrays */
+
+static struct large_elem g_large_batch_in[8];
+static struct large_elem g_large_batch_out[8];
+
+/****************************************************************************
+ * Private Functions - Single-core functional tests
+ ****************************************************************************/
+
+static void test_spsc_basic(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_basic);
+
+  assert_int_equal(rt_count(&g_spsc_basic), 0);
+  assert_int_equal(rt_capacity(&g_spsc_basic), RING_TEST_CAP);
+  n = rt_spsc_dequeue(&g_spsc_basic, &out, 1);
+  assert_int_equal(n, 0);
+
+  for (i = 0; i < 32; i++)
+    {
+      val = i + 100;
+      n = rt_spsc_enqueue(&g_spsc_basic, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  assert_int_equal(rt_count(&g_spsc_basic), 32);
+
+  for (i = 0; i < 32; i++)
+    {
+      n = rt_spsc_dequeue(&g_spsc_basic, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i + 100);
+    }
+
+  assert_int_equal(rt_count(&g_spsc_basic), 0);
+}
+
+static void test_spsc_batch(FAR void **state)
+{
+  uint32_t buf[RING_TEST_BATCH];
+  uint32_t out[RING_TEST_BATCH];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_batch);
+
+  for (i = 0; i < RING_TEST_BATCH; i++)
+    {
+      buf[i] = i + 200;
+    }
+
+  n = rt_spsc_enqueue(&g_spsc_batch, buf, RING_TEST_BATCH);
+  assert_int_equal(n, RING_TEST_BATCH);
+  n = rt_spsc_dequeue(&g_spsc_batch, out, RING_TEST_BATCH);
+  assert_int_equal(n, RING_TEST_BATCH);
+
+  for (i = 0; i < RING_TEST_BATCH; i++)
+    {
+      assert_int_equal(out[i], i + 200);
+    }
+}
+
+static void test_spsc_full(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_full);
+
+  for (i = 0; i < RING_TEST_CAP; i++)
+    {
+      val = i;
+      n = rt_spsc_enqueue(&g_spsc_full, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  val = 999;
+  n = rt_spsc_enqueue(&g_spsc_full, &val, 1);
+  assert_int_equal(n, 0);
+
+  for (i = 0; i < RING_TEST_CAP / 2; i++)
+    {
+      n = rt_spsc_dequeue(&g_spsc_full, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i);
+    }
+
+  for (i = 0; i < RING_TEST_CAP / 2; i++)
+    {
+      val = i + 1000;
+      n = rt_spsc_enqueue(&g_spsc_full, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  for (i = 0; i < RING_TEST_CAP / 2; i++)
+    {
+      n = rt_spsc_dequeue(&g_spsc_full, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i + RING_TEST_CAP / 2);
+    }
+
+  for (i = 0; i < RING_TEST_CAP / 2; i++)
+    {
+      n = rt_spsc_dequeue(&g_spsc_full, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i + 1000);
+    }
+
+  assert_int_equal(rt_count(&g_spsc_full), 0);
+}
+
+static void test_spsc_typed_api(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t batch[4];
+  uint32_t obatch[4];
+  uint32_t n;
+  uint32_t i;
+
+  ring_test_init(&g_spsc_typed);
+
+  val = 42;
+  n = rt_spsc_enqueue(&g_spsc_typed, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_spsc_dequeue(&g_spsc_typed, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 42);
+
+  for (i = 0; i < 4; i++)
+    {
+      batch[i] = i + 500;
+    }
+
+  n = rt_spsc_enqueue(&g_spsc_typed, batch, 4);
+  assert_int_equal(n, 4);
+  n = rt_spsc_dequeue(&g_spsc_typed, obatch, 4);
+  assert_int_equal(n, 4);
+
+  for (i = 0; i < 4; i++)
+    {
+      assert_int_equal(obatch[i], i + 500);
+    }
+}
+
+static void test_spsc_alloc_free(FAR void **state)
+{
+  struct ring_test_s t;
+  FAR struct ring_test_s *r = &t;
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+
+  assert_non_null(ring_test_alloc(r, RING_TEST_CAP, sizeof(uint32_t)));
+
+  val = 77;
+  n = rt_spsc_enqueue(r, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_spsc_dequeue(r, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 77);
+
+  ring_free(r->r);
+}
+
+/****************************************************************************
+ * Private Functions - ring_alloc tests
+ ****************************************************************************/
+
+static void test_ring_alloc_valid(FAR void **state)
+{
+  struct ring_test_s t;
+  FAR struct ring_test_s *r = &t;
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+
+  assert_non_null(ring_test_alloc(r, 16, sizeof(uint32_t)));
+  assert_int_equal(rt_capacity(r), 16);
+  assert_int_equal(rt_count(r), 0);
+
+  val = 123;
+  n = rt_spsc_enqueue(r, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_spsc_dequeue(r, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 123);
+
+  ring_free(r->r);
+}
+
+static void test_ring_alloc_invalid(FAR void **state)
+{
+  assert_null(ring_alloc(0));
+}
+
+static void test_ring_alloc_non_pow2(FAR void **state)
+{
+  static const uint32_t caps[] =
+  {
+    3, 5, 6, 7, 9, 10
+  };
+
+  struct ring_test_s t;
+  FAR struct ring_test_s *r = &t;
+  uint32_t val;
+  uint32_t out;
+  uint32_t i;
+  uint32_t j;
+
+  for (i = 0; i < nitems(caps); i++)
+    {
+      assert_non_null(ring_test_alloc(r, caps[i], sizeof(uint32_t)));
+      assert_int_equal(rt_capacity(r), caps[i]);
+
+      /* Two full passes, so the indices wrap at least once */
+
+      for (j = 0; j < 2 * caps[i]; j++)
+        {
+          val = j;
+          assert_int_equal(rt_spsc_enqueue(r, &val, 1), 1);
+          assert_int_equal(rt_spsc_dequeue(r, &out, 1), 1);
+          assert_int_equal(out, j);
+        }
+
+      ring_free(r->r);
+    }
+}
+
+/****************************************************************************
+ * Private Functions - Enqueue/dequeue boundary tests
+ ****************************************************************************/
+
+static void test_enqueue_dequeue_boundary(FAR void **state)
+{
+  uint32_t out = 0;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_boundary);
+
+  /* Dequeue from empty ring */
+
+  n = rt_spsc_dequeue(&g_spsc_boundary, &out, 1);
+  assert_int_equal(n, 0);
+
+  /* Enqueue count=0 */
+
+  uint32_t val = 42;
+  n = rt_spsc_enqueue(&g_spsc_boundary, &val, 0);
+  assert_int_equal(n, 0);
+  assert_int_equal(rt_count(&g_spsc_boundary), 0);
+
+  /* Dequeue count=0 */
+
+  n = rt_spsc_dequeue(&g_spsc_boundary, &out, 0);
+  assert_int_equal(n, 0);
+
+  /* Enqueue to full ring, then try one more */
+
+  uint32_t i;
+  for (i = 0; i < RING_TEST_CAP; i++)
+    {
+      val = i;
+      n = rt_spsc_enqueue(&g_spsc_boundary, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  assert_int_equal(rt_count(&g_spsc_boundary), RING_TEST_CAP);
+
+  val = 999;
+  n = rt_spsc_enqueue(&g_spsc_boundary, &val, 1);
+  assert_int_equal(n, 0);
+}
+
+static void test_partial_batch(FAR void **state)
+{
+  uint32_t buf[16];
+  uint32_t out[16];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_partial);
+
+  /* Batch enqueue larger than capacity: should partial enqueue */
+
+  for (i = 0; i < 16; i++)
+    {
+      buf[i] = i + 1;
+    }
+
+  n = rt_spsc_enqueue(&g_spsc_partial, buf, 16);
+  assert_int_equal(n, 8);
+  assert_int_equal(rt_count(&g_spsc_partial), 8);
+
+  /* Batch dequeue larger than available: should partial dequeue */
+
+  n = rt_spsc_dequeue(&g_spsc_partial, out, 16);
+  assert_int_equal(n, 8);
+
+  for (i = 0; i < 8; i++)
+    {
+      assert_int_equal(out[i], i + 1);
+    }
+
+  assert_int_equal(rt_count(&g_spsc_partial), 0);
+
+  /* Partial enqueue when partially full */
+
+  for (i = 0; i < 6; i++)
+    {
+      buf[i] = i + 100;
+    }
+
+  n = rt_spsc_enqueue(&g_spsc_partial, buf, 6);
+  assert_int_equal(n, 6);
+
+  /* Try to enqueue 4 more, only 2 should fit */
+
+  for (i = 0; i < 4; i++)
+    {
+      buf[i] = i + 200;
+    }
+
+  n = rt_spsc_enqueue(&g_spsc_partial, buf, 4);
+  assert_int_equal(n, 2);
+  assert_int_equal(rt_count(&g_spsc_partial), 8);
+
+  /* Partial dequeue: request 5, get 5 */
+
+  n = rt_spsc_dequeue(&g_spsc_partial, out, 5);
+  assert_int_equal(n, 5);
+  assert_int_equal(rt_count(&g_spsc_partial), 3);
+}
+
+static void test_wraparound_batch(FAR void **state)
+{
+  uint32_t buf[8];
+  uint32_t out[8];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_wrap);
+
+  /* Fill ring to advance head/tail indices */
+
+  for (i = 0; i < 6; i++)
+    {
+      buf[i] = i;
+    }
+
+  n = rt_spsc_enqueue(&g_spsc_wrap, buf, 6);
+  assert_int_equal(n, 6);
+  n = rt_spsc_dequeue(&g_spsc_wrap, out, 6);
+  assert_int_equal(n, 6);
+
+  /* Now head/tail are at index 6. Enqueue 8 items wraps around. */
+
+  for (i = 0; i < 8; i++)
+    {
+      buf[i] = i + 1000;
+    }
+
+  n = rt_spsc_enqueue(&g_spsc_wrap, buf, 8);
+  assert_int_equal(n, 8);
+
+  memset(out, 0, sizeof(out));
+  n = rt_spsc_dequeue(&g_spsc_wrap, out, 8);
+  assert_int_equal(n, 8);
+
+  for (i = 0; i < 8; i++)
+    {
+      assert_int_equal(out[i], i + 1000);
+    }
+}
+
+static void test_capacity_two(FAR void **state)
+{
+  /* Smallest ring exercised: 2 items */
+
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_cap2);
+
+  assert_int_equal(rt_capacity(&g_spsc_cap2), 2);
+  assert_int_equal(rt_count(&g_spsc_cap2), 0);
+
+  val = 10;
+  n = rt_spsc_enqueue(&g_spsc_cap2, &val, 1);
+  assert_int_equal(n, 1);
+
+  val = 20;
+  n = rt_spsc_enqueue(&g_spsc_cap2, &val, 1);
+  assert_int_equal(n, 1);
+
+  /* Full */
+
+  val = 30;
+  n = rt_spsc_enqueue(&g_spsc_cap2, &val, 1);
+  assert_int_equal(n, 0);
+
+  n = rt_spsc_dequeue(&g_spsc_cap2, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 10);
+
+  n = rt_spsc_dequeue(&g_spsc_cap2, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 20);
+
+  /* Empty */
+
+  n = rt_spsc_dequeue(&g_spsc_cap2, &out, 1);
+  assert_int_equal(n, 0);
+}
+
+static void test_large_elem(FAR void **state)
+{
+  struct large_elem in;
+  struct large_elem out;
+  uint32_t n;
+  uint32_t i;
+
+  ring_test_init(&g_spsc_large);
+
+  /* Single element */
+
+  memset(&in, 0, sizeof(in));
+  in.a = 1;
+  in.b = 2;
+  in.c = 0xdeadbeefcafe0000ull;
+  strlcpy(in.name, "hello", sizeof(in.name));
+
+  n = rt_spsc_enqueue(&g_spsc_large, &in, 1);
+  assert_int_equal(n, 1);
+
+  memset(&out, 0, sizeof(out));
+  n = rt_spsc_dequeue(&g_spsc_large, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out.a, 1);
+  assert_int_equal(out.b, 2);
+  assert_true(out.c == 0xdeadbeefcafe0000ull);
+  assert_string_equal(out.name, "hello");
+
+  /* Batch with wraparound */
+
+  /* Advance indices to force wraparound */
+
+  for (i = 0; i < 5; i++)
+    {
+      memset(&in, 0, sizeof(in));
+      in.a = i;
+      rt_spsc_enqueue(&g_spsc_large, &in, 1);
+    }
+
+  rt_spsc_dequeue(&g_spsc_large, g_large_batch_out, 5);
+
+  /* Now enqueue 8 items (wraps around) */
+
+  for (i = 0; i < 8; i++)
+    {
+      memset(&g_large_batch_in[i], 0, sizeof(g_large_batch_in[i]));
+      g_large_batch_in[i].a = i + 100;
+      g_large_batch_in[i].b = i + 200;
+      g_large_batch_in[i].c = (uint64_t)i * 1000;
+    }
+
+  n = rt_spsc_enqueue(&g_spsc_large, g_large_batch_in, 8);
+  assert_int_equal(n, 8);
+
+  memset(g_large_batch_out, 0, sizeof(g_large_batch_out));
+  n = rt_spsc_dequeue(&g_spsc_large, g_large_batch_out, 8);
+  assert_int_equal(n, 8);
+
+  for (i = 0; i < 8; i++)
+    {
+      assert_int_equal(g_large_batch_out[i].a, i + 100);
+      assert_int_equal(g_large_batch_out[i].b, i + 200);
+      assert_true(g_large_batch_out[i].c == (uint64_t)i * 1000);
+    }
+}
+
+static void test_ring_count_boundary(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out[8];
+  uint32_t i;
+
+  ring_test_init(&g_spsc_count);
+
+  /* Empty */
+
+  assert_int_equal(rt_count(&g_spsc_count), 0);
+
+  /* Partially filled */
+
+  for (i = 0; i < 3; i++)
+    {
+      val = i;
+      rt_spsc_enqueue(&g_spsc_count, &val, 1);
+    }
+
+  assert_int_equal(rt_count(&g_spsc_count), 3);
+
+  /* Full */
+
+  for (i = 3; i < 8; i++)
+    {
+      val = i;
+      rt_spsc_enqueue(&g_spsc_count, &val, 1);
+    }
+
+  assert_int_equal(rt_count(&g_spsc_count), 8);
+
+  /* Dequeue one: count should be 7 */
+
+  rt_spsc_dequeue(&g_spsc_count, out, 1);
+  assert_int_equal(rt_count(&g_spsc_count), 7);
+
+  /* Drain all */
+
+  rt_spsc_dequeue(&g_spsc_count, out, 7);
+  assert_int_equal(rt_count(&g_spsc_count), 0);
+}
+
+static void test_ring_alloc_all_modes(FAR void **state)
+{
+  struct ring_test_s t;
+  FAR struct ring_test_s *r = &t;
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+
+  /* Test ring_alloc with MPSC mode */
+
+  assert_non_null(ring_test_alloc(r, 8, sizeof(uint32_t)));
+
+  val = 1;
+  n = rt_mpsc_enqueue(r, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_spsc_dequeue(r, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 1);
+  ring_free(r->r);
+
+  /* Test ring_alloc with SPMC mode */
+
+  assert_non_null(ring_test_alloc(r, 8, sizeof(uint32_t)));
+
+  val = 2;
+  n = rt_spsc_enqueue(r, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_mpmc_dequeue(r, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 2);
+  ring_free(r->r);
+
+  /* Test ring_alloc with MPMC mode */
+
+  assert_non_null(ring_test_alloc(r, 8, sizeof(uint32_t)));
+
+  val = 3;
+  n = rt_mpsc_enqueue(r, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_mpmc_dequeue(r, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 3);
+  ring_free(r->r);
+}
+
+/****************************************************************************
+ * Private Functions - init magic / warm-restart tests
+ ****************************************************************************/
+
+/* A reboot leaves the blob as it was and clears the handle, which lives
+ * in ordinary RAM: forget the handle, then init again on the same blob.
+ */
+
+static void ring_test_reboot(FAR struct ring_test_s *t)
+{
+  memset(t->r, 0, sizeof(*t->r));
+}
+
+static void test_init_fresh(FAR void **state)
+{
+  FAR struct ring_test_s *r = &g_spsc_init;
+  FAR struct ring_blob_s *blob = (FAR struct ring_blob_s *)r->blob;
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+
+  ring_test_init(r);
+
+  assert_true(ring_is_ready(r->r));
+  assert_int_equal(blob->magic, RING_BLOB_MAGIC_READY);
+  assert_int_equal(rt_capacity(r), RING_TEST_CAP);
+  assert_int_equal(rt_count(r), 0);
+
+  val = 42;
+  n = rt_spsc_enqueue(r, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_spsc_dequeue(r, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 42);
+}
+
+static void test_init_warm_restart_recovery(FAR void **state)
+{
+  FAR struct ring_test_s *r = &g_spsc_init;
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+  uint32_t i;
+
+  ring_test_init(r);
+  for (i = 0; i < 16; i++)
+    {
+      val = i + 500;
+      rt_spsc_enqueue(r, &val, 1);
+    }
+
+  for (i = 0; i < 8; i++)
+    {
+      rt_spsc_dequeue(r, &out, 1);
+    }
+
+  assert_int_equal(rt_count(r), 8);
+
+  ring_test_reboot(r);
+  ring_mpmc_init(r->r, r->blob, r->size, 0);
+
+  assert_true(ring_is_ready(r->r));
+  assert_int_equal(rt_count(r), 8);
+
+  for (i = 0; i < 8; i++)
+    {
+      n = rt_spsc_dequeue(r, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i + 508);
+    }
+
+  assert_int_equal(rt_count(r), 0);
+}
+
+static void test_init_warm_restart_rewind(FAR void **state)
+{
+  FAR struct ring_test_s *r = &g_spsc_init;
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+
+  ring_test_init(r);
+  for (i = 0; i < 16; i++)
+    {
+      val = i + 500;
+      rt_spsc_enqueue(r, &val, 1);
+    }
+
+  for (i = 0; i < 8; i++)
+    {
+      rt_spsc_dequeue(r, &out, 1);
+    }
+
+  /* Replay the last 3 items consumed before the reboot */
+
+  ring_test_reboot(r);
+  ring_mpmc_init(r->r, r->blob, r->size, RT_BYTES(r, 3));
+
+  assert_int_equal(rt_count(r), 11);
+
+  for (i = 0; i < 11; i++)
+    {
+      assert_int_equal(rt_spsc_dequeue(r, &out, 1), 1);
+      assert_int_equal(out, i + 505);
+    }
+}
+
+static void test_init_warm_restart_corrupt(FAR void **state)
+{
+  FAR struct ring_test_s *r = &g_spsc_init;
+  FAR struct ring_blob_s *blob = (FAR struct ring_blob_s *)r->blob;
+  uint32_t val = 99;
+  uint32_t out = 0;
+  uint32_t n;
+
+  /* READY blob whose indices claim more data than the ring can hold */
+
+  ring_test_init(r);
+  ring_test_reboot(r);
+  atomic_set(&blob->prod_tail,
+             RTS_PACK(0, RT_BYTES(r, RING_TEST_CAP + 10)));
+  atomic_set(&blob->cons_tail, RTS_PACK(0, 0));
+
+  ring_mpmc_init(r->r, r->blob, r->size, 0);
+
+  assert_true(ring_is_ready(r->r));
+  assert_int_equal(rt_count(r), 0);
+
+  n = rt_spsc_enqueue(r, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_spsc_dequeue(r, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 99);
+}
+
+static void test_init_warm_restart_cnt_reset(FAR void **state)
+{
+  /* A reboot in the middle of an MPMC enqueue leaves head.cnt !=
+   * tail.cnt; unless init zeroes the counters, tail can never catch head
+   * again and the next MP commit spins forever.
+   */
+
+  FAR struct ring_test_s *r = &g_spsc_init;
+  FAR struct ring_blob_s *blob = (FAR struct ring_blob_s *)r->blob;
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+  uint32_t i;
+
+  ring_test_init(r);
+  ring_test_reboot(r);
+  atomic_set(&blob->prod_head, RTS_PACK(3, RT_BYTES(r, 5)));
+  atomic_set(&blob->prod_tail, RTS_PACK(1, RT_BYTES(r, 5)));
+  atomic_set(&blob->cons_head, RTS_PACK(2, 0));
+  atomic_set(&blob->cons_tail, RTS_PACK(0, 0));
+
+  ring_mpmc_init(r->r, r->blob, r->size, 0);
+
+  assert_int_equal(RTS_CNT(atomic_read(&blob->prod_head)), 0);
+  assert_int_equal(RTS_CNT(atomic_read(&blob->prod_tail)), 0);
+  assert_int_equal(RTS_CNT(atomic_read(&blob->cons_head)), 0);
+  assert_int_equal(RTS_CNT(atomic_read(&blob->cons_tail)), 0);
+
+  assert_int_equal(RTS_IDX(atomic_read(&blob->prod_tail)),
+                   RT_BYTES(r, 5));
+  assert_int_equal(RTS_IDX(atomic_read(&blob->cons_tail)), 0);
+  assert_int_equal(rt_count(r), 5);
+
+  for (i = 0; i < 4; i++)
+    {
+      val = i + 900;
+      n = rt_mpmc_enqueue(r, &val, 1);
+      assert_int_equal(n, 1);
+    }
+
+  assert_int_equal(rt_count(r), 9);
+
+  rt_mpmc_skip(r, 5);
+
+  for (i = 0; i < 4; i++)
+    {
+      n = rt_mpmc_dequeue(r, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i + 900);
+    }
+
+  assert_int_equal(rt_count(r), 0);
+}
+
+static void test_init_garbage_magic(FAR void **state)
+{
+  FAR struct ring_test_s *r = &g_spsc_init;
+  FAR struct ring_blob_s *blob = (FAR struct ring_blob_s *)r->blob;
+
+  ring_test_reboot(r);
+  atomic_set(&blob->magic, (int32_t)0xdeadbeef);
+  atomic_set(&blob->prod_tail, RTS_PACK(3, 100));
+  atomic_set(&blob->cons_tail, RTS_PACK(1, 50));
+
+  ring_mpmc_init(r->r, r->blob, r->size, 0);
+
+  assert_int_equal(atomic_read(&blob->magic), RING_BLOB_MAGIC_READY);
+  assert_int_equal(rt_count(r), 0);
+}
+
+static void test_init_geometry_mismatch(FAR void **state)
+{
+  FAR struct ring_test_s *r = &g_spsc_init;
+  uint32_t val = 7;
+
+  /* A READY blob left by a build with a different size is not reused */
+
+  ring_test_init(r);
+  rt_spsc_enqueue(r, &val, 1);
+
+  ring_test_reboot(r);
+  ring_mpmc_init(r->r, r->blob, r->size - RT_BYTES(r, 1), 0);
+
+  assert_int_equal(rt_capacity(r), RING_TEST_CAP - 1);
+  assert_int_equal(rt_count(r), 0);
+}
+
+static void test_init_double_call(FAR void **state)
+{
+  /* A second init in the same boot must not reset a ring in use */
+
+  FAR struct ring_test_s *r = &g_spsc_init;
+  uint32_t val = 77;
+  uint32_t out = 0;
+  uint32_t n;
+
+  ring_test_init(r);
+  n = rt_spsc_enqueue(r, &val, 1);
+  assert_int_equal(n, 1);
+
+  assert_false(ring_mpmc_init(r->r, r->blob, r->size, 0));
+  assert_int_equal(ring_spsc_init(r->r, r->blob, r->size, 0, false), OK);
+  assert_int_equal(rt_count(r), 1);
+
+  n = rt_spsc_dequeue(r, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 77);
+}
+
+static void test_init_spsc_slave(FAR void **state)
+{
+  FAR struct ring_test_s *r = &g_spsc_init;
+  struct ring_s slave;
+  uint32_t val = 55;
+  uint32_t out = 0;
+
+  memset(&slave, 0, sizeof(slave));
+  memset(r->blob, 0, sizeof(struct ring_blob_s));
+  memset(r->r, 0, sizeof(*r->r));
+
+  /* The slave never initializes the blob, it waits for the master */
+
+  assert_int_equal(ring_spsc_init(&slave, r->blob, r->size, 0, true),
+                   -EAGAIN);
+  assert_false(ring_is_ready(&slave));
+
+  assert_int_equal(ring_spsc_init(r->r, r->blob, r->size, 0, false), OK);
+  assert_int_equal(ring_spsc_init(&slave, r->blob, r->size - 1, 0, true),
+                   -EINVAL);
+  assert_int_equal(ring_spsc_init(&slave, r->blob, r->size, 0, true), OK);
+
+  assert_int_equal(ring_spsc_enqueue(r->r, &val, sizeof(val)),
+                   sizeof(val));
+  assert_int_equal(ring_spsc_dequeue(&slave, &out, sizeof(out)),
+                   sizeof(out));
+  assert_int_equal(out, 55);
+}
+
+static void test_init_alloc_warm_restart(FAR void **state)
+{
+  struct ring_test_s t;
+  FAR struct ring_test_s *r = &t;
+  FAR struct ring_s *alloc;
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+  uint32_t i;
+
+  alloc = ring_test_alloc(r, 16, sizeof(uint32_t));
+  assert_non_null(alloc);
+
+  for (i = 0; i < 10; i++)
+    {
+      val = i + 300;
+      rt_spsc_enqueue(r, &val, 1);
+    }
+
+  for (i = 0; i < 4; i++)
+    {
+      rt_spsc_dequeue(r, &out, 1);
+    }
+
+  assert_int_equal(rt_count(r), 6);
+
+  /* Rebind a fresh handle to the allocated blob, as after a reboot */
+
+  memset(&r->handle, 0, sizeof(r->handle));
+  r->r = &r->handle;
+  ring_mpmc_init(r->r, alloc->blob, r->size, 0);
+
+  assert_int_equal(rt_count(r), 6);
+
+  for (i = 0; i < 6; i++)
+    {
+      n = rt_spsc_dequeue(r, &out, 1);
+      assert_int_equal(n, 1);
+      assert_int_equal(out, i + 304);
+    }
+
+  ring_free(alloc);
+}
+
+struct init_thread_ctx_s
+{
+  FAR struct ring_test_s *ring;
+  FAR atomic_t *go;
+  FAR atomic_t *first_count;
+  FAR atomic_t *done_count;
+};
+
+static FAR void *init_thread_func(FAR void *arg)
+{
+  FAR struct init_thread_ctx_s *ctx =
+    (FAR struct init_thread_ctx_s *)arg;
+  struct ring_s handle;
+
+  memset(&handle, 0, sizeof(handle));
+
+  while (atomic_read(ctx->go) == 0)
+    {
+      sched_yield();
+    }
+
+  if (ring_mpmc_init(&handle, ctx->ring->blob, ctx->ring->size, 0))
+    {
+      atomic_add(ctx->first_count, 1);
+    }
+
+  if (ring_is_ready(&handle))
+    {
+      atomic_add(ctx->done_count, 1);
+    }
+
+  return NULL;
+}
+
+static void test_init_concurrent(FAR void **state)
+{
+  /* Each thread binds its own handle to the same cold blob: exactly one
+   * of them may run the init body.
+   */
+
+  FAR struct ring_test_s *r = &g_spsc_init;
+  struct init_thread_ctx_s ctx;
+  pthread_t threads[4];
+  atomic_t go = 0;
+  atomic_t first_count = 0;
+  atomic_t done_count = 0;
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t n;
+  int i;
+
+  memset(r->blob, 0, sizeof(struct ring_blob_s));
+
+  ctx.ring = r;
+  ctx.go = &go;
+  ctx.first_count = &first_count;
+  ctx.done_count = &done_count;
+
+  for (i = 0; i < 4; i++)
+    {
+      pthread_create(&threads[i], NULL, init_thread_func, &ctx);
+    }
+
+  atomic_set(&go, 1);
+
+  for (i = 0; i < 4; i++)
+    {
+      pthread_join(threads[i], NULL);
+    }
+
+  assert_int_equal(atomic_read(&first_count), 1);
+  assert_int_equal(atomic_read(&done_count), 4);
+
+  ring_test_reboot(r);
+  ring_mpmc_init(r->r, r->blob, r->size, 0);
+  assert_int_equal(rt_count(r), 0);
+
+  val = 123;
+  n = rt_spsc_enqueue(r, &val, 1);
+  assert_int_equal(n, 1);
+  n = rt_spsc_dequeue(r, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 123);
+}
+
+/****************************************************************************
+ * Private Functions - Overwrite enqueue tests
+ ****************************************************************************/
+
+static void test_spsc_overwrite_basic(FAR void **state)
+{
+  uint32_t out[8];
+  uint32_t val;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_ow);
+
+  /* Fill ring to capacity */
+
+  for (i = 0; i < 8; i++)
+    {
+      val = i;
+      rt_spmc_overwrite(&g_spsc_ow, &val, 1);
+    }
+
+  assert_int_equal(rt_count(&g_spsc_ow), 8);
+
+  /* Overwrite: push one more, oldest (0) should be discarded */
+
+  val = 100;
+  n = rt_spmc_overwrite(&g_spsc_ow, &val, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(rt_count(&g_spsc_ow), 8);
+
+  /* Dequeue all: expect 1,2,3,4,5,6,7,100 */
+
+  n = rt_spmc_dequeue(&g_spsc_ow, out, 8);
+  assert_int_equal(n, 8);
+  for (i = 0; i < 7; i++)
+    {
+      assert_int_equal(out[i], i + 1);
+    }
+
+  assert_int_equal(out[7], 100);
+}
+
+static void test_spsc_overwrite_wrap(FAR void **state)
+{
+  uint32_t out[8];
+  uint32_t val;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_ow_wrap);
+
+  /* Advance indices to force wraparound */
+
+  for (i = 0; i < 6; i++)
+    {
+      val = i;
+      rt_spmc_overwrite(&g_spsc_ow_wrap, &val, 1);
+    }
+
+  rt_spmc_dequeue(&g_spsc_ow_wrap, out, 6);
+
+  /* Now fill ring (indices start at 6, wraps at 8) */
+
+  for (i = 0; i < 8; i++)
+    {
+      val = i + 10;
+      rt_spmc_overwrite(&g_spsc_ow_wrap, &val, 1);
+    }
+
+  /* Overwrite 3 more: discards 10,11,12 */
+
+  for (i = 0; i < 3; i++)
+    {
+      val = i + 200;
+      rt_spmc_overwrite(&g_spsc_ow_wrap, &val, 1);
+    }
+
+  assert_int_equal(rt_count(&g_spsc_ow_wrap), 8);
+
+  n = rt_spmc_dequeue(&g_spsc_ow_wrap, out, 8);
+  assert_int_equal(n, 8);
+
+  /* Expect: 13,14,15,16,17,200,201,202 */
+
+  for (i = 0; i < 5; i++)
+    {
+      assert_int_equal(out[i], i + 13);
+    }
+
+  for (i = 0; i < 3; i++)
+    {
+      assert_int_equal(out[i + 5], i + 200);
+    }
+}
+
+static void test_spsc_overwrite_batch(FAR void **state)
+{
+  uint32_t in[8];
+  uint32_t out[8];
+  uint32_t val;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_ow_batch);
+
+  /* Fill with 0..7 */
+
+  for (i = 0; i < 8; i++)
+    {
+      val = i;
+      rt_spmc_overwrite(&g_spsc_ow_batch, &val, 1);
+    }
+
+  /* Batch overwrite 4 items: discards 0,1,2,3 */
+
+  for (i = 0; i < 4; i++)
+    {
+      in[i] = i + 100;
+    }
+
+  n = rt_spmc_overwrite(&g_spsc_ow_batch, in, 4);
+  assert_int_equal(n, 4);
+  assert_int_equal(rt_count(&g_spsc_ow_batch), 8);
+
+  n = rt_spmc_dequeue(&g_spsc_ow_batch, out, 8);
+  assert_int_equal(n, 8);
+
+  /* Expect: 4,5,6,7,100,101,102,103 */
+
+  for (i = 0; i < 4; i++)
+    {
+      assert_int_equal(out[i], i + 4);
+    }
+
+  for (i = 0; i < 4; i++)
+    {
+      assert_int_equal(out[i + 4], i + 100);
+    }
+}
+
+static void test_spsc_overwrite_exceed_cap(FAR void **state)
+{
+  uint32_t in[16];
+  uint32_t out[8];
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_ow_cap);
+
+  /* Enqueue 16 items into cap=8 ring: only last 8 should remain */
+
+  for (i = 0; i < 16; i++)
+    {
+      in[i] = i;
+    }
+
+  n = rt_spmc_overwrite(&g_spsc_ow_cap, in, 16);
+  assert_int_equal(n, 8);
+  assert_int_equal(rt_count(&g_spsc_ow_cap), 8);
+
+  n = rt_spmc_dequeue(&g_spsc_ow_cap, out, 8);
+  assert_int_equal(n, 8);
+
+  /* Expect: 8,9,10,11,12,13,14,15 */
+
+  for (i = 0; i < 8; i++)
+    {
+      assert_int_equal(out[i], i + 8);
+    }
+}
+
+static void test_spsc_overwrite_not_full(FAR void **state)
+{
+  uint32_t out[8];
+  uint32_t val;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_ow);
+
+  /* Partially fill (4 of 8) */
+
+  for (i = 0; i < 4; i++)
+    {
+      val = i;
+      rt_spmc_overwrite(&g_spsc_ow, &val, 1);
+    }
+
+  /* Overwrite enqueue when not full: should behave like normal */
+
+  val = 99;
+  n = rt_spmc_overwrite(&g_spsc_ow, &val, 1);
+  assert_int_equal(n, 0);
+  assert_int_equal(rt_count(&g_spsc_ow), 5);
+
+  n = rt_spmc_dequeue(&g_spsc_ow, out, 5);
+  assert_int_equal(n, 5);
+  for (i = 0; i < 4; i++)
+    {
+      assert_int_equal(out[i], i);
+    }
+
+  assert_int_equal(out[4], 99);
+}
+
+/****************************************************************************
+ * Private Functions - Dequeue skip tests
+ ****************************************************************************/
+
+static void test_spsc_dequeue_skip_basic(FAR void **state)
+{
+  uint32_t val;
+  uint32_t out = 0;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_ow);
+
+  /* Fill with 0..7 */
+
+  for (i = 0; i < 8; i++)
+    {
+      val = i;
+      rt_spsc_enqueue(&g_spsc_ow, &val, 1);
+    }
+
+  /* Skip first 3 */
+
+  n = rt_spsc_skip(&g_spsc_ow, 3);
+  assert_int_equal(n, 3);
+  assert_int_equal(rt_count(&g_spsc_ow), 5);
+
+  /* Next dequeue should return 3 */
+
+  n = rt_spsc_dequeue(&g_spsc_ow, &out, 1);
+  assert_int_equal(n, 1);
+  assert_int_equal(out, 3);
+}
+
+static void test_spsc_dequeue_skip_all(FAR void **state)
+{
+  uint32_t val;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_ow);
+
+  for (i = 0; i < 8; i++)
+    {
+      val = i;
+      rt_spsc_enqueue(&g_spsc_ow, &val, 1);
+    }
+
+  /* Skip all */
+
+  n = rt_spsc_skip(&g_spsc_ow, 8);
+  assert_int_equal(n, 8);
+  assert_int_equal(rt_count(&g_spsc_ow), 0);
+}
+
+static void test_spsc_dequeue_skip_more_than_avail(FAR void **state)
+{
+  uint32_t val;
+  uint32_t i;
+  uint32_t n;
+
+  ring_test_init(&g_spsc_ow);
+
+  for (i = 0; i < 4; i++)
+    {
+      val = i;
+      rt_spsc_enqueue(&g_spsc_ow, &val, 1);
+    }
+
+  /* Try to skip 8, only 4 available */
+
+  n = rt_spsc_skip(&g_spsc_ow, 8);
+  assert_int_equal(n, 4);
+  assert_int_equal(rt_count(&g_spsc_ow), 0);
+}
+
+static void test_spsc_dequeue_skip_empty(FAR void **state)
+{
+  uint32_t n;
+
+  ring_test_init(&g_spsc_ow);
+
+  n = rt_spsc_skip(&g_spsc_ow, 5);
+  assert_int_equal(n, 0);
+}
+
+/****************************************************************************
+ * Private Functions - Single-core multi-thread concurrent test
+ *
+ * SPSC: 1 producer thread + main thread as consumer.
+ * Uses pthread + sched_yield() for single-core safety.
+ ****************************************************************************/
+
+struct spsc_thread_ctx_s
+{
+  FAR struct ring_test_s *ring;
+  int items;
+  atomic_t *start;
+};
+
+static FAR void *spsc_producer_thread(FAR void *arg)
+{
+  FAR struct spsc_thread_ctx_s *ctx =
+    (FAR struct spsc_thread_ctx_s *)arg;
+  uint32_t val;
+  int sent = 0;
+
+  while (atomic_read(ctx->start) == 0)
+    {
+      sched_yield();
+    }
+
+  while (sent < ctx->items)
+    {
+      val = (uint32_t)sent;
+      if (rt_spsc_enqueue(ctx->ring, &val, 1) == 1)
+        {
+          sent++;
+        }
+      else
+        {
+          sched_yield();
+        }
+    }
+
+  return NULL;
+}
+
+static void test_spsc_concurrent(FAR void **state)
+{
+  struct spsc_thread_ctx_s ctx;
+  pthread_t thread;
+  atomic_t start = 0;
+  uint32_t out = 0;
+  int received = 0;
+
+  ring_test_init(&g_spsc_concurrent);
+
+  ctx.ring = &g_spsc_concurrent;
+  ctx.items = RING_TEST_ITEMS;
+  ctx.start = &start;
+  pthread_create(&thread, NULL, spsc_producer_thread, &ctx);
+
+  /* Signal producer to start */
+
+  atomic_set(&start, 1);
+
+  /* Main thread: single consumer */
+
+  while (received < RING_TEST_ITEMS)
+    {
+      if (rt_spsc_dequeue(&g_spsc_concurrent, &out, 1) == 1)
+        {
+          assert_int_equal(out, (uint32_t)received);
+          received++;
+        }
+      else
+        {
+          sched_yield();
+        }
+    }
+
+  pthread_join(thread, NULL);
+  assert_int_equal(received, RING_TEST_ITEMS);
+  assert_int_equal(rt_count(&g_spsc_concurrent), 0);
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+static const struct CMUnitTest g_spsc_local_tests[] =
+{
+  cmocka_unit_test(test_spsc_basic),
+  cmocka_unit_test(test_spsc_batch),
+  cmocka_unit_test(test_spsc_full),
+  cmocka_unit_test(test_spsc_typed_api),
+  cmocka_unit_test(test_spsc_alloc_free),
+  cmocka_unit_test(test_ring_alloc_valid),
+  cmocka_unit_test(test_ring_alloc_invalid),
+  cmocka_unit_test(test_ring_alloc_all_modes),
+  cmocka_unit_test(test_ring_alloc_non_pow2),
+  cmocka_unit_test(test_enqueue_dequeue_boundary),
+  cmocka_unit_test(test_partial_batch),
+  cmocka_unit_test(test_wraparound_batch),
+  cmocka_unit_test(test_capacity_two),
+  cmocka_unit_test(test_large_elem),
+  cmocka_unit_test(test_ring_count_boundary),
+  cmocka_unit_test(test_init_fresh),
+  cmocka_unit_test(test_init_warm_restart_recovery),
+  cmocka_unit_test(test_init_warm_restart_rewind),
+  cmocka_unit_test(test_init_warm_restart_corrupt),
+  cmocka_unit_test(test_init_warm_restart_cnt_reset),
+  cmocka_unit_test(test_init_garbage_magic),
+  cmocka_unit_test(test_init_geometry_mismatch),
+  cmocka_unit_test(test_init_double_call),
+  cmocka_unit_test(test_init_spsc_slave),
+  cmocka_unit_test(test_init_alloc_warm_restart),
+  cmocka_unit_test(test_init_concurrent),
+  cmocka_unit_test(test_spsc_concurrent),
+  cmocka_unit_test(test_spsc_overwrite_basic),
+  cmocka_unit_test(test_spsc_overwrite_wrap),
+  cmocka_unit_test(test_spsc_overwrite_batch),
+  cmocka_unit_test(test_spsc_overwrite_exceed_cap),
+  cmocka_unit_test(test_spsc_overwrite_not_full),
+  cmocka_unit_test(test_spsc_dequeue_skip_basic),
+  cmocka_unit_test(test_spsc_dequeue_skip_all),
+  cmocka_unit_test(test_spsc_dequeue_skip_more_than_avail),
+  cmocka_unit_test(test_spsc_dequeue_skip_empty),
+};
+
+int ring_test_spsc_local(void)
+{
+  return cmocka_run_group_tests(g_spsc_local_tests, NULL, NULL);
+}
diff --git a/testing/libc/ring/ring_test.h b/testing/libc/ring/ring_test.h
new file mode 100644
index 000000000..765334741
--- /dev/null
+++ b/testing/libc/ring/ring_test.h
@@ -0,0 +1,176 @@
+/****************************************************************************
+ * apps/testing/libc/ring/ring_test.h
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.  The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); 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.
+ *
+ ****************************************************************************/
+
+#ifndef __APPS_TESTING_LIBC_RING_RING_TEST_H
+#define __APPS_TESTING_LIBC_RING_RING_TEST_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+#include <nuttx/ring.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <stdint.h>
+#include <pthread.h>
+#include <sched.h>
+#include <sys/param.h>
+#include <unistd.h>
+
+#include <cmocka.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+#define RING_TEST_CAP       64
+#define RING_TEST_ITEMS     1024
+#define RING_TEST_BATCH     8
+#define RING_TEST_THREADS   2
+
+/* The ring counts bytes while the cases count items, so each test ring
+ * records its item size and the rt_ wrappers convert both ways.
+ */
+
+#define RING_TEST_DEFINE(name, type, cap) \
+  static char name##_blob[sizeof(struct ring_blob_s) + \
+                          (cap) * sizeof(type)] \
+              aligned_data(RING_BLOB_ALIGN); \
+  static struct ring_test_s name = \
+  { \
+    .r    = &name.handle, \
+    .blob = name##_blob, \
+    .size = sizeof(name##_blob), \
+    .elem = sizeof(type), \
+  }
+
+#define RT_BYTES(t, n)  ((uint32_t)(n) * (t)->elem)
+#define RT_ITEMS(t, b)  ((uint32_t)(b) / (t)->elem)
+
+#define RT_IO(name, op) \
+  static inline uint32_t name(FAR struct ring_test_s *t, \
+                              FAR void *items, uint32_t n) \
+  { \
+    return RT_ITEMS(t, op(t->r, items, RT_BYTES(t, n))); \
+  }
+
+#define RT_SKIP(name, op) \
+  static inline uint32_t name(FAR struct ring_test_s *t, uint32_t n) \
+  { \
+    return RT_ITEMS(t, op(t->r, RT_BYTES(t, n))); \
+  }
+
+#define rt_count(t)               RT_ITEMS(t, ring_count((t)->r))
+#define rt_capacity(t)            RT_ITEMS(t, ring_capacity((t)->r))
+#define rt_reset(t)               ((void)ring_reset((t)->r))
+
+/****************************************************************************
+ * Public Types
+ ****************************************************************************/
+
+struct ring_test_s
+{
+  FAR struct ring_s *r;          /* Handle in use: &handle or ring_alloc */
+  struct ring_s      handle;
+  FAR char          *blob;
+  uint32_t           size;       /* Whole blob, header included */
+  uint32_t           elem;       /* Item size in bytes */
+};
+
+/****************************************************************************
+ * Inline Functions - item-count wrappers
+ ****************************************************************************/
+
+RT_IO(rt_spsc_enqueue, ring_spsc_enqueue)
+RT_IO(rt_spsc_dequeue, ring_spsc_dequeue)
+RT_IO(rt_mpsc_enqueue, ring_mpsc_enqueue)
+RT_IO(rt_mpsc_dequeue, ring_mpsc_dequeue)
+RT_IO(rt_spmc_enqueue, ring_spmc_enqueue)
+RT_IO(rt_spmc_dequeue, ring_spmc_dequeue)
+RT_IO(rt_mpmc_enqueue, ring_mpmc_enqueue)
+RT_IO(rt_mpmc_dequeue, ring_mpmc_dequeue)
+
+/* Overwrite returns the items that did not stay in the ring */
+
+RT_IO(rt_spmc_overwrite, ring_spmc_overwrite)
+RT_IO(rt_mpmc_overwrite, ring_mpmc_overwrite)
+
+RT_SKIP(rt_spsc_skip, ring_spsc_skip)
+RT_SKIP(rt_mpmc_skip, ring_mpmc_skip)
+
+/****************************************************************************
+ * Public Function Prototypes
+ ****************************************************************************/
+
+int ring_test_spsc_local(void);
+int ring_test_mpsc_local(void);
+int ring_test_spmc_local(void);
+int ring_test_mpmc_local(void);
+
+/****************************************************************************
+ * Inline Functions - test ring helpers
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: ring_test_init
+ *
+ * Description:
+ *   Cold-start a test ring.  Both magics are cleared first: a READY blob
+ *   would be recovered as a warm restart, and a READY handle makes init
+ *   return without touching the blob.
+ *
+ ****************************************************************************/
+
+static inline void ring_test_init(FAR struct ring_test_s *t)
+{
+  memset(t->r, 0, sizeof(*t->r));
+  memset(t->blob, 0, sizeof(struct ring_blob_s));
+  ring_spsc_init(t->r, t->blob, t->size, 0, false);
+}
+
+/****************************************************************************
+ * Name: ring_test_alloc
+ *
+ * Description:
+ *   Wrap a ring_alloc() ring holding cap items of elem bytes.  Free it
+ *   with ring_free(t->r).
+ *
+ ****************************************************************************/
+
+static inline FAR struct ring_s *ring_test_alloc(FAR struct ring_test_s *t,
+                                                 uint32_t cap,
+                                                 uint32_t elem)
+{
+  t->elem = elem;
+  t->size = sizeof(struct ring_blob_s) + cap * elem;
+  t->blob = NULL;
+  t->r = ring_alloc(t->size);
+  return t->r;
+}
+
+#endif /* __APPS_TESTING_LIBC_RING_RING_TEST_H */

Reply via email to