sched_callback/
message.rs

1use std::time::SystemTime;
2
3#[derive(Debug)]
4pub enum MessageType{
5    Add(usize, SystemTime),
6    Cancel(usize, SystemTime),
7    WaitStart(usize, SystemTime),
8    WaitEnd(usize, SystemTime), 
9    Abort(usize, SystemTime),
10    ExecuteCallback(usize, SystemTime),
11}
12#[cfg(test)]
13mod tests {
14    use std::{sync::Arc, time::{Duration}};
15    use tokio::sync::Mutex;
16    use crate::{queue::SchedQueue, task::{SchedType, Task}, message::MessageType};
17
18    #[tokio::test]
19    async fn message_test() {
20        let (sq, mut rx) = SchedQueue::new();
21        let order = Arc::new(Mutex::new(Vec::new()));
22
23        for i in 0..10 {
24            let order = order.clone();
25            let _ = sq.add(Task::new(SchedType::Delay(Duration::from_millis(101-i), 1), Box::new(move || {
26                let order = order.clone();
27                Box::pin(async move {
28                    let mut guard = order.lock().await;
29                    guard.push(i);
30                })
31            }))).await;
32        }
33        let messages = Arc::new(Mutex::new(Vec::new()));
34        let m = messages.clone();
35        tokio::spawn(async move {
36            while let Some(msg) = rx.recv().await {
37                let mut guard = m.lock().await;
38                guard.push(msg);
39            }
40        });
41        tokio::time::sleep(Duration::from_secs(1)).await;
42        let guard = messages.lock().await;
43        let mut length = (0, 0, 0, 0);
44        for msg in &*guard {
45            match msg {
46                MessageType::Add(_, _) => length.0 += 1,
47                MessageType::WaitStart(_, _) => length.1 += 1,
48                MessageType::WaitEnd(_, _) => length.2 += 1,
49                MessageType::Abort(_, _) => length.3 += 1,
50                _ => {},
51            }
52        }
53        assert_eq!(length.0, 10);
54        assert_eq!(length.1, 10);
55        assert_eq!(length.2, 10);
56        assert_eq!(length.3, 9);
57    }
58}