crack 0.1.0

verify distributed and lock-free algorithms through symbolic execution
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

#[macro_export]
macro_rules! fsm {
    (inner: $INNER:ty, transitions: [($($FROM:ty => ($($TO:ty),*)),*)]) => {
        $(
            impl Decoder for $T {
                type Item = $T;
                type Error = io::Error;

                fn decode(&mut self, buf: &mut BytesMut) -> io::Result<Option<$T>> {
                    println!("decoding message");
                    decode(&buf.take()[..])
                        .map(|v| {
                            println!("successfully decoded {:?}", v);
                            Some(v)
                        })
                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
                }
            }

            impl Encoder for $T {
                type Item = $T;
                type Error = io::Error;

                fn encode(&mut self, msg: $T, buf: &mut BytesMut) -> io::Result<()> {
                    println!("encoding message");
                    buf.put(encode(&msg, SizeLimit::Infinite).unwrap());
                    Ok(())
                }
            }
        )*
    };
}

#[cfg(test)]
mod tests {
    #[test]
    #[ignore]
    fn it_works() {
        struct Inner {
            inner: u64,
        }

        // fsm!{
        // inner: Inner,
        // transitions: [
        // A => [A, B, C],
        // B => [A, C],
        // C => [C],
        // ]
        // }
        //
    }
}