add test coverage

Author: rursprung

src/button_event.rs

@@ -102,3 +102,135 @@ impl ButtonEvent {
         &self.state
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::button_event::{Button, ButtonEvent, ButtonParseError, ButtonState};
+    use crate::ProtocolParseError;
+
+    fn assert_is_button_event(
+        result: &Result<ButtonEvent, ProtocolParseError>,
+        button: Button,
+        button_state: ButtonState,
+    ) {
+        match result {
+            Ok(event) => {
+                assert_eq!(event.button(), &button);
+                assert_eq!(event.state(), &button_state)
+            }
+            _ => assert!(false),
+        }
+    }
+
+    #[test]
+    fn test_parse_button1_pressed_event() {
+        let input: &[u8] = b"11";
+        assert_is_button_event(
+            &ButtonEvent::try_from(input),
+            Button::Button1,
+            ButtonState::Pressed,
+        );
+    }
+
+    #[test]
+    fn test_parse_button1_released_event() {
+        let input: &[u8] = b"11";
+        assert_is_button_event(
+            &ButtonEvent::try_from(input),
+            Button::Button1,
+            ButtonState::Pressed,
+        );
+    }
+
+    #[test]
+    fn test_parse_button2_pressed_event() {
+        let input: &[u8] = b"21";
+        assert_is_button_event(
+            &ButtonEvent::try_from(input),
+            Button::Button2,
+            ButtonState::Pressed,
+        );
+    }
+
+    #[test]
+    fn test_parse_button3_pressed_event() {
+        let input: &[u8] = b"31";
+        assert_is_button_event(
+            &ButtonEvent::try_from(input),
+            Button::Button3,
+            ButtonState::Pressed,
+        );
+    }
+
+    #[test]
+    fn test_parse_button4_pressed_event() {
+        let input: &[u8] = b"41";
+        assert_is_button_event(
+            &ButtonEvent::try_from(input),
+            Button::Button4,
+            ButtonState::Pressed,
+        );
+    }
+
+    #[test]
+    fn test_parse_button_up_pressed_event() {
+        let input: &[u8] = b"51";
+        assert_is_button_event(
+            &ButtonEvent::try_from(input),
+            Button::Up,
+            ButtonState::Pressed,
+        );
+    }
+
+    #[test]
+    fn test_parse_button_down_pressed_event() {
+        let input: &[u8] = b"61";
+        assert_is_button_event(
+            &ButtonEvent::try_from(input),
+            Button::Down,
+            ButtonState::Pressed,
+        );
+    }
+
+    #[test]
+    fn test_parse_button_left_pressed_event() {
+        let input: &[u8] = b"71";
+        assert_is_button_event(
+            &ButtonEvent::try_from(input),
+            Button::Left,
+            ButtonState::Pressed,
+        );
+    }
+
+    #[test]
+    fn test_parse_button_right_pressed_event() {
+        let input: &[u8] = b"81";
+        assert_is_button_event(
+            &ButtonEvent::try_from(input),
+            Button::Right,
+            ButtonState::Pressed,
+        );
+    }
+
+    #[test]
+    fn test_parse_invalid_button() {
+        let input: &[u8] = b"01";
+        assert_eq!(
+            ButtonEvent::try_from(input),
+            Err(ProtocolParseError::ButtonParseError(
+                ButtonParseError::UnknownButton(b'0')
+            ))
+        );
+    }
+
+    #[test]
+    fn test_parse_invalid_button_state() {
+        let input: &[u8] = b"13";
+        assert_eq!(
+            ButtonEvent::try_from(input),
+            Err(ProtocolParseError::ButtonParseError(
+                ButtonParseError::UnknownButtonState(b'3')
+            ))
+        );
+    }
+}

src/color_event.rs

@@ -59,3 +59,36 @@ impl Into<RGB8> for ColorEvent {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::color_event::ColorEvent;
+    #[cfg(feature = "rgb")]
+    use rgb::RGB8;
+
+    #[test]
+    fn test_parse_color_event() {
+        let input: &[u8] = b"\xff-9";
+        let expected = ColorEvent {
+            red: 255,
+            green: 45,
+            blue: 57,
+        };
+
+        assert_eq!(ColorEvent::try_from(input), Ok(expected));
+    }
+
+    #[test]
+    #[cfg(feature = "rgb")]
+    fn test_into_rgb8() {
+        let input = ColorEvent {
+            red: 1,
+            green: 2,
+            blue: 3,
+        };
+        let expected = RGB8 { r: 1, g: 2, b: 3 };
+
+        let result: RGB8 = input.into();
+        assert_eq!(result, expected);
+    }
+}

src/gyro_event.rs

@@ -46,3 +46,20 @@ impl GyroEvent {
         self.z
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::gyro_event::GyroEvent;
+
+    #[test]
+    fn test_parse_gyro_event() {
+        let input: &[u8] = b"H.\xd7;\x0c\xb2\xe8<z\xe62\xbd";
+        let expected = GyroEvent {
+            x: 0.0065667965,
+            y: 0.028405212,
+            z: -0.04367683,
+        };
+
+        assert_eq!(GyroEvent::try_from(input), Ok(expected));
+    }
+}

src/lib.rs

@@ -85,18 +85,22 @@ pub enum ControllerEvent {
 #[derive(PartialEq, Eq, Debug)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum ProtocolParseError {
-    /// The message contained an event which is not known to the current implementation. This can either mean that the message was malformed or that a newer protocol version has been used.
+    /// The message contained an event which is not known to the current implementation.
+    /// This can mean that:
+    /// * the message was malformed or
+    /// * that a newer protocol version has been used or
+    /// * that the event type has not been enabled as a feature.
     UnknownEvent(Option<u8>),
     /// The message contained an event which is known to the library but has not been selected as a feature and can thus not be parsed. Select the feature when compiling the library to handle this message.
     DisabledControllerDataPackageType(ControllerDataPackageType),
     /// An error occurred while parsing a [`ButtonEvent`].
     #[cfg(feature = "button_event")]
     ButtonParseError(ButtonParseError),
-    /// The event in the message did not have the expected length.
+    /// The event in the message did not have the expected length. The first value is the expected length, the second the actual length.
     InvalidLength(usize, usize),
-    /// The event in the message did not have the expected CRC.
+    /// The event in the message did not have the expected CRC. The first value is the expected CRC, the second the actual CRC.
     InvalidCrc(u8, u16),
-    /// There was a problem parsing a float from a message.
+    /// There was a problem parsing a float from a message. The parameter gives the length of the received input.
     InvalidFloatSize(usize),
 }
 
@@ -307,3 +311,74 @@ fn try_f32_from_le_bytes(input: &[u8]) -> Result<f32, ProtocolParseError> {
         |_| ProtocolParseError::InvalidFloatSize(input.len()),
     )?))
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::button_event::{Button, ButtonState};
+    use crate::{check_crc, parse, try_f32_from_le_bytes, ControllerEvent, ProtocolParseError};
+
+    fn assert_is_button_event(
+        event: &Result<ControllerEvent, ProtocolParseError>,
+        button: Button,
+        button_state: ButtonState,
+    ) {
+        match event {
+            Ok(ControllerEvent::ButtonEvent(event)) => {
+                assert_eq!(event.button(), &button);
+                assert_eq!(event.state(), &button_state)
+            }
+            _ => assert!(false),
+        }
+    }
+
+    #[test]
+    fn test_parse() {
+        const MAX_RESULTS: usize = 4;
+        let input = b"\x00!B11:!B10;\x00\x00\x00\x00\x00\x00";
+        let result = parse::<MAX_RESULTS>(input);
+
+        assert_eq!(result.len(), 2);
+        assert_is_button_event(&result[0], Button::Button1, ButtonState::Pressed);
+        assert_is_button_event(&result[1], Button::Button1, ButtonState::Released);
+    }
+
+    #[test]
+    fn test_check_crc_ok() {
+        let input = b"!B11:";
+        let data = &input[0..input.len() - 1];
+        let crc = input.last().unwrap();
+
+        assert!(check_crc(data, &crc).is_ok());
+    }
+
+    #[test]
+    fn test_check_crc_err() {
+        let input = b"!B11;"; // should either be "!B11:" or "!B10;"
+        let correct_crc = b':';
+        let data = &input[0..input.len() - 1];
+        let crc = input.last().unwrap();
+
+        assert_eq!(
+            check_crc(data, &crc),
+            Err(ProtocolParseError::InvalidCrc(*crc, correct_crc as u16))
+        );
+    }
+
+    #[test]
+    fn test_try_f32_from_le_bytes_ok() {
+        let input = b"9\x1e\x0c\xc0";
+        let expected: f32 = -2.1893446;
+
+        assert_eq!(try_f32_from_le_bytes(input), Ok(expected));
+    }
+
+    #[test]
+    fn test_try_f32_from_le_bytes_err() {
+        let input = b"\x1e\x0c\xc0";
+
+        assert_eq!(
+            try_f32_from_le_bytes(input),
+            Err(ProtocolParseError::InvalidFloatSize(3))
+        );
+    }
+}

src/location_event.rs

@@ -46,3 +46,30 @@ impl LocationEvent {
         self.altitude
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::location_event::LocationEvent;
+
+    #[test]
+    fn test_parse_gyro_event() {
+        // as an exception this is not done using a real-world string received via bluetooth as I don't have a mock GPS app installed and don't want my real location in the source code :)
+        let expected_lat = 1.2f32;
+        let expected_lon = 2.3f32;
+        let expected_alt = 3.4f32;
+        let input = [
+            expected_lat.to_le_bytes(),
+            expected_lon.to_le_bytes(),
+            expected_alt.to_le_bytes(),
+        ]
+        .concat();
+
+        let expected = LocationEvent {
+            latitude: expected_lat,
+            longitude: expected_lon,
+            altitude: expected_alt,
+        };
+
+        assert_eq!(LocationEvent::try_from(input.as_slice()), Ok(expected));
+    }
+}

src/magnetometer_event.rs

@@ -46,3 +46,20 @@ impl MagnetometerEvent {
         self.z
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::magnetometer_event::MagnetometerEvent;
+
+    #[test]
+    fn test_parse_gyro_event() {
+        let input: &[u8] = b"\xcd\xcc\x8bA\x00@\x03\xc2\x9a\x19\xcb\xc1";
+        let expected = MagnetometerEvent {
+            x: 17.475,
+            y: -32.8125,
+            z: -25.3875,
+        };
+
+        assert_eq!(MagnetometerEvent::try_from(input), Ok(expected));
+    }
+}

src/quaternion_event.rs

@@ -52,3 +52,21 @@ impl QuaternionEvent {
         self.w
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::quaternion_event::QuaternionEvent;
+
+    #[test]
+    fn test_parse_quaternion_event() {
+        let input: &[u8] = b"9\x1e\x0c\xc03\xf7P\xbf\xefv\x96>\x00\x00\x00\x00";
+        let expected = QuaternionEvent {
+            x: -2.1893446,
+            y: -0.81627196,
+            z: 0.29387614,
+            w: 0.0,
+        };
+
+        assert_eq!(QuaternionEvent::try_from(input), Ok(expected));
+    }
+}