jay-compositor 1.15.0

The Jay compositor
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

use crate::async_engine::AsyncEngine;
use crate::eventfd_cache::EventfdCache;
use crate::io_uring::IoUring;
use crate::utils::array;
use std::rc::Rc;
use std::slice;
use uapi::c;

#[test]
fn test() {
    let eng = AsyncEngine::new();
    let ring = IoUring::new(&eng, 32).unwrap();
    let cache = Rc::new(EventfdCache::new(&ring, &eng));
    const TOTAL: usize = 5;
    let signaled = 3;
    let fd1: [_; TOTAL] = array::from_fn(|_| cache.acquire().unwrap());
    let fd2: [_; TOTAL] = array::from_fn(|_| cache.acquire().unwrap());
    for fd in fd1.iter().chain(fd2.iter()) {
        uapi::eventfd_write(fd.fd.raw(), 1).unwrap();
        let mut poll = c::pollfd {
            fd: fd.fd.raw(),
            events: c::POLLIN,
            revents: 0,
        };
        uapi::poll(slice::from_mut(&mut poll), 0).unwrap();
        assert_eq!(poll.revents, c::POLLIN);
    }
    assert_eq!(cache.inner.fds.len(), 0);
    let ring2 = ring.clone();
    let cache2 = cache.clone();
    let _fut1 = eng.spawn("", async move {
        for fd in fd1.iter().take(signaled) {
            fd.signaled().await.unwrap();
        }
        drop(fd1);
        let debouncer = ring2.debouncer(0);
        while cache2.inner.fds.len() != signaled {
            debouncer.debounce().await;
        }
        for fd in fd2.iter().take(signaled) {
            fd.signaled().await.unwrap();
        }
        drop(fd2);
        while cache2.inner.fds.len() != 2 * signaled {
            debouncer.debounce().await;
        }
        ring2.stop();
    });
    let now_nsec = eng.now().nsec();
    let ring2 = ring.clone();
    let _fut2 = eng.spawn("", async move {
        ring2.timeout(now_nsec + 1_000_000_000).await.unwrap();
        ring2.stop();
    });
    ring.run().unwrap();
    assert_eq!(cache.inner.fds.len(), 2 * signaled);
    for fd in cache.inner.fds.take() {
        let mut poll = c::pollfd {
            fd: fd.raw(),
            events: c::POLLIN,
            revents: 0,
        };
        uapi::poll(slice::from_mut(&mut poll), 0).unwrap();
        assert_eq!(poll.revents, 0);
    }
}