traceforge 0.2.1

TraceForge is a model checker for concurrent and distributed programs written in Rust
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use std::sync::Arc;

use traceforge::{sync::notify::Notify, *};
// this file shows some example usage of the Must's `sync::notify` library

#[test]
fn notify_test() {
    let f = || {
        future::block_on(async {
            let notify = Arc::new(Notify::new());
            let notify2 = notify.clone();

            let handle = future::spawn(async move {
                notify2.notified().await;
                println!("received notification");
            });

            println!("sending notification");
            notify.notify_one();

            // Wait for task to receive notification.
            handle.await.unwrap();
        });
    };

    let stats = verify(
        Config::builder()
            .with_verbose(10)
            .with_keep_going_after_error(false)
            .build(),
        f,
    );
    println!("Stats = {}, {}", stats.execs, stats.block);
}

#[test]
fn multiple_waiters_test() {
    let f = || {
        future::block_on(async {
            let notify = Arc::new(Notify::new());
            let notify1 = notify.clone();
            let notify2 = notify.clone();
            let notify3 = notify.clone();

            let handle1 = future::spawn(async move {
                notify1.notified().await;
                println!("waiter 1 received notification");
            });

            let handle2 = future::spawn(async move {
                notify2.notified().await;
                println!("waiter 2 received notification");
            });

            println!("sending first notification");
            notify.notify_one();

            println!("sending second notification");
            notify3.notify_one();

            // Wait for both tasks to receive notifications
            handle1.await.unwrap();
            handle2.await.unwrap();
        });
    };

    let stats = verify(
        Config::builder()
            .with_verbose(5)
            .with_keep_going_after_error(false)
            .build(),
        f,
    );
    println!("Multiple waiters stats = {}, {}", stats.execs, stats.block);
}

#[test]
fn notify_before_wait_test() {
    let f = || {
        future::block_on(async {
            let notify = Arc::new(Notify::new());
            let notify_clone = notify.clone();

            // Send notification before anyone is waiting
            println!("sending notification before waiting");
            notify.notify_one();

            let handle = future::spawn(async move {
                notify_clone.notified().await;
                println!("received pre-sent notification");
            });

            // The waiter should receive the notification immediately
            handle.await.unwrap();
        });
    };

    let stats = verify(
        Config::builder()
            .with_verbose(5)
            .with_keep_going_after_error(false)
            .build(),
        f,
    );
    println!(
        "Notify before wait stats = {}, {}",
        stats.execs, stats.block
    );
}

#[test]
fn two_notifies_one_received() {
    let f = || {
        future::block_on(async {
            let notify = Arc::new(Notify::new());
            let notify_clone = notify.clone();

            // Send first notification - this sets state to 1
            println!("sending first notification");
            notify.notify_one();

            // Send second notification - this should overwrite the first (state stays 1)
            println!("sending second notification (overwrites first)");
            notify.notify_one();

            let handle = future::spawn(async move {
                notify_clone.notified().await;
                println!("received notification (only one despite two sends)");
            });

            // The waiter should only receive one notification, not two
            handle.await.unwrap();

            // Now if we try to wait again, it should block since no new notification was sent
            let notify_clone2 = notify.clone();
            let handle2 = future::spawn(async move {
                println!("waiting for another notification...");
                notify_clone2.notified().await;
                println!("received second notification");
            });

            // Send one more notification to unblock the second waiter
            println!("sending third notification");
            notify.notify_one();

            handle2.await.unwrap();
        });
    };

    let stats = verify(
        Config::builder()
            .with_verbose(5)
            .with_keep_going_after_error(false)
            .build(),
        f,
    );
    println!(
        "Two notifies one received stats = {}, {}",
        stats.execs, stats.block
    );
}