Use the official way of unit testing in examples

Cargo.toml

@@ -10,10 +10,26 @@ mlua = { version = "0.9", features = ["luau", "luau-jit", "async"] }
 [lib]
 path = "lib/lib.rs"
 
-[examples]
-basic-sleep = "examples/basic_sleep.rs"
-basic-spawn = "examples/basic_spawn.rs"
-callbacks = "examples/callbacks.rs"
-captures = "examples/captures.rs"
-lots-of-threads = "examples/lots_of_threads.rs"
-scheduler-ordering = "examples/scheduler_ordering.rs"
+[[example]]
+name = "basic_sleep"
+test = true
+
+[[example]]
+name = "basic_spawn"
+test = true
+
+[[example]]
+name = "callbacks"
+test = true
+
+[[example]]
+name = "captures"
+test = true
+
+[[example]]
+name = "lots_of_threads"
+test = true
+
+[[example]]
+name = "scheduler_ordering"
+test = true

examples/basic_sleep.rs

@@ -28,3 +28,8 @@ pub fn main() -> LuaResult<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_basic_sleep() -> LuaResult<()> {
+    main()
+}

examples/basic_spawn.rs

@@ -34,3 +34,8 @@ pub fn main() -> LuaResult<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_basic_spawn() -> LuaResult<()> {
+    main()
+}

examples/callbacks.rs

@@ -26,3 +26,8 @@ pub fn main() -> LuaResult<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_callbacks() -> LuaResult<()> {
+    main()
+}

examples/captures.rs

@@ -85,3 +85,8 @@ fn run<'lua>(lua: &'lua Lua, main: impl IntoLuaThread<'lua>) -> LuaResult<LuaVal
         unreachable!("No value or error captured from main thread");
     }
 }
+
+#[test]
+fn test_captures() -> LuaResult<()> {
+    main()
+}

examples/lots_of_threads.rs

@@ -31,3 +31,8 @@ pub fn main() -> LuaResult<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_lots_of_threads() -> LuaResult<()> {
+    main()
+}

examples/scheduler_ordering.rs

@@ -29,3 +29,8 @@ pub fn main() -> LuaResult<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_scheduler_ordering() -> LuaResult<()> {
+    main()
+}

lib/lib.rs

@@ -10,6 +10,3 @@ pub use smol;
 pub use callbacks::Callbacks;
 pub use runtime::Runtime;
 pub use traits::{IntoLuaThread, LuaExecutorExt};
-
-#[cfg(test)]
-mod tests;

lib/tests.rs

@@ -1,52 +0,0 @@
-use std::time::{Duration, Instant};
-
-use mlua::prelude::*;
-
-use smol::{fs::read_to_string, Timer};
-
-use crate::Runtime;
-
-macro_rules! create_tests {
-    ($($name:ident: $value:expr,)*) => { $(
-        #[test]
-        fn $name() -> LuaResult<()> {
-            // Read the test script
-            let script = std::fs::read_to_string(concat!($value, ".luau"))?;
-
-            // Set up persistent lua environment
-            let lua = Lua::new();
-            lua.globals().set(
-                "sleep",
-                lua.create_async_function(|_, duration: Option<f64>| async move {
-                    let duration = duration.unwrap_or_default().max(1.0 / 250.0);
-                    let before = Instant::now();
-                    let after = Timer::after(Duration::from_secs_f64(duration)).await;
-                    Ok((after - before).as_secs_f64())
-                })?
-            )?;
-            lua.globals().set(
-                "readFile",
-                lua.create_async_function(|_, path: String| async move {
-                    Ok(read_to_string(path).await?)
-                })?
-            )?;
-
-            // Load the main script into a runtime and run it until completion
-            let rt = Runtime::new(&lua)?;
-            let main = lua.load(script);
-            rt.push_thread(main, ());
-            rt.run_blocking();
-
-            Ok(())
-        }
-    )* }
-}
-
-create_tests! {
-    basic_sleep: "examples/lua/basic_sleep",
-    basic_spawn: "examples/lua/basic_spawn",
-    callbacks: "examples/lua/callbacks",
-    captures: "examples/lua/captures",
-    lots_of_threads: "examples/lua/lots_of_threads",
-    scheduler_ordering: "examples/lua/scheduler_ordering",
-}