dfir_rs 0.16.0

DFIR runtime for Rust, used by Hydro.
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
123
124
125
126
127

use dfir_rs::dfir_syntax;
use dfir_rs::util::collect_ready;
use dfir_rs::util::demux_enum::DemuxEnum;
use multiplatform_test::multiplatform_test;

#[multiplatform_test]
pub fn test_demux_enum_basic() {
    #[derive(DemuxEnum)]
    enum Shape {
        Square(f64),
        Rectangle { w: f64, h: f64 },
        Circle { r: f64 },
    }

    let mut df = dfir_syntax! {
        my_demux = source_iter([
            Shape::Square(9.0),
            Shape::Rectangle { w: 10.0, h: 8.0 },
            Shape::Circle { r: 5.0 },
        ]) -> demux_enum::<Shape>();

        my_demux[Square] -> for_each(drop);
        my_demux[Circle] -> for_each(drop);
        my_demux[Rectangle] -> for_each(drop);
    };
    df.run_available_sync();
}

#[multiplatform_test]
pub fn test_demux_enum() {
    let (out_send, out_recv) = dfir_rs::util::unbounded_channel();

    #[derive(DemuxEnum)]
    enum Shape {
        Square(f64),
        Rectangle { w: f64, h: f64 },
        Circle { r: f64 },
    }

    let mut df = dfir_syntax! {
        my_demux = source_iter([
            Shape::Square(9.0),
            Shape::Rectangle { w: 10.0, h: 8.0 },
            Shape::Circle { r: 5.0 },
        ]) -> demux_enum::<Shape>();

        my_demux[Square] -> map(|(s,)| s * s) -> out;
        my_demux[Circle] -> map(|(r,)| std::f64::consts::PI * r * r) -> out;
        my_demux[Rectangle] -> map(|(w, h)| w * h) -> out;

        out = union()
            -> map(|area| format!("{:.2}", area))
            -> for_each(|area_str| out_send.send(area_str).unwrap());
    };
    df.run_available_sync();

    let areas = collect_ready::<Vec<_>, _>(out_recv);
    assert_eq!(&["81.00", "78.54", "80.00"], &*areas);
}

#[multiplatform_test]
pub fn test_demux_enum_generic() {
    #[derive(DemuxEnum)]
    enum Shape<N> {
        Square(N),
        Rectangle { w: N, h: N },
        Circle { r: N },
    }

    fn test<N>(s: N, w: N, h: N, r: N, expected: &[&str])
    where
        N: 'static + Into<f64>,
    {
        let (out_send, out_recv) = dfir_rs::util::unbounded_channel();

        let mut df = dfir_syntax! {
            my_demux = source_iter([
                Shape::Square(s),
                Shape::Rectangle { w, h },
                Shape::Circle { r },
            ]) -> demux_enum::<Shape<N>>();

            my_demux[Square] -> map(|(s,)| s.into()) -> map(|s| s * s) -> out;
            my_demux[Circle] -> map(|(r,)| r.into()) -> map(|r| std::f64::consts::PI * r * r) -> out;
            my_demux[Rectangle] -> map(|(w, h)| w.into() * h.into()) -> out;

            out = union()
                -> map(|area| format!("{:.2}", area))
                -> for_each(|area_str| out_send.send(area_str).unwrap());
        };
        df.run_available_sync();

        let areas = collect_ready::<Vec<_>, _>(out_recv);
        assert_eq!(expected, &*areas);
    }
    test::<f32>(9., 10., 8., 5., &["81.00", "78.54", "80.00"]);
    test::<u32>(9, 10, 8, 5, &["81.00", "78.54", "80.00"]);
}

#[multiplatform_test]
fn test_zero_variants() {
    #[derive(DemuxEnum)]
    enum Never {}

    let mut df = dfir_syntax! {
        source_iter(std::iter::empty::<Never>()) -> demux_enum::<Never>();
    };
    df.run_available_sync();
}

#[multiplatform_test]
fn test_one_variant() {
    #[derive(DemuxEnum)]
    enum Request<T> {
        OnlyMessage(T),
    }

    let (out_send, out_recv) = dfir_rs::util::unbounded_channel();

    let mut df = dfir_syntax! {
        input = source_iter([Request::OnlyMessage("hi")]) -> demux_enum::<Request<&'static str>>();
        input[OnlyMessage] -> for_each(|(msg,)| out_send.send(msg).unwrap());
    };
    df.run_available_sync();

    assert_eq!(&["hi"], &*collect_ready::<Vec<_>, _>(out_recv));
}