mirror of
https://github.com/italicsjenga/winit-sonoma-fix.git
synced 2024-12-23 13:51:30 +11:00
Increase test coverage for generic modules
This commit is contained in:
parent
57fad2ce15
commit
8a7e18aaf0
418
src/dpi.rs
418
src/dpi.rs
|
@ -581,3 +581,421 @@ impl<P: Pixel> From<LogicalPosition<P>> for Position {
|
|||
Position::Logical(position.cast())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::dpi;
|
||||
use std::collections::HashSet;
|
||||
|
||||
macro_rules! test_pixel_int_impl {
|
||||
($($name:ident => $ty:ty),*) => {$(
|
||||
#[test]
|
||||
fn $name() {
|
||||
use dpi::Pixel;
|
||||
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::from_f64(37.0),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::from_f64(37.4),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::from_f64(37.5),
|
||||
38,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::from_f64(37.9),
|
||||
38,
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<u8>(37),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<u16>(37),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<u32>(37),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<i8>(37),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<i16>(37),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<i32>(37),
|
||||
37,
|
||||
);
|
||||
}
|
||||
)*};
|
||||
}
|
||||
|
||||
test_pixel_int_impl! {
|
||||
test_pixel_int_u8 => u8,
|
||||
test_pixel_int_u16 => u16,
|
||||
test_pixel_int_u32 => u32,
|
||||
test_pixel_int_i8 => i8,
|
||||
test_pixel_int_i16 => i16
|
||||
}
|
||||
|
||||
macro_rules! assert_approx_eq {
|
||||
($a:expr, $b:expr $(,)?) => {
|
||||
assert!(
|
||||
($a - $b).abs() < 0.001,
|
||||
"{} is not approximately equal to {}",
|
||||
$a,
|
||||
$b
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! test_pixel_float_impl {
|
||||
($($name:ident => $ty:ty),*) => {$(
|
||||
#[test]
|
||||
fn $name() {
|
||||
use dpi::Pixel;
|
||||
|
||||
assert_approx_eq!(
|
||||
<$ty as Pixel>::from_f64(37.0),
|
||||
37.0,
|
||||
);
|
||||
assert_approx_eq!(
|
||||
<$ty as Pixel>::from_f64(37.4),
|
||||
37.4,
|
||||
);
|
||||
assert_approx_eq!(
|
||||
<$ty as Pixel>::from_f64(37.5),
|
||||
37.5,
|
||||
);
|
||||
assert_approx_eq!(
|
||||
<$ty as Pixel>::from_f64(37.9),
|
||||
37.9,
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<u8>(37.0),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<u8>(37.4),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<u8>(37.5),
|
||||
38,
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<u16>(37.0),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<u16>(37.4),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<u16>(37.5),
|
||||
38,
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<u32>(37.0),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<u32>(37.4),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<u32>(37.5),
|
||||
38,
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<i8>(37.0),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<i8>(37.4),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<i8>(37.5),
|
||||
38,
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<i16>(37.0),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<i16>(37.4),
|
||||
37,
|
||||
);
|
||||
assert_eq!(
|
||||
<$ty as Pixel>::cast::<i16>(37.5),
|
||||
38,
|
||||
);
|
||||
}
|
||||
)*};
|
||||
}
|
||||
|
||||
test_pixel_float_impl! {
|
||||
test_pixel_float_f32 => f32,
|
||||
test_pixel_float_f64 => f64
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_validate_scale_factor() {
|
||||
assert!(dpi::validate_scale_factor(1.0));
|
||||
assert!(dpi::validate_scale_factor(2.0));
|
||||
assert!(dpi::validate_scale_factor(3.0));
|
||||
assert!(dpi::validate_scale_factor(1.5));
|
||||
assert!(dpi::validate_scale_factor(0.5));
|
||||
|
||||
assert!(!dpi::validate_scale_factor(0.0));
|
||||
assert!(!dpi::validate_scale_factor(-1.0));
|
||||
assert!(!dpi::validate_scale_factor(f64::INFINITY));
|
||||
assert!(!dpi::validate_scale_factor(f64::NAN));
|
||||
assert!(!dpi::validate_scale_factor(f64::NEG_INFINITY));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_logical_position() {
|
||||
let log_pos = dpi::LogicalPosition::new(1.0, 2.0);
|
||||
assert_eq!(
|
||||
log_pos.to_physical::<u32>(1.0),
|
||||
dpi::PhysicalPosition::new(1, 2)
|
||||
);
|
||||
assert_eq!(
|
||||
log_pos.to_physical::<u32>(2.0),
|
||||
dpi::PhysicalPosition::new(2, 4)
|
||||
);
|
||||
assert_eq!(log_pos.cast::<u32>(), dpi::LogicalPosition::new(1, 2));
|
||||
assert_eq!(
|
||||
log_pos,
|
||||
dpi::LogicalPosition::from_physical(dpi::PhysicalPosition::new(1.0, 2.0), 1.0)
|
||||
);
|
||||
assert_eq!(
|
||||
log_pos,
|
||||
dpi::LogicalPosition::from_physical(dpi::PhysicalPosition::new(2.0, 4.0), 2.0)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::LogicalPosition::from((2.0, 2.0)),
|
||||
dpi::LogicalPosition::new(2.0, 2.0)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::LogicalPosition::from([2.0, 3.0]),
|
||||
dpi::LogicalPosition::new(2.0, 3.0)
|
||||
);
|
||||
|
||||
let x: (f64, f64) = log_pos.into();
|
||||
assert_eq!(x, (1.0, 2.0));
|
||||
let x: [f64; 2] = log_pos.into();
|
||||
assert_eq!(x, [1.0, 2.0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_physical_position() {
|
||||
assert_eq!(
|
||||
dpi::PhysicalPosition::from_logical(dpi::LogicalPosition::new(1.0, 2.0), 1.0),
|
||||
dpi::PhysicalPosition::new(1, 2)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::PhysicalPosition::from_logical(dpi::LogicalPosition::new(2.0, 4.0), 0.5),
|
||||
dpi::PhysicalPosition::new(1, 2)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::PhysicalPosition::from((2.0, 2.0)),
|
||||
dpi::PhysicalPosition::new(2.0, 2.0)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::PhysicalPosition::from([2.0, 3.0]),
|
||||
dpi::PhysicalPosition::new(2.0, 3.0)
|
||||
);
|
||||
|
||||
let x: (f64, f64) = dpi::PhysicalPosition::new(1, 2).into();
|
||||
assert_eq!(x, (1.0, 2.0));
|
||||
let x: [f64; 2] = dpi::PhysicalPosition::new(1, 2).into();
|
||||
assert_eq!(x, [1.0, 2.0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_logical_size() {
|
||||
let log_size = dpi::LogicalSize::new(1.0, 2.0);
|
||||
assert_eq!(
|
||||
log_size.to_physical::<u32>(1.0),
|
||||
dpi::PhysicalSize::new(1, 2)
|
||||
);
|
||||
assert_eq!(
|
||||
log_size.to_physical::<u32>(2.0),
|
||||
dpi::PhysicalSize::new(2, 4)
|
||||
);
|
||||
assert_eq!(log_size.cast::<u32>(), dpi::LogicalSize::new(1, 2));
|
||||
assert_eq!(
|
||||
log_size,
|
||||
dpi::LogicalSize::from_physical(dpi::PhysicalSize::new(1.0, 2.0), 1.0)
|
||||
);
|
||||
assert_eq!(
|
||||
log_size,
|
||||
dpi::LogicalSize::from_physical(dpi::PhysicalSize::new(2.0, 4.0), 2.0)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::LogicalSize::from((2.0, 2.0)),
|
||||
dpi::LogicalSize::new(2.0, 2.0)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::LogicalSize::from([2.0, 3.0]),
|
||||
dpi::LogicalSize::new(2.0, 3.0)
|
||||
);
|
||||
|
||||
let x: (f64, f64) = log_size.into();
|
||||
assert_eq!(x, (1.0, 2.0));
|
||||
let x: [f64; 2] = log_size.into();
|
||||
assert_eq!(x, [1.0, 2.0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_physical_size() {
|
||||
assert_eq!(
|
||||
dpi::PhysicalSize::from_logical(dpi::LogicalSize::new(1.0, 2.0), 1.0),
|
||||
dpi::PhysicalSize::new(1, 2)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::PhysicalSize::from_logical(dpi::LogicalSize::new(2.0, 4.0), 0.5),
|
||||
dpi::PhysicalSize::new(1, 2)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::PhysicalSize::from((2.0, 2.0)),
|
||||
dpi::PhysicalSize::new(2.0, 2.0)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::PhysicalSize::from([2.0, 3.0]),
|
||||
dpi::PhysicalSize::new(2.0, 3.0)
|
||||
);
|
||||
|
||||
let x: (f64, f64) = dpi::PhysicalSize::new(1, 2).into();
|
||||
assert_eq!(x, (1.0, 2.0));
|
||||
let x: [f64; 2] = dpi::PhysicalSize::new(1, 2).into();
|
||||
assert_eq!(x, [1.0, 2.0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_size() {
|
||||
assert_eq!(
|
||||
dpi::Size::new(dpi::PhysicalSize::new(1, 2)),
|
||||
dpi::Size::Physical(dpi::PhysicalSize::new(1, 2))
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::Size::new(dpi::LogicalSize::new(1.0, 2.0)),
|
||||
dpi::Size::Logical(dpi::LogicalSize::new(1.0, 2.0))
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
dpi::Size::new(dpi::PhysicalSize::new(1, 2)).to_logical::<f64>(1.0),
|
||||
dpi::LogicalSize::new(1.0, 2.0)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::Size::new(dpi::PhysicalSize::new(1, 2)).to_logical::<f64>(2.0),
|
||||
dpi::LogicalSize::new(0.5, 1.0)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::Size::new(dpi::LogicalSize::new(1.0, 2.0)).to_logical::<f64>(1.0),
|
||||
dpi::LogicalSize::new(1.0, 2.0)
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
dpi::Size::new(dpi::PhysicalSize::new(1, 2)).to_physical::<u32>(1.0),
|
||||
dpi::PhysicalSize::new(1, 2)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::Size::new(dpi::PhysicalSize::new(1, 2)).to_physical::<u32>(2.0),
|
||||
dpi::PhysicalSize::new(1, 2)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::Size::new(dpi::LogicalSize::new(1.0, 2.0)).to_physical::<u32>(1.0),
|
||||
dpi::PhysicalSize::new(1, 2)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::Size::new(dpi::LogicalSize::new(1.0, 2.0)).to_physical::<u32>(2.0),
|
||||
dpi::PhysicalSize::new(2, 4)
|
||||
);
|
||||
|
||||
let small = dpi::Size::Physical((1, 2).into());
|
||||
let medium = dpi::Size::Logical((3, 4).into());
|
||||
let medium_physical = dpi::Size::new(medium.to_physical::<u32>(1.0));
|
||||
let large = dpi::Size::Physical((5, 6).into());
|
||||
assert_eq!(dpi::Size::clamp(medium, small, large, 1.0), medium_physical);
|
||||
assert_eq!(dpi::Size::clamp(small, medium, large, 1.0), medium_physical);
|
||||
assert_eq!(dpi::Size::clamp(large, small, medium, 1.0), medium_physical);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_position() {
|
||||
assert_eq!(
|
||||
dpi::Position::new(dpi::PhysicalPosition::new(1, 2)),
|
||||
dpi::Position::Physical(dpi::PhysicalPosition::new(1, 2))
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::Position::new(dpi::LogicalPosition::new(1.0, 2.0)),
|
||||
dpi::Position::Logical(dpi::LogicalPosition::new(1.0, 2.0))
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
dpi::Position::new(dpi::PhysicalPosition::new(1, 2)).to_logical::<f64>(1.0),
|
||||
dpi::LogicalPosition::new(1.0, 2.0)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::Position::new(dpi::PhysicalPosition::new(1, 2)).to_logical::<f64>(2.0),
|
||||
dpi::LogicalPosition::new(0.5, 1.0)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::Position::new(dpi::LogicalPosition::new(1.0, 2.0)).to_logical::<f64>(1.0),
|
||||
dpi::LogicalPosition::new(1.0, 2.0)
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
dpi::Position::new(dpi::PhysicalPosition::new(1, 2)).to_physical::<u32>(1.0),
|
||||
dpi::PhysicalPosition::new(1, 2)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::Position::new(dpi::PhysicalPosition::new(1, 2)).to_physical::<u32>(2.0),
|
||||
dpi::PhysicalPosition::new(1, 2)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::Position::new(dpi::LogicalPosition::new(1.0, 2.0)).to_physical::<u32>(1.0),
|
||||
dpi::PhysicalPosition::new(1, 2)
|
||||
);
|
||||
assert_eq!(
|
||||
dpi::Position::new(dpi::LogicalPosition::new(1.0, 2.0)).to_physical::<u32>(2.0),
|
||||
dpi::PhysicalPosition::new(2, 4)
|
||||
);
|
||||
}
|
||||
|
||||
// Eat coverage for the Debug impls et al
|
||||
#[test]
|
||||
fn ensure_attrs_do_not_panic() {
|
||||
let _ = format!("{:?}", dpi::LogicalPosition::<u32>::default().clone());
|
||||
HashSet::new().insert(dpi::LogicalPosition::<u32>::default());
|
||||
|
||||
let _ = format!("{:?}", dpi::PhysicalPosition::<u32>::default().clone());
|
||||
HashSet::new().insert(dpi::PhysicalPosition::<u32>::default());
|
||||
|
||||
let _ = format!("{:?}", dpi::LogicalSize::<u32>::default().clone());
|
||||
HashSet::new().insert(dpi::LogicalSize::<u32>::default());
|
||||
|
||||
let _ = format!("{:?}", dpi::PhysicalSize::<u32>::default().clone());
|
||||
HashSet::new().insert(dpi::PhysicalSize::<u32>::default());
|
||||
|
||||
let _ = format!("{:?}", dpi::Size::Physical((1, 2).into()).clone());
|
||||
let _ = format!("{:?}", dpi::Position::Physical((1, 2).into()).clone());
|
||||
}
|
||||
}
|
||||
|
|
22
src/error.rs
22
src/error.rs
|
@ -109,3 +109,25 @@ impl error::Error for OsError {}
|
|||
impl error::Error for ExternalError {}
|
||||
impl error::Error for NotSupportedError {}
|
||||
impl error::Error for RunLoopError {}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#![allow(clippy::redundant_clone)]
|
||||
|
||||
use super::*;
|
||||
|
||||
// Eat attributes for testing
|
||||
#[test]
|
||||
fn ensure_fmt_does_not_panic() {
|
||||
let _ = format!(
|
||||
"{:?}, {}",
|
||||
NotSupportedError::new(),
|
||||
NotSupportedError::new().clone()
|
||||
);
|
||||
let _ = format!(
|
||||
"{:?}, {}",
|
||||
ExternalError::NotSupported(NotSupportedError::new()),
|
||||
ExternalError::NotSupported(NotSupportedError::new())
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
203
src/event.rs
203
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();
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue