cutlery 0.1.0

Cross-platform fork
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

use std::io::{Read as _, Write as _, pipe, stdout};
use std::process::exit;
use std::thread::sleep;
use std::time::Duration;

use stdio_utils::StdioOverride;

use crate::{Fork, fork, fork_fn};

#[test]
fn test_fork_basic() {
    match fork().unwrap() {
        Fork::Parent(mut child) => {
            let exit_code = child.wait().unwrap();
            assert_eq!(exit_code, 42);
        }
        Fork::Child => {
            exit(42);
        }
    }
}

#[test]
fn test_pid() {
    let (mut r, mut w) = pipe().unwrap();
    let child = fork_fn(move || {
        w.write_all(&std::process::id().to_ne_bytes()).unwrap();
    })
    .unwrap();

    let mut buf = [0; core::mem::size_of::<u32>()];
    r.read_exact(&mut buf).unwrap();
    let pid = u32::from_ne_bytes(buf);

    assert_eq!(pid, child.id());
}

#[test]
fn test_fork_try_wait() {
    match fork().unwrap() {
        Fork::Parent(mut child) => {
            let status = child.try_wait().unwrap();
            assert_eq!(status, None);

            sleep(Duration::from_secs(2));

            let status = child.try_wait().unwrap();
            assert_eq!(status, Some(42));

            let status = child.wait().unwrap();
            assert_eq!(status, 42);
        }
        Fork::Child => {
            sleep(Duration::from_secs(1));
            exit(42);
        }
    }
}

#[test]
fn test_fork_pipe() {
    let (mut r, mut w) = pipe().unwrap();

    match fork().unwrap() {
        Fork::Child => {
            w.write_all(b"hello world").unwrap();
            exit(42);
        }
        Fork::Parent(mut child) => {
            let mut buf = [0; 11];
            r.read_exact(&mut buf).unwrap();

            assert_eq!(&buf, b"hello world");

            child.wait().unwrap();
        }
    }
}

#[test]
fn test_fork_fn() {
    let (mut r, mut w) = pipe().unwrap();

    let mut child = fork_fn(move || {
        w.write_all(b"hello world").unwrap();
    })
    .unwrap();

    let mut buf = [0u8; 11];
    r.read_exact(&mut buf).unwrap();

    assert_eq!(&buf, b"hello world");

    child.wait().unwrap();
}

#[test]
fn test_fork_stdout() {
    let (mut r, w) = pipe().unwrap();

    let _guard = w.override_stdout().unwrap();
    drop(w);

    let mut child = fork_fn(|| {
        // use stdout instead of println to avoid
        // output capturing by rust's test framework
        stdout().write_all(b"hello from child!").unwrap();
    })
    .unwrap();

    drop(_guard);

    let mut buf = vec![];
    r.read_to_end(&mut buf).unwrap();

    assert_eq!(&buf, b"hello from child!");

    child.wait().unwrap();
}