tests: lib: rust: Add 'time' test

Add a test to test that the time values in Rust (Duration and Instance)
and up calculating the same results as the various macros used in the C
code.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

tests/lib/rust/time/CMakeLists.txt

@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(time_rust)
+
+target_sources(app PRIVATE src/times.c)
+
+rust_cargo_application()

tests/lib/rust/time/Cargo.toml

@@ -0,0 +1,16 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+# This must be rustapp for now.
+name = "rustapp"
+version = "0.1.0"
+edition = "2021"
+description = "Tests of time"
+license = "Apache-2.0 or MIT"
+
+[lib]
+crate-type = ["staticlib"]
+
+[dependencies]
+zephyr = "0.1.0"

tests/lib/rust/time/prj.conf

@@ -0,0 +1,5 @@
+# Copyright (c) 2024 Linaro LTD
+# SPDX-License-Identifier: Apache-2.0
+
+CONFIG_RUST=y
+CONFIG_MAIN_STACK_SIZE=2048

tests/lib/rust/time/src/lib.rs

@@ -0,0 +1,86 @@
+// Copyright (c) 2024 Linaro LTD
+// SPDX-License-Identifier: Apache-2.0
+
+#![no_std]
+
+use core::ffi::{
+    c_char,
+    CStr,
+};
+
+use zephyr::printkln;
+use zephyr::time::{Duration, Instant, Tick, Timeout};
+use zephyr::raw::k_timeout_t;
+
+#[no_mangle]
+extern "C" fn rust_main() {
+    printkln!("Tick frequency: {}", zephyr::time::SYS_FREQUENCY);
+    check_conversions();
+    printkln!("All tests passed");
+}
+
+/// Verify that the conversions are correct.
+fn check_conversions() {
+    let mut index = 0;
+    loop {
+        // The entry returns is always valid, so is a valid reference.
+        let entry = unsafe { &*get_time_entry(index) };
+        if entry.name.is_null() {
+            break;
+        }
+        let name = unsafe {
+            CStr::from_ptr(entry.name).to_str().expect("Invalid C string")
+        };
+        printkln!("Testing: {}", name);
+
+        // The units must match the enum in the C code.
+        match entry.units {
+            // UNIT_FOREVER
+            0 => {
+                assert_eq!(entry.value.ticks, zephyr::sys::K_FOREVER.ticks);
+            }
+            // UNIT_NO_WAIT
+            1 => {
+                assert_eq!(entry.value.ticks, zephyr::sys::K_NO_WAIT.ticks);
+            }
+            // UNIT_DUR_MS
+            2 => {
+                let value = Duration::millis_at_least(entry.uvalue as Tick);
+                let value: Timeout = value.into();
+                assert_eq!(entry.value.ticks, value.0.ticks);
+            }
+            // UNIT_INST_MS
+            3 => {
+                let base = Instant::from_ticks(0);
+                let value = Duration::millis_at_least(entry.uvalue as Tick);
+                let value = base + value;
+                let value: Timeout = value.into();
+                let c_value = unsafe { ms_to_abs_timeout(entry.uvalue) };
+                if c_value.ticks != value.0.ticks {
+                    printkln!("Mismatch C: {}, Rust: {}",
+                        c_value.ticks, value.0.ticks);
+                }
+                assert_eq!(c_value.ticks, value.0.ticks);
+            }
+            _ => {
+                panic!("Invalid unit enum");
+            }
+        }
+
+        index += 1;
+    }
+}
+
+/// The time entry information.
+#[repr(C)]
+struct TimeEntry {
+    name: *const c_char,
+    units: u32,
+    uvalue: i64,
+    value: k_timeout_t,
+}
+
+extern "C" {
+    fn get_time_entry(index: usize) -> *const TimeEntry;
+    fn ms_to_abs_timeout(ms: i64) -> k_timeout_t;
+}

tests/lib/rust/time/src/times.c

@@ -0,0 +1,94 @@
+/* Copyright (c) 2024 Linaro LTD */
+/* SPDX-License-Identifier: Apache-2.0 */
+
+#include <zephyr/kernel.h>
+
+/* Rather than trying to get C enums to match in size with Rust ones, just use a known integet type.
+ */
+enum units {
+	UNIT_FOREVER,
+	UNIT_NO_WAIT,
+	UNIT_DUR_MSEC,
+	UNIT_INST_MSEC,
+};
+
+/* Data handed back from C containing processed time constant values.
+ */
+struct time_entry {
+	const char *name;
+
+	uint32_t units;
+
+	/* Value in the given units. */
+	int64_t uvalue;
+
+	/* Value in ticks. */
+	k_timeout_t value;
+};
+
+const struct time_entry time_entries[] = {
+	{
+		.name = "K_FOREVER",
+		.units = UNIT_FOREVER,
+		.uvalue = 0,
+		.value = K_FOREVER,
+	},
+	{
+		.name = "K_NO_WAIT",
+		.units = UNIT_NO_WAIT,
+		.uvalue = 0,
+		.value = K_NO_WAIT,
+	},
+#define DUR_TEST(unit, n) \
+	{ \
+		.name = "Duration " #unit " " #n, \
+		.units = UNIT_DUR_ ## unit, \
+		.uvalue = n, \
+		.value = K_ ## unit(n) , \
+	}
+	// Test various values near typical clock boundaries.
+	DUR_TEST(MSEC, 1),
+	DUR_TEST(MSEC, 2),
+	DUR_TEST(MSEC, 99),
+	DUR_TEST(MSEC, 100),
+	DUR_TEST(MSEC, 101),
+	DUR_TEST(MSEC, 999),
+	DUR_TEST(MSEC, 1000),
+	DUR_TEST(MSEC, 1001),
+	DUR_TEST(MSEC, 32767),
+	DUR_TEST(MSEC, 32768),
+	DUR_TEST(MSEC, 32769),
+#define INST_TEST(unit, n) \
+	{ \
+		.name = "Instant " #unit " " #n, \
+		.units = UNIT_INST_ ## unit, \
+		.uvalue = n, \
+	}
+	INST_TEST(MSEC, 1),
+	INST_TEST(MSEC, 2),
+	INST_TEST(MSEC, 99),
+	INST_TEST(MSEC, 100),
+	INST_TEST(MSEC, 101),
+	INST_TEST(MSEC, 999),
+	INST_TEST(MSEC, 1000),
+	INST_TEST(MSEC, 1001),
+	INST_TEST(MSEC, 32767),
+	INST_TEST(MSEC, 32768),
+	INST_TEST(MSEC, 32769),
+	{
+		.name = 0,
+	},
+};
+
+/* Return the indexed time entry.  It is up to the Rust code to detect the null name, and handle it
+ * properly.
+ */
+const struct time_entry *get_time_entry(uintptr_t index) {
+	return &time_entries[index];
+}
+
+/* The abs timeout is not constant, so provide this wrapper function.
+ */
+const k_timeout_t ms_to_abs_timeout(int64_t ms) {
+	return K_TIMEOUT_ABS_MS(ms);
+}

tests/lib/rust/time/testcase.yaml

@@ -0,0 +1,9 @@
+common:
+  filter: CONFIG_RUST_SUPPORTED
+tests:
+  test.rust.time:
+    harness: console
+    harness_config:
+      type: one_line
+      regex:
+        - "All tests passed"