a10 0.4.3

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

use std::io;
use std::pin::pin;

use a10::fd::{self, AsyncFd};
use a10::pipe::{Pipe, pipe, sync_pipe};

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

const DATA1: &[u8] = b"Hello from the other side";

#[test]
fn pipe_is_send_and_sync() {
    is_send::<Pipe>();
    is_sync::<Pipe>();
}

#[test]
fn pipe_file_descriptor() {
    test_pipe(create_async(fd::Kind::File))
}

#[test]
#[cfg(any(target_os = "android", target_os = "linux"))]
fn pipe_direct_descriptor() {
    test_pipe(create_async(fd::Kind::Direct))
}

#[test]
fn sync_pipe_file_descriptor() {
    let sq = test_queue();
    test_pipe(
        sync_pipe()
            .map(|[r, s]| [AsyncFd::new(r, sq.clone()), AsyncFd::new(s, sq.clone())])
            .expect("failed to create pipe"),
    )
}

fn create_async(fd_kind: fd::Kind) -> [AsyncFd; 2] {
    let sq = test_queue();
    Waker::new()
        .block_on(pipe(sq).kind(fd_kind))
        .expect("failed to create pipe")
}

fn test_pipe([receiver, sender]: [AsyncFd; 2]) {
    let waker = Waker::new();

    // Send some data.
    waker
        .block_on(sender.write_all(DATA1))
        .expect("failed to write");

    // Received it on the other side.
    let received = waker
        .block_on(receiver.read_n(Vec::with_capacity(DATA1.len() + 1), DATA1.len()))
        .expect("failed to read");
    assert_eq!(received, DATA1);
}

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

    let mut pipe = pin!(pipe(sq));
    _ = poll_nop(pipe.as_mut());
    drop(pipe);
}

#[test]
fn writing_to_closed_pipe() {
    // Older versions of macOS (OS X 10.11 and 10.10 have been witnessed) can
    // return EPIPE when registering a pipe file descriptor where the other end
    // has already disappeared. For example code that creates a pipe, closes a
    // file descriptor, and then registers the other end will see an EPIPE
    // returned.
    //
    // More info can be found at https://github.com/tokio-rs/mio#582.
    //
    // We've removed the work around for this (as OS X 10.11 and 10.10 are no
    // longer supported), but we explicitly want to test the behaviour doesn't
    // return.

    let sq = test_queue();
    let waker = Waker::new();

    let [receiver, sender] = waker.block_on(pipe(sq)).expect("failed to create pipe");

    waker.block_on(receiver.close()).unwrap(); // Close the fd.

    match waker.block_on(sender.write_all(DATA1)) {
        // Normally we would expect a broken pipe error here. However, sometimes
        // on Linux and macOS we get no error. Since that's not an A10 issue, we
        // can't do much about it other than accept it here.
        Ok(()) => {}
        res => expect_io_error_kind(res, io::ErrorKind::BrokenPipe),
    }
}

#[test]
fn reading_from_closed_pipe() {
    // See writing_to_closed_pipe test above for why this is tested.

    let sq = test_queue();
    let waker = Waker::new();

    let [receiver, sender] = waker.block_on(pipe(sq)).expect("failed to create pipe");

    waker.block_on(sender.close()).unwrap(); // Close the fd.

    let buf = waker
        .block_on(receiver.read(Vec::with_capacity(8)))
        .expect("failed to read");
    assert!(buf.is_empty());
}