Fix all of the broken tests

src/experimental/animation.rs

@@ -40,7 +40,7 @@
 //!         clear_background(WHITE);
 //!         // Now we can draw our character
 //!         draw_texture_ex(
-//!             image,
+//!             &image,
 //!             10.,
 //!             10.,
 //!             WHITE,

src/text.rs

@@ -201,16 +201,6 @@ impl Font {
     /// Sets the [FilterMode](https://docs.rs/miniquad/latest/miniquad/graphics/enum.FilterMode.html#) of this font's texture atlas.
     ///
     /// Use Nearest if you need integer-ratio scaling for pixel art, for example.
-    ///
-    /// # Example
-    /// ```
-    /// # use macroquad::prelude::*;
-    /// # #[macroquad::main("test")]
-    /// # async fn main() {
-    /// let font = Font::default();
-    /// font.set_filter(FilterMode::Linear);
-    /// # }
-    /// ```
     pub fn set_filter(&mut self, filter_mode: miniquad::FilterMode) {
         self.atlas.lock().unwrap().set_filter(filter_mode);
     }

tests/coroutine_execution_order.rs

@@ -0,0 +1,14 @@
+use macroquad::{experimental::coroutines::start_coroutine, window::next_frame};
+
+#[macroquad::test]
+async fn coroutine_execution_order() {
+    start_coroutine(async move {
+        println!("a");
+        next_frame().await;
+        println!("b");
+    });
+    println!("c");
+    next_frame().await;
+    println!("d");
+    next_frame().await;
+}

tests/coroutine_manual_poll.rs

@@ -0,0 +1,42 @@
+use macroquad::{
+    experimental::{coroutines::start_coroutine, scene},
+    window::next_frame,
+};
+
+#[macroquad::test]
+async fn coroutine_manual_poll() {
+    struct Player {
+        state: i32,
+    }
+    impl scene::Node for Player {}
+
+    let player = scene::add_node(Player { state: 0 });
+
+    let mut coroutine = start_coroutine(async move {
+        loop {
+            scene::get_node(player).state += 1;
+            next_frame().await;
+        }
+    });
+
+    // make sure that coroutine is not yet polled
+    assert_eq!(scene::get_node(player).state, 0);
+
+    coroutine.set_manual_poll();
+
+    // still not polled
+    assert_eq!(scene::get_node(player).state, 0);
+
+    coroutine.poll(0.1);
+    assert_eq!(scene::get_node(player).state, 1);
+
+    next_frame().await;
+    next_frame().await;
+
+    // make sure that after main loop's next_frame coroutine was not polled
+    assert_eq!(scene::get_node(player).state, 1);
+
+    // and that we still can poll
+    coroutine.poll(0.1);
+    assert_eq!(scene::get_node(player).state, 2);
+}

tests/coroutine_manual_poll_delay.rs

@@ -0,0 +1,33 @@
+use macroquad::experimental::{
+    coroutines::{start_coroutine, wait_seconds},
+    scene,
+};
+
+#[macroquad::test]
+async fn coroutine_manual_poll_delay() {
+    struct Player {
+        state: i32,
+    }
+    impl scene::Node for Player {}
+
+    let player = scene::add_node(Player { state: 0 });
+
+    let mut coroutine = start_coroutine(async move {
+        wait_seconds(1.).await;
+        scene::get_node(player).state = 1;
+    });
+
+    coroutine.set_manual_poll();
+
+    assert_eq!(scene::get_node(player).state, 0);
+
+    // not 1 second yet, coroutine will have "now": 0.0, "delta": 0.9, (0.0 + 0.9) < 1.0
+    coroutine.poll(0.9);
+
+    assert_eq!(scene::get_node(player).state, 0);
+
+    // coroutine will have "now": 0.1, delta: 0.11, (0.9 + 0.11) > 1.0, wait_for_seconds pass
+    coroutine.poll(0.11);
+
+    assert_eq!(scene::get_node(player).state, 1);
+}

tests/coroutine_memory.rs

@@ -0,0 +1,17 @@
+use macroquad::{experimental::coroutines::start_coroutine, telemetry, window::next_frame};
+
+#[macroquad::test]
+async fn coroutine_memory() {
+    for _ in 0..20 {
+        start_coroutine(async move {
+            next_frame().await;
+        });
+
+        next_frame().await;
+    }
+
+    // wait for the last one to finish
+    next_frame().await;
+
+    assert_eq!(telemetry::active_coroutines_count(), 0);
+}

tests/coroutine_values.rs

@@ -1,7 +1,7 @@
-use macroquad::{experimental::coroutines::start_coroutine, telemetry, window::next_frame};
+use macroquad::{experimental::coroutines::start_coroutine, window::next_frame};
 
 #[macroquad::test]
-async fn coroutine_value() {
+async fn coroutine_values() {
     let mut coroutine = start_coroutine(async move {
         next_frame().await;
         1
@@ -16,21 +16,3 @@ async fn coroutine_value() {
 
     assert_eq!(coroutine.retrieve(), Some(1));
 }
-
-#[macroquad::test]
-async fn coroutine_memory() {
-    use macroquad::prelude::*;
-
-    for _ in 0..20 {
-        start_coroutine(async move {
-            next_frame().await;
-        });
-
-        next_frame().await;
-    }
-
-    // wait for the last one to finish
-    next_frame().await;
-
-    assert_eq!(telemetry::active_coroutines_count(), 0);
-}