add SetDutyCycle mock

this is the 1.0 equivalent of the old `PwmPin` trait (the mock for this
has been added in dbrgn#52).

note that the test coverage is fully handled by the doc test which is
why there's no additional `mod test` in this file.

this fixes dbrgn#73

CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ## Unreleased
 
 ### Added
+- Implement mock for `embedded_hal::pwm::SetDutyCycle`
 
 ### Fixed
 

src/eh1.rs

@@ -10,5 +10,6 @@ pub use crate::eh1::error::MockError;
 pub mod delay;
 pub mod i2c;
 pub mod pin;
+pub mod pwm;
 pub mod serial;
 pub mod spi;

src/eh1/pin.rs

@@ -1,7 +1,7 @@
-//! Mock digital [`InputPin`] and [`OutputPin`] v2 implementations
+//! Mock digital [`InputPin`] and [`OutputPin`] implementations
 //!
-//! [`InputPin`]: https://docs.rs/embedded-hal/1.0.0-alpha.6/embedded_hal/digital/trait.InputPin.html
-//! [`OutputPin`]: https://docs.rs/embedded-hal/1.0.0-alpha.6/embedded_hal/digital/trait.OutputPin.html
+//! [`InputPin`]: https://docs.rs/embedded-hal/1.0.0-rc.1/embedded_hal/digital/trait.InputPin.html
+//! [`OutputPin`]: https://docs.rs/embedded-hal/1.0.0-rc.1/embedded_hal/digital/trait.OutputPin.html
 //!
 //! ```
 //! # use eh1 as embedded_hal;

src/eh1/pwm.rs

@@ -0,0 +1,127 @@
+//! Mock implementations for
+//! [`embedded_hal::pwm`](https://docs.rs/embedded-hal/1.0.0-rc.1/embedded_hal/pwm/index.html).
+//!
+//! Usage example:
+//! ```
+//! use std::io::ErrorKind;
+//!
+//! # use eh1 as embedded_hal;
+//! use embedded_hal::pwm::SetDutyCycle;
+//! use embedded_hal_mock::eh1::{
+//!     pwm::{Mock as PwmMock, Transaction as PwmTransaction},
+//!     MockError,
+//! };
+//!
+//! // Configure expectations
+//! let expectations = [
+//!     PwmTransaction::get_max_duty_cycle(100),
+//!     PwmTransaction::set_duty_cycle(50),
+//!     PwmTransaction::set_duty_cycle(101).with_error(MockError::Io(ErrorKind::NotConnected)),
+//! ];
+//!
+//! // Create pin
+//! let mut pwm = PwmMock::new(&expectations);
+//!
+//! // Run and test
+//! pwm.set_duty_cycle_percent(50).unwrap();
+//! pwm.set_duty_cycle(101).expect_err("expected error return");
+//!
+//! // Finalise expectations
+//! pwm.done();
+//! ```
+
+use eh1::pwm::{ErrorKind, ErrorType, SetDutyCycle};
+
+use crate::{common::Generic, eh1::MockError};
+
+/// MockPwm transaction
+#[derive(PartialEq, Clone, Debug)]
+pub struct Transaction {
+    /// Kind is the transaction kind (and data) expected
+    kind: TransactionKind,
+    /// Err is an optional error return for a transaction.
+    /// This is in addition to kind to allow validation that the transaction kind
+    /// is correct prior to returning the error.
+    err: Option<MockError>,
+}
+
+impl Transaction {
+    /// Create a new PWM transaction
+    pub fn new(kind: TransactionKind) -> Transaction {
+        Transaction { kind, err: None }
+    }
+
+    /// Create a new [`TransactionKind::GetMaxDutyCycle`] transaction for [`SetDutyCycle::get_max_duty_cycle`].
+    pub fn get_max_duty_cycle(duty: u16) -> Transaction {
+        Transaction::new(TransactionKind::GetMaxDutyCycle(duty))
+    }
+
+    /// Create a new [`TransactionKind::SetDutyCycle`] transaction for [`SetDutyCycle::set_duty_cycle`].
+    pub fn set_duty_cycle(duty: u16) -> Transaction {
+        Transaction::new(TransactionKind::SetDutyCycle(duty))
+    }
+
+    /// Add an error return to a transaction
+    ///
+    /// This is used to mock failure behaviours.
+    pub fn with_error(mut self, error: MockError) -> Self {
+        self.err = Some(error);
+        self
+    }
+}
+
+/// MockPwm transaction kind
+#[derive(PartialEq, Clone, Debug)]
+pub enum TransactionKind {
+    /// [`SetDutyCycle::get_max_duty_cycle`] which will return the defined duty.
+    GetMaxDutyCycle(u16),
+    /// [`SetDutyCycle::set_duty_cycle`] with the expected duty.
+    SetDutyCycle(u16),
+}
+
+/// Mock PWM `SetDutyCycle` implementation
+pub type Mock = Generic<Transaction>;
+
+impl eh1::pwm::Error for MockError {
+    fn kind(&self) -> ErrorKind {
+        ErrorKind::Other
+    }
+}
+
+impl ErrorType for Mock {
+    type Error = MockError;
+}
+
+impl SetDutyCycle for Mock {
+    fn get_max_duty_cycle(&self) -> u16 {
+        let mut s = self.clone();
+
+        let Transaction { kind, err } = s
+            .next()
+            .expect("no expectation for get_max_duty_cycle call");
+
+        assert_eq!(err, None, "error not supported by get_max_duty_cycle!");
+
+        match kind {
+            TransactionKind::GetMaxDutyCycle(duty) => duty,
+            other => panic!("expected get_max_duty_cycle, got {:?}", other),
+        }
+    }
+
+    fn set_duty_cycle(&mut self, duty: u16) -> Result<(), Self::Error> {
+        let Transaction { kind, err } =
+            self.next().expect("no expectation for set_duty_cycle call");
+
+        assert_eq!(
+            kind,
+            TransactionKind::SetDutyCycle(duty),
+            "expected set_duty_cycle"
+        );
+
+        if let Some(e) = err {
+            Err(e)
+        } else {
+            Ok(())
+        }
+    }
+}