bach 0.1.2

Discrete-event simulation environment for async workflows
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

use super::*;
use crate::queue::Queue as _;

/// Overflow behavior should be the same regardless of discipline
macro_rules! overflow_tests {
    () => {
        #[test]
        fn prefer_oldest() {
            let mut queue = Queue::builder()
                .with_capacity(Some(2))
                .with_discipline(DISCIPLINE)
                .with_overflow(Overflow::PreferOldest)
                .build();

            queue.push(0).unwrap();
            queue.push(1).unwrap();
            assert!(matches!(queue.push_lazy(&mut None), Err(PushError::Full)));
        }

        #[test]
        fn prefer_recent() {
            let mut queue = Queue::builder()
                .with_capacity(Some(2))
                .with_discipline(DISCIPLINE)
                .with_overflow(Overflow::PreferRecent)
                .build();

            queue.push(0).unwrap();
            queue.push(1).unwrap();
            let mut v = Some(2);
            assert!(matches!(queue.push_lazy(&mut v), Ok(Some(0))));
            assert_eq!(v, None);
        }
    };
}

macro_rules! push_pop_test {
    ([$($value:expr),* $(,)?]) => {
        #[test]
        fn push_pop() {
            let mut queue = Queue::builder()
                .with_discipline(DISCIPLINE)
                .build();

            let mut v = 0;

            $(
                queue.push(v).unwrap();
                v += 1;
                let _ = $value;
            )*

            let _ = v;

            $(
                assert_eq!(queue.pop().unwrap(), $value);
            )*
        }
    };
}

mod lifo {
    use super::*;
    const DISCIPLINE: Discipline = Discipline::Lifo;
    overflow_tests!();

    push_pop_test!([5, 4, 3, 2, 1, 0]);
}

mod fifo {
    use super::*;
    const DISCIPLINE: Discipline = Discipline::Fifo;
    overflow_tests!();

    push_pop_test!([0, 1, 2, 3, 4, 5]);
}