tokio 1.52.1

An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications.
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

use super::*;

use futures::task::noop_waker;

#[cfg(loom)]
const NUM_ITEMS: usize = 16;

#[cfg(not(loom))]
const NUM_ITEMS: usize = 64;

fn new_handle() -> EntryHandle {
    EntryHandle::new(0, noop_waker())
}

fn model<F: Fn() + Send + Sync + 'static>(f: F) {
    #[cfg(loom)]
    loom::model(f);

    #[cfg(not(loom))]
    f();
}

#[test]
fn sanity() {
    model(|| {
        let mut queue = RegistrationQueue::new();
        for _ in 0..NUM_ITEMS {
            unsafe {
                queue.push_front(new_handle());
            }
        }
        for _ in 0..NUM_ITEMS {
            assert!(queue.pop_front().is_some());
        }
        assert!(queue.pop_front().is_none());
    });
}

#[test]
fn drop_should_not_leak_memory() {
    model(|| {
        let mut queue = RegistrationQueue::new();

        let hdls = (0..NUM_ITEMS).map(|_| new_handle()).collect::<Vec<_>>();
        for hdl in hdls.iter() {
            unsafe { queue.push_front(hdl.clone()) };
        }

        drop(queue);

        assert!(hdls.into_iter().all(|hdl| hdl.inner_strong_count() == 1));
    });
}