Increase test coverage for generic modules

src/event.rs

@@ -1102,3 +1102,206 @@ impl PartialEq for InnerSizeWriter {
         self.new_inner_size.as_ptr() == other.new_inner_size.as_ptr()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::event;
+    use std::collections::{BTreeSet, HashSet};
+
+    macro_rules! foreach_event {
+        ($closure:expr) => {{
+            #[allow(unused_mut)]
+            let mut x = $closure;
+            let did = unsafe { event::DeviceId::dummy() };
+
+            #[allow(deprecated)]
+            {
+                use crate::event::{Event::*, Ime::Enabled, WindowEvent::*};
+                use crate::window::WindowId;
+
+                // Mainline events.
+                let wid = unsafe { WindowId::dummy() };
+                x(UserEvent(()));
+                x(NewEvents(event::StartCause::Init));
+                x(RedrawRequested(wid));
+                x(AboutToWait);
+                x(LoopExiting);
+                x(Suspended);
+                x(Resumed);
+
+                // Window events.
+                let with_window_event = |wev| {
+                    x(WindowEvent {
+                        window_id: wid,
+                        event: wev,
+                    })
+                };
+
+                with_window_event(CloseRequested);
+                with_window_event(Destroyed);
+                with_window_event(Focused(true));
+                with_window_event(Moved((0, 0).into()));
+                with_window_event(Resized((0, 0).into()));
+                with_window_event(DroppedFile("x.txt".into()));
+                with_window_event(HoveredFile("x.txt".into()));
+                with_window_event(HoveredFileCancelled);
+                with_window_event(Ime(Enabled));
+                with_window_event(CursorMoved {
+                    device_id: did,
+                    position: (0, 0).into(),
+                });
+                with_window_event(ModifiersChanged(event::Modifiers::default()));
+                with_window_event(CursorEntered { device_id: did });
+                with_window_event(CursorLeft { device_id: did });
+                with_window_event(MouseWheel {
+                    device_id: did,
+                    delta: event::MouseScrollDelta::LineDelta(0.0, 0.0),
+                    phase: event::TouchPhase::Started,
+                });
+                with_window_event(MouseInput {
+                    device_id: did,
+                    state: event::ElementState::Pressed,
+                    button: event::MouseButton::Other(0),
+                });
+                with_window_event(TouchpadMagnify {
+                    device_id: did,
+                    delta: 0.0,
+                    phase: event::TouchPhase::Started,
+                });
+                with_window_event(SmartMagnify { device_id: did });
+                with_window_event(TouchpadRotate {
+                    device_id: did,
+                    delta: 0.0,
+                    phase: event::TouchPhase::Started,
+                });
+                with_window_event(TouchpadPressure {
+                    device_id: did,
+                    pressure: 0.0,
+                    stage: 0,
+                });
+                with_window_event(AxisMotion {
+                    device_id: did,
+                    axis: 0,
+                    value: 0.0,
+                });
+                with_window_event(Touch(event::Touch {
+                    device_id: did,
+                    phase: event::TouchPhase::Started,
+                    location: (0.0, 0.0).into(),
+                    id: 0,
+                    force: Some(event::Force::Normalized(0.0)),
+                }));
+                with_window_event(ThemeChanged(crate::window::Theme::Light));
+                with_window_event(Occluded(true));
+            }
+
+            #[allow(deprecated)]
+            {
+                use event::DeviceEvent::*;
+
+                let with_device_event = |dev_ev| {
+                    x(event::Event::DeviceEvent {
+                        device_id: did,
+                        event: dev_ev,
+                    })
+                };
+
+                with_device_event(Added);
+                with_device_event(Removed);
+                with_device_event(MouseMotion {
+                    delta: (0.0, 0.0).into(),
+                });
+                with_device_event(MouseWheel {
+                    delta: event::MouseScrollDelta::LineDelta(0.0, 0.0),
+                });
+                with_device_event(Motion {
+                    axis: 0,
+                    value: 0.0,
+                });
+                with_device_event(Button {
+                    button: 0,
+                    state: event::ElementState::Pressed,
+                });
+                with_device_event(Text { codepoint: 'a' });
+            }
+        }};
+    }
+
+    #[allow(clippy::redundant_clone)]
+    #[test]
+    fn test_event_clone() {
+        foreach_event!(|event: event::Event<()>| {
+            let event2 = event.clone();
+            assert_eq!(event, event2);
+        })
+    }
+
+    #[test]
+    fn test_map_nonuser_event() {
+        foreach_event!(|event: event::Event<()>| {
+            let is_user = matches!(event, event::Event::UserEvent(()));
+            let event2 = event.map_nonuser_event::<()>();
+            if is_user {
+                assert_eq!(event2, Err(event::Event::UserEvent(())));
+            } else {
+                assert!(event2.is_ok());
+            }
+        })
+    }
+
+    #[test]
+    fn test_force_normalize() {
+        let force = event::Force::Normalized(0.0);
+        assert_eq!(force.normalized(), 0.0);
+
+        let force2 = event::Force::Calibrated {
+            force: 5.0,
+            max_possible_force: 2.5,
+            altitude_angle: None,
+        };
+        assert_eq!(force2.normalized(), 2.0);
+
+        let force3 = event::Force::Calibrated {
+            force: 5.0,
+            max_possible_force: 2.5,
+            altitude_angle: Some(std::f64::consts::PI / 2.0),
+        };
+        assert_eq!(force3.normalized(), 2.0);
+    }
+
+    #[allow(clippy::clone_on_copy)]
+    #[test]
+    fn ensure_attrs_do_not_panic() {
+        foreach_event!(|event: event::Event<()>| {
+            let _ = format!("{:?}", event);
+        });
+        let _ = event::StartCause::Init.clone();
+
+        let did = unsafe { crate::event::DeviceId::dummy() }.clone();
+        HashSet::new().insert(did);
+        let mut set = [did, did, did];
+        set.sort_unstable();
+        let mut set2 = BTreeSet::new();
+        set2.insert(did);
+        set2.insert(did);
+
+        HashSet::new().insert(event::TouchPhase::Started.clone());
+        HashSet::new().insert(event::MouseButton::Left.clone());
+        HashSet::new().insert(event::Ime::Enabled);
+
+        let _ = event::Touch {
+            device_id: did,
+            phase: event::TouchPhase::Started,
+            location: (0.0, 0.0).into(),
+            id: 0,
+            force: Some(event::Force::Normalized(0.0)),
+        }
+        .clone();
+        let _ = event::Force::Calibrated {
+            force: 0.0,
+            max_possible_force: 0.0,
+            altitude_angle: None,
+        }
+        .clone();
+    }
+}