fix: error of test case

Author: BinChengZhao

examples/demo_async_tokio.rs

@@ -13,9 +13,7 @@ async fn main() -> Result<()> {
     // You can also share a tokio runtime with delayTimer, please see api `DelayTimerBuilder::tokio_runtime` for details.
 
     // Build an DelayTimer that uses the default configuration of the Smol runtime internally.
-    let delay_timer = DelayTimerBuilder::default()
-        .tokio_runtime_by_default()
-        .build();
+    let delay_timer = DelayTimerBuilder::default().build();
 
     // Develop a print job that runs in an asynchronous cycle.
     let task_instance_chain = delay_timer.insert_task(build_task_async_print()?)?;

src/entity.rs

@@ -224,18 +224,18 @@ impl DelayTimerBuilder {
             .build()
             .ok_or_else(|| anyhow!("Missing base component, can't initialize."))?;
 
-        let timer = Timer::new(self.get_timer_event_sender(), shared_header.clone());
-
         match self.runtime_instance.kind {
-            RuntimeKind::Smol => self.assign_task(timer, event_handle),
+            RuntimeKind::Smol => self.assign_task(event_handle, shared_header),
 
-            RuntimeKind::Tokio => self.assign_task_by_tokio(timer, event_handle, shared_header),
+            RuntimeKind::Tokio => self.assign_task_by_tokio(event_handle, shared_header),
         };
 
         Ok(())
     }
 
-    fn assign_task(&self, timer: Timer, event_handle: EventHandle) {
+    fn assign_task(&mut self, event_handle: EventHandle, shared_header: SharedHeader) {
+        let timer = Timer::new(self.get_timer_event_sender(), shared_header.clone());
+
         self.run_async_schedule(timer);
 
         self.run_event_handle(event_handle);
@@ -383,23 +383,22 @@ impl DelayTimer {
 /// This function requires the `tokio-support` feature of the `delay_timer`
 /// crate to be enabled.
 impl DelayTimerBuilder {
-    fn assign_task_by_tokio(
-        &mut self,
-        timer: Timer,
-        event_handle: EventHandle,
-        shared_header: SharedHeader,
-    ) {
-        self.run_async_schedule_by_tokio(timer, shared_header.clone());
+    fn assign_task_by_tokio(&mut self, event_handle: EventHandle, shared_header: SharedHeader) {
+        self.run_async_schedule_by_tokio(shared_header.clone());
         self.run_event_handle_by_tokio(event_handle, shared_header);
     }
 
-    fn run_async_schedule_by_tokio(&self, mut timer: Timer, shared_header: SharedHeader) {
+    fn run_async_schedule_by_tokio(&mut self, shared_header: SharedHeader) {
+        let shared_header_by_timer = shared_header.clone();
+        let timer_event_sender = self.get_timer_event_sender();
+
         if let Some(ref tokio_runtime_ref) = shared_header.runtime_instance.inner {
             let tokio_runtime = tokio_runtime_ref.clone();
             Builder::new()
                 .name("async_schedule_tokio".into())
                 .spawn(move || {
                     tokio_runtime.block_on(async {
+                        let mut timer = Timer::new(timer_event_sender, shared_header_by_timer);
                         timer.async_schedule().await;
                     })
                 })

src/prelude.rs

@@ -54,7 +54,7 @@ pub(crate) use log::{debug, error, info, trace};
 pub(crate) use smol::channel::{unbounded, Receiver as AsyncReceiver, Sender as AsyncSender};
 pub(crate) use smol::future::yield_now;
 pub(crate) use smol::lock::Mutex as AsyncMutex;
-pub(crate) use smol::Timer;
+pub(crate) use smol::Timer as AsyncTimer;
 pub(crate) use std::convert::{TryFrom, TryInto};
 pub(crate) use std::future::Future;
 pub(crate) use std::iter::StepBy;

src/timer/runtime_trace/sweeper.rs

@@ -168,7 +168,7 @@ impl RecyclingBins {
         let duration = duration.unwrap_or_else(|| Duration::from_secs(3));
         match self.runtime_kind {
             RuntimeKind::Smol => {
-                Timer::after(duration).await;
+                AsyncTimer::after(duration).await;
             }
 
             RuntimeKind::Tokio => {

src/timer/timer_core.rs

@@ -426,8 +426,8 @@ impl Timer {
 
 mod tests {
 
-    #[test]
-    fn test_next_position() {
+    #[tokio::test]
+    async fn test_next_position() {
         use super::{SharedHeader, Timer, TimerEvent};
         use smol::channel::unbounded;
         use std::sync::atomic::Ordering;

tests/simulation.rs

@@ -12,8 +12,8 @@ use std::time::Duration;
 use smol::Timer;
 
 // TODO: Please turn on `--features=full` before test.
-#[test]
-fn test_instance_state() -> anyhow::Result<()> {
+#[tokio::test]
+async fn test_instance_state() -> anyhow::Result<()> {
     let delay_timer = DelayTimer::new();
 
     let body = || async {
@@ -52,8 +52,8 @@ fn test_instance_state() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[test]
-fn test_instance_timeout_state() -> anyhow::Result<()> {
+#[tokio::test]
+async fn test_instance_timeout_state() -> anyhow::Result<()> {
     let delay_timer = DelayTimer::new();
 
     let body = || async {
@@ -171,8 +171,8 @@ fn test_shell_task_instance_complete_state() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[test]
-fn go_works() -> AnyResult<()> {
+#[tokio::test]
+async fn go_works() -> AnyResult<()> {
     // Coordinates the inner-Runtime with the external(test-thread) clock.
     let expression = "0/2 * * * * * *";
     let park_time = 2_100_000u64;
@@ -235,8 +235,8 @@ fn test_advance() -> AnyResult<()> {
     Ok(())
 }
 
-#[test]
-fn test_maximum_parallel_runnable_num() -> AnyResult<()> {
+#[tokio::test]
+async fn test_maximum_parallel_runnable_num() -> AnyResult<()> {
     let delay_timer = DelayTimer::new();
     let share_num = Arc::new(AtomicU64::new(0));
     let share_num_bunshin = share_num.clone();
@@ -267,8 +267,8 @@ fn test_maximum_parallel_runnable_num() -> AnyResult<()> {
     Ok(())
 }
 
-#[test]
-fn tests_countdown() -> AnyResult<()> {
+#[tokio::test]
+async fn tests_countdown() -> AnyResult<()> {
     let delay_timer = DelayTimer::new();
     let share_num = Arc::new(AtomicI32::new(3));
     let share_num_bunshin = share_num.clone();
@@ -330,7 +330,7 @@ fn test_cron_clock() -> AnyResult<()> {
         cron_clock::Schedule::from_str("0 10 22 * * Monday,Tuesday,Wednesday,Thursday,Friday *")?
             .upcoming_owned(cron_clock::Utc);
 
-    for i in 0..10 {
+    for _ in 0..10 {
         println!("{:?}", s.next());
     }