uapi 0.1.1

Wrappers for OS APIs on UNIX-like platform
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

use std::{
    fs::File,
    io::{IoSlice, IoSliceMut, Read, Write},
    net::{TcpListener, TcpStream, UdpSocket},
    os::unix::net::{UnixDatagram, UnixListener, UnixStream},
    process::{Command, Stdio},
};
use uapi::*;

#[test]
fn fd() {
    assert_eq!(OwnedFd::new(-1).unwrap(), -1);
    assert_eq!(OwnedFd::new(-1).borrow(), Fd::new(-1));
    assert_eq!(*OwnedFd::new(-1), -1);
    assert_eq!(OwnedFd::new(-1).raw(), -1);

    assert_eq!(OwnedFd::from(File::from(OwnedFd::new(37))).unwrap(), 37);
    assert_eq!(
        OwnedFd::from(TcpListener::from(OwnedFd::new(37))).unwrap(),
        37
    );
    assert_eq!(
        OwnedFd::from(TcpStream::from(OwnedFd::new(37))).unwrap(),
        37
    );
    assert_eq!(
        OwnedFd::from(UdpSocket::from(OwnedFd::new(37))).unwrap(),
        37
    );
    assert_eq!(
        OwnedFd::from(UnixDatagram::from(OwnedFd::new(37))).unwrap(),
        37
    );
    assert_eq!(
        OwnedFd::from(UnixStream::from(OwnedFd::new(37))).unwrap(),
        37
    );
    assert_eq!(
        OwnedFd::from(UnixListener::from(OwnedFd::new(37))).unwrap(),
        37
    );

    let (mut r, w) = pipe().unwrap();

    Command::new("/bin/sh")
        .arg("-c")
        .arg("printf x")
        .stdout(w)
        .status()
        .unwrap();

    assert_eq!(&r.read_to_new_ustring().unwrap(), "x");

    let mut child = Command::new("/bin/sh")
        .arg("-c")
        .arg("printf y >&2; cat")
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .stdin(Stdio::piped())
        .spawn()
        .unwrap();

    OwnedFd::from(child.stdin.take().unwrap())
        .write_all(b"x")
        .unwrap();
    let mut r = OwnedFd::from(child.stdout.take().unwrap());
    assert_eq!(&r.read_to_new_ustring().unwrap(), "x");
    let mut r = OwnedFd::from(child.stderr.take().unwrap());
    assert_eq!(&r.read_to_new_ustring().unwrap(), "y");

    assert_eq!(Fd::new(-1).raw(), -1);
    assert_eq!(*Fd::new(-1), -1);

    assert_eq!(Fd::new(-1), Fd::new(-1));
    assert_eq!(OwnedFd::new(-1), OwnedFd::new(-1));
    assert_eq!(Fd::new(-1), OwnedFd::new(-1));
    assert_eq!(OwnedFd::new(-1), Fd::new(-1));

    let (mut r, mut w) = pipe().unwrap();
    assert_eq!(w.write(b"abc").unwrap(), 3);
    assert_eq!(w.borrow().write(b"abc").unwrap(), 3);
    assert_eq!(w.write_vectored(&[IoSlice::new(b"abc")]).unwrap(), 3);
    assert_eq!(
        w.borrow().write_vectored(&[IoSlice::new(b"abc")]).unwrap(),
        3
    );
    assert!(w.flush().is_ok());
    assert!(w.borrow().flush().is_ok());

    let mut buf = [0; 1];
    assert_eq!(r.read(&mut buf).unwrap(), 1);
    assert_eq!(buf[0], b'a');
    assert_eq!(r.borrow().read(&mut buf).unwrap(), 1);
    assert_eq!(buf[0], b'b');
    assert_eq!(
        r.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(),
        1
    );
    assert_eq!(buf[0], b'c');
    assert_eq!(
        r.borrow()
            .read_vectored(&mut [IoSliceMut::new(&mut buf)])
            .unwrap(),
        1
    );
    assert_eq!(buf[0], b'a');
}