a10 0.4.2

This library is meant as a low-level library safely exposing different OS's abilities to perform non-blocking I/O.
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

//! NOTE: see `tests/signals.rs` for testing of signal handling.

use std::pin::{Pin, pin};
use std::process::Command;

#[cfg(any(target_os = "android", target_os = "linux"))]
use a10::process::ToDirect;
use a10::process::{
    self, ChildStatus, ReceiveSignal, Signal, SignalInfo, SignalSet, Signals, To, WaitId,
    WaitOption,
};

use crate::util::{Waker, is_send, is_sync, poll_nop, test_queue};

#[test]
fn signal_is_send_and_sync() {
    is_send::<Signal>();
    is_sync::<Signal>();
}

#[test]
fn signal_set_is_send_and_sync() {
    is_send::<SignalSet>();
    is_sync::<SignalSet>();
}

#[test]
fn signals_is_send_and_sync() {
    is_send::<Signals>();
    is_sync::<Signals>();
}

#[test]
fn signal_info_is_send_and_sync() {
    is_send::<SignalInfo>();
    is_sync::<SignalInfo>();
}

#[test]
#[cfg(any(target_os = "android", target_os = "linux"))]
fn to_direct_is_send_and_sync() {
    is_send::<ToDirect>();
    is_sync::<ToDirect>();
}

#[test]
fn wait_id_is_send_and_sync() {
    is_send::<WaitId>();
    is_sync::<WaitId>();
}

#[test]
fn receive_signal_is_send_and_sync() {
    is_send::<ReceiveSignal>();
    is_sync::<ReceiveSignal>();
}

#[test]
fn process_wait_on() {
    let sq = test_queue();
    let waker = Waker::new();

    let process = Command::new("true").spawn().unwrap();
    let pid = process.id();

    let info = waker
        .block_on(process::wait_on(sq, &process).flags(WaitOption::EXITED))
        .expect("failed wait");

    assert_eq!(info.signal(), Signal::CHILD);
    assert_eq!(info.code(), ChildStatus::EXITED);
    assert_eq!(info.pid(), pid as i32);
    assert_eq!(info.status().code(), Some(libc::EXIT_SUCCESS));
}

#[test]
fn process_wait_on_process_that_does_not_stop() {
    let sq = test_queue();

    let process = Command::new("sleep").arg("10000").spawn().unwrap();

    let mut fut = pin!(process::wait_on(sq, &process).flags(WaitOption::EXITED));
    for _ in 0..=3 {
        let res = poll_nop(fut.as_mut());
        assert!(res.is_pending(), "unexpected poll result: {res:?}");
    }
}

#[test]
fn process_wait_on_drop_before_complete() {
    let sq = test_queue();

    let process = Command::new("sleep").arg("1000").spawn().unwrap();

    let mut future = process::wait_on(sq, &process).flags(WaitOption::EXITED);
    let result = poll_nop(Pin::new(&mut future));
    if !result.is_pending() {
        panic!("unexpected result, expected it to return Poll::Pending");
    }
    drop(future);
}

#[test]
fn send_signal() {
    let sq = test_queue();
    let waker = Waker::new();

    let process = Command::new("sleep").arg("10000").spawn().unwrap();
    let pid = process.id();

    let mut wait_on = pin!(process::wait_on(sq, &process).flags(WaitOption::EXITED));
    let res = poll_nop(wait_on.as_mut());
    assert!(res.is_pending(), "unexpected poll result: {res:?}");

    process::send_signal(To::child(&process), Signal::TERMINATION).unwrap();

    let info = waker.block_on(wait_on).expect("failed wait");

    assert_eq!(info.signal(), Signal::CHILD);
    assert_eq!(info.code(), ChildStatus::KILLED);
    assert_eq!(info.pid(), pid as i32);
}