nexus-acto-rs 0.4.2

A Rust crate for Actors
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

#[cfg(test)]
mod tests {
  use crate::util::queue::ring_queue::RingQueue;
  use crate::util::queue::{QueueBase, QueueError, QueueReader, QueueWriter};

  #[tokio::test]
  async fn test_push_pop() {
    let mut queue = RingQueue::new(5);
    assert!(queue.offer(1).await.is_ok());
    assert!(queue.offer(2).await.is_ok());
    assert_eq!(queue.poll().await.unwrap(), Some(1));
    assert_eq!(queue.poll().await.unwrap(), Some(2));
    assert_eq!(queue.poll().await.unwrap(), None);
  }

  #[tokio::test]
  async fn test_full_queue_fixed_size() {
    let mut queue = RingQueue::new(4).with_dynamic(false);
    assert!(queue.offer(1).await.is_ok());
    assert!(queue.offer(2).await.is_ok());
    assert!(queue.offer(3).await.is_ok());
    assert!(matches!(queue.offer(4).await, Err(QueueError::OfferError(4))));
  }

  #[tokio::test]
  async fn test_full_queue_dynamic_size() {
    let mut queue = RingQueue::new(4).with_dynamic(true);
    assert!(queue.offer(1).await.is_ok());
    assert!(queue.offer(2).await.is_ok());
    assert!(queue.offer(3).await.is_ok());
    assert!(queue.offer(4).await.is_ok());
    assert!(queue.offer(5).await.is_ok()); // This should trigger resize
    assert_eq!(queue.capacity().await.to_usize(), 9);

    // Add more elements to test the new capacity
    assert!(queue.offer(6).await.is_ok());
    assert!(queue.offer(7).await.is_ok());
    assert!(queue.offer(8).await.is_ok());
    assert!(queue.offer(9).await.is_ok()); // This should trigger another resize
    assert_eq!(queue.capacity().await.to_usize(), 19);
  }

  #[tokio::test]
  async fn test_len_and_is_empty() {
    let mut queue = RingQueue::new(5);
    assert_eq!(queue.len().await.to_usize(), 0);

    queue.offer(1).await.unwrap();
    assert_eq!(queue.len().await.to_usize(), 1);

    queue.offer(2).await.unwrap();
    assert_eq!(queue.len().await.to_usize(), 2);

    queue.poll().await.unwrap();
    assert_eq!(queue.len().await.to_usize(), 1);

    queue.poll().await.unwrap();
    assert_eq!(queue.len().await.to_usize(), 0);
  }

  #[tokio::test]
  async fn test_wrap_around() {
    let mut queue = RingQueue::new(4);
    assert!(queue.offer(1).await.is_ok());
    assert!(queue.offer(2).await.is_ok());
    assert!(queue.offer(3).await.is_ok());
    assert!(queue.offer(4).await.is_ok());
    assert_eq!(queue.poll().await.unwrap(), Some(1));
    assert!(queue.offer(5).await.is_ok());
    assert_eq!(queue.poll().await.unwrap(), Some(2));
    assert_eq!(queue.poll().await.unwrap(), Some(3));
    assert_eq!(queue.poll().await.unwrap(), Some(4));
    assert_eq!(queue.poll().await.unwrap(), Some(5));
    assert_eq!(queue.poll().await.unwrap(), None);
  }

  #[tokio::test]
  async fn test_clean_up() {
    let mut queue = RingQueue::new(5);
    queue.offer(1).await.unwrap();
    queue.offer(2).await.unwrap();
    queue.offer(3).await.unwrap();
    assert_eq!(queue.len().await.to_usize(), 3);

    queue.clean_up().await;
    assert_eq!(queue.len().await.to_usize(), 0);
    assert_eq!(queue.poll().await.unwrap(), None);
  }
}