procspawn 1.0.1

thread::spawn just with processes
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

use procspawn::{self, spawn};

procspawn::enable_test_support!();

#[test]
fn test_macro_no_args() {
    let handle = spawn!(() || false);
    let value = handle.join().unwrap();
    assert!(!value);
}

#[test]
fn test_macro_single_arg() {
    let value = 42u32;

    let handle = spawn!((value) || value);
    assert_eq!(handle.join().unwrap(), 42);

    let handle = spawn!((value => new_name) || new_name);
    assert_eq!(handle.join().unwrap(), 42);

    let ref_value = &value;

    let handle = spawn!((*ref_value) || ref_value);
    assert_eq!(handle.join().unwrap(), 42);

    let handle = spawn!((*ref_value => new_name) || new_name);
    assert_eq!(handle.join().unwrap(), 42);

    let handle = spawn!((mut value) || {
        value += 1;
        value
    });
    assert_eq!(handle.join().unwrap(), 43);

    let handle = spawn!((value => mut new_name) || {
        new_name += 1;
        new_name
    });
    assert_eq!(handle.join().unwrap(), 43);
}

#[test]
fn test_macro_two_args() {
    let value1 = 42u32;
    let value2 = 23u32;

    let handle = spawn!((value1, value2) || value1 + value2);
    assert_eq!(handle.join().unwrap(), 42 + 23);

    let handle = spawn!((value1 => new_name1, value2) || new_name1 + value2);
    assert_eq!(handle.join().unwrap(), 42 + 23);

    let ref_value = &value1;

    let handle = spawn!((*ref_value, value2) || ref_value + value2);
    assert_eq!(handle.join().unwrap(), 42 + 23);

    let handle = spawn!((*ref_value => new_name, value2) || new_name + value2);
    assert_eq!(handle.join().unwrap(), 42 + 23);

    let handle = spawn!((mut value1, value2) || {
        value1 += 1;
        value1 + value2
    });
    assert_eq!(handle.join().unwrap(), 43 + 23);

    let handle = spawn!((value1 => mut new_name, value2) || {
        new_name += 1;
        new_name + value2
    });
    assert_eq!(handle.join().unwrap(), 43 + 23);
}

#[test]
fn test_macro_three_args() {
    let value1 = 42u32;
    let value2 = 23u32;
    let value3 = 99u32;

    let handle = spawn!((value1, value2, value3) || value1 + value2 + value3);
    assert_eq!(handle.join().unwrap(), 42 + 23 + 99);

    let handle = spawn!((value1 => new_name1, value2, value3) || new_name1 + value2 + value3);
    assert_eq!(handle.join().unwrap(), 42 + 23 + 99);

    let ref_value = &value1;

    let handle = spawn!((*ref_value, value2, value3) || ref_value + value2 + value3);
    assert_eq!(handle.join().unwrap(), 42 + 23 + 99);

    let handle = spawn!((*ref_value => new_name, value2, value3) || new_name + value2 + value3);
    assert_eq!(handle.join().unwrap(), 42 + 23 + 99);

    let handle = spawn!((mut value1, value2, value3) || {
        value1 += 1;
        value1 + value2 + value3
    });
    assert_eq!(handle.join().unwrap(), 43 + 23 + 99);

    let handle = spawn!((value1 => mut new_name, value2, value3) || {
        new_name += 1;
        new_name + value2 + value3
    });
    assert_eq!(handle.join().unwrap(), 43 + 23 + 99);
}

#[test]
fn test_macro_three_args_rv() {
    let value1 = 42u32;
    let value2 = 23u32;
    let value3 = 99u32;

    let handle =
        spawn!((value1, value2, value3) || -> Option<_> { Some(value1 + value2 + value3) });
    assert_eq!(handle.join().unwrap(), Some(42 + 23 + 99));

    let handle = spawn!((value1 => new_name1, value2, value3) || -> Option<_> { Some(new_name1 + value2 + value3) });
    assert_eq!(handle.join().unwrap(), Some(42 + 23 + 99));
}