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

use crate::error::FuzzedError;
use crate::shared_data::FuzzData;
use core::marker::PhantomData;
use embedded_hal::digital::v2::{InputPin, OutputPin};

/// A fuzzed backend for the digital input trait.
pub struct InputPinFuzz<'a, E: FuzzedError<'a>> {
    data: FuzzData<'a>,
    _e: PhantomData<E>,
}

impl<'a, E: FuzzedError<'a>> InputPinFuzz<'a, E> {
    pub fn new(data: FuzzData<'a>) -> Self {
        InputPinFuzz {
            data,
            _e: PhantomData,
        }
    }

    fn pin_state(&self) -> Result<bool, E> {
        // Randomly create an error.
        let mut data = match self.data.iter.lock() {
            Ok(data) => data,
            Err(_) => return Err(Default::default()),
        };
        if let Some(err) = E::new_err(&mut *data) {
            return Err(err);
        }
        match data.next() {
            Some(x) if *x > 128 => Ok(false),
            _ => Ok(true),
        }
    }
}

impl<'a, E: FuzzedError<'a>> InputPin for InputPinFuzz<'a, E> {
    type Error = E;

    fn is_high(&self) -> Result<bool, Self::Error> {
        self.pin_state()
    }

    fn is_low(&self) -> Result<bool, Self::Error> {
        self.pin_state()
    }
}

/// A fuzzed backend for the digital input trait.
pub struct OutputPinFuzz<'a, E: FuzzedError<'a>> {
    data: FuzzData<'a>,
    _e: PhantomData<E>,
}

impl<'a, E: FuzzedError<'a>> OutputPinFuzz<'a, E> {
    pub fn new(data: FuzzData<'a>) -> Self {
        OutputPinFuzz {
            data,
            _e: PhantomData,
        }
    }

    fn potential_error(&self) -> Result<(), E> {
        // Randomly create an error.
        let mut data = match self.data.iter.lock() {
            Ok(data) => data,
            Err(_) => return Err(Default::default()),
        };
        if let Some(err) = E::new_err(&mut *data) {
            return Err(err);
        }
        Ok(())
    }
}

impl<'a, E: FuzzedError<'a>> OutputPin for OutputPinFuzz<'a, E> {
    type Error = E;

    fn set_low(&mut self) -> Result<(), Self::Error> {
        // set_low is an output, so we ignore it here.
        // Potentially create an error.
        self.potential_error()
    }
    fn set_high(&mut self) -> Result<(), Self::Error> {
        // set_high is an output, so we ignore it here.
        // Potentially create an error.
        self.potential_error()
    }
}