path: root/libs/input/rust/input_verifier.rs

/*
 * Copyright 2023 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

//! Contains the InputVerifier, used to validate a stream of input events.

use crate::ffi::RustPointerProperties;
use crate::input::{DeviceId, MotionAction, MotionButton, MotionFlags, Source, SourceClass};
use log::info;
use std::collections::HashMap;
use std::collections::HashSet;

/// Represents a movement or state change event from a pointer device. The Rust equivalent of the
/// C++ NotifyMotionArgs struct.
#[derive(Clone, Copy)]
pub struct NotifyMotionArgs<'a> {
    /// The ID of the device that emitted the event.
    pub device_id: DeviceId,

    /// The type of device that emitted the event.
    pub source: Source,

    /// The type of event that took place.
    pub action: MotionAction,

    /// The properties of each of the pointers involved in the event.
    pub pointer_properties: &'a [RustPointerProperties],

    /// Flags applied to the event.
    pub flags: MotionFlags,

    /// The set of buttons that were pressed at the time of the event.
    ///
    /// We allow DOWN events to include buttons in their state for which BUTTON_PRESS events haven't
    /// been sent yet. In that case, the DOWN should be immediately followed by BUTTON_PRESS events
    /// for those buttons, building up to a button state matching that of the DOWN. For example, if
    /// the user presses the primary and secondary buttons at exactly the same time, we'd expect
    /// this sequence:
    ///
    /// | Action         | Action button | Button state           |
    /// |----------------|---------------|------------------------|
    /// | `HOVER_EXIT`   | -             | -                      |
    /// | `DOWN`         | -             | `PRIMARY`, `SECONDARY` |
    /// | `BUTTON_PRESS` | `PRIMARY`     | `PRIMARY`              |
    /// | `BUTTON_PRESS` | `SECONDARY`   | `PRIMARY`, `SECONDARY` |
    /// | `MOVE`         | -             | `PRIMARY`, `SECONDARY` |
    pub button_state: MotionButton,
}

/// Verifies the properties of an event that should always be true, regardless of the current state.
fn verify_event(event: NotifyMotionArgs<'_>, verify_buttons: bool) -> Result<(), String> {
    let pointer_count = event.pointer_properties.len();
    if pointer_count < 1 {
        return Err(format!("Invalid {} event: no pointers", event.action));
    }
    match event.action {
        MotionAction::Down
        | MotionAction::HoverEnter
        | MotionAction::HoverExit
        | MotionAction::HoverMove
        | MotionAction::Up => {
            if pointer_count != 1 {
                return Err(format!(
                    "Invalid {} event: there are {} pointers in the event",
                    event.action, pointer_count
                ));
            }
        }

        MotionAction::Cancel => {
            if !event.flags.contains(MotionFlags::CANCELED) {
                return Err(format!(
                    "For ACTION_CANCEL, must set FLAG_CANCELED. Received flags: {:#?}",
                    event.flags
                ));
            }
        }

        MotionAction::PointerDown { action_index } | MotionAction::PointerUp { action_index } => {
            if action_index >= pointer_count {
                return Err(format!(
                    "Got {}, but event has {} pointer(s)",
                    event.action, pointer_count
                ));
            }
        }

        MotionAction::ButtonPress { action_button }
        | MotionAction::ButtonRelease { action_button } => {
            if verify_buttons {
                let button_count = action_button.iter().count();
                if button_count != 1 {
                    return Err(format!(
                        "Invalid {} event: must specify a single action button, not {} action \
                         buttons",
                        event.action, button_count
                    ));
                }
            }
        }

        _ => {}
    }
    Ok(())
}

/// Keeps track of the button state for a single device and verifies events against it.
#[derive(Default)]
struct ButtonVerifier {
    /// The current button state of the device.
    button_state: MotionButton,

    /// The set of "pending buttons", which were seen in the last DOWN event's button state but
    /// for which we haven't seen BUTTON_PRESS events yet (see [`NotifyMotionArgs::button_state`]).
    pending_buttons: MotionButton,
}

impl ButtonVerifier {
    pub fn process_event(&mut self, event: NotifyMotionArgs<'_>) -> Result<(), String> {
        if !self.pending_buttons.is_empty() {
            // We just saw a DOWN with some additional buttons in its state, so it should be
            // immediately followed by ButtonPress events for those buttons.
            match event.action {
                MotionAction::ButtonPress { action_button }
                    if self.pending_buttons.contains(action_button) =>
                {
                    self.pending_buttons -= action_button;
                }
                _ => {
                    return Err(format!(
                        "After DOWN event, expected BUTTON_PRESS event(s) for {:?}, but got {}",
                        self.pending_buttons, event.action
                    ));
                }
            }
        }
        let expected_state = match event.action {
            MotionAction::Down => {
                if self.button_state - event.button_state != MotionButton::empty() {
                    return Err(format!(
                        "DOWN event button state is missing {:?}",
                        self.button_state - event.button_state
                    ));
                }
                self.pending_buttons = event.button_state - self.button_state;
                // We've already checked that the state isn't missing any already-down buttons, and
                // extra buttons are valid on DOWN actions, so bypass the expected state check.
                event.button_state
            }
            MotionAction::ButtonPress { action_button } => {
                if self.button_state.contains(action_button) {
                    return Err(format!(
                        "Duplicate BUTTON_PRESS; button state already contains {action_button:?}"
                    ));
                }
                self.button_state | action_button
            }
            MotionAction::ButtonRelease { action_button } => {
                if !self.button_state.contains(action_button) {
                    return Err(format!(
                        "Invalid BUTTON_RELEASE; button state doesn't contain {action_button:?}",
                    ));
                }
                self.button_state - action_button
            }
            _ => self.button_state,
        };
        if event.button_state != expected_state {
            return Err(format!(
                "Expected {} button state to be {:?}, but was {:?}",
                event.action, expected_state, event.button_state
            ));
        }
        // DOWN events can have pending buttons, so don't update the state for them.
        if event.action != MotionAction::Down {
            self.button_state = event.button_state;
        }
        Ok(())
    }
}

/// The InputVerifier is used to validate a stream of input events.
pub struct InputVerifier {
    name: String,
    should_log: bool,
    verify_buttons: bool,
    touching_pointer_ids_by_device: HashMap<DeviceId, HashSet<i32>>,
    hovering_pointer_ids_by_device: HashMap<DeviceId, HashSet<i32>>,
    button_verifier_by_device: HashMap<DeviceId, ButtonVerifier>,
}

impl InputVerifier {
    /// Create a new InputVerifier.
    pub fn new(name: &str, should_log: bool, verify_buttons: bool) -> Self {
        logger::init(
            logger::Config::default()
                .with_tag_on_device("InputVerifier")
                .with_max_level(log::LevelFilter::Trace),
        );
        Self {
            name: name.to_owned(),
            should_log,
            verify_buttons,
            touching_pointer_ids_by_device: HashMap::new(),
            hovering_pointer_ids_by_device: HashMap::new(),
            button_verifier_by_device: HashMap::new(),
        }
    }

    /// Process a pointer movement event from an InputDevice.
    /// If the event is not valid, we return an error string that describes the issue.
    pub fn process_movement(&mut self, event: NotifyMotionArgs<'_>) -> Result<(), String> {
        if !event.source.is_from_class(SourceClass::Pointer) {
            // Skip non-pointer sources like MOUSE_RELATIVE for now
            return Ok(());
        }
        if self.should_log {
            info!(
                "Processing {} for device {:?} ({} pointer{}) on {}",
                event.action,
                event.device_id,
                event.pointer_properties.len(),
                if event.pointer_properties.len() == 1 { "" } else { "s" },
                self.name
            );
        }

        verify_event(event, self.verify_buttons)?;

        if self.verify_buttons {
            self.button_verifier_by_device
                .entry(event.device_id)
                .or_default()
                .process_event(event)?;
        }

        match event.action {
            MotionAction::Down => {
                if self.touching_pointer_ids_by_device.contains_key(&event.device_id) {
                    return Err(format!(
                        "{}: Invalid DOWN event - pointers already down for device {:?}: {:?}",
                        self.name, event.device_id, self.touching_pointer_ids_by_device
                    ));
                }
                let it = self.touching_pointer_ids_by_device.entry(event.device_id).or_default();
                it.insert(event.pointer_properties[0].id);
            }
            MotionAction::PointerDown { action_index } => {
                if !self.touching_pointer_ids_by_device.contains_key(&event.device_id) {
                    return Err(format!(
                        "{}: Received POINTER_DOWN but no pointers are currently down \
                        for device {:?}",
                        self.name, event.device_id
                    ));
                }
                let it = self.touching_pointer_ids_by_device.get_mut(&event.device_id).unwrap();
                if it.len() != event.pointer_properties.len() - 1 {
                    return Err(format!(
                        "{}: There are currently {} touching pointers, but the incoming \
                         POINTER_DOWN event has {}",
                        self.name,
                        it.len(),
                        event.pointer_properties.len()
                    ));
                }
                let pointer_id = event.pointer_properties[action_index].id;
                if it.contains(&pointer_id) {
                    return Err(format!(
                        "{}: Pointer with id={} already present found in the properties",
                        self.name, pointer_id
                    ));
                }
                it.insert(pointer_id);
            }
            MotionAction::Move => {
                if !self.ensure_touching_pointers_match(event.device_id, event.pointer_properties) {
                    return Err(format!(
                        "{}: ACTION_MOVE touching pointers don't match",
                        self.name
                    ));
                }
            }
            MotionAction::PointerUp { action_index } => {
                if !self.ensure_touching_pointers_match(event.device_id, event.pointer_properties) {
                    return Err(format!(
                        "{}: ACTION_POINTER_UP touching pointers don't match",
                        self.name
                    ));
                }
                let it = self.touching_pointer_ids_by_device.get_mut(&event.device_id).unwrap();
                let pointer_id = event.pointer_properties[action_index].id;
                it.remove(&pointer_id);
            }
            MotionAction::Up => {
                if !self.touching_pointer_ids_by_device.contains_key(&event.device_id) {
                    return Err(format!(
                        "{} Received ACTION_UP but no pointers are currently down for device {:?}",
                        self.name, event.device_id
                    ));
                }
                let it = self.touching_pointer_ids_by_device.get_mut(&event.device_id).unwrap();
                if it.len() != 1 {
                    return Err(format!(
                        "{}: Got ACTION_UP, but we have pointers: {:?} for device {:?}",
                        self.name, it, event.device_id
                    ));
                }
                let pointer_id = event.pointer_properties[0].id;
                if !it.contains(&pointer_id) {
                    return Err(format!(
                        "{}: Got ACTION_UP, but pointerId {} is not touching. Touching pointers:\
                        {:?} for device {:?}",
                        self.name, pointer_id, it, event.device_id
                    ));
                }
                self.touching_pointer_ids_by_device.remove(&event.device_id);
            }
            MotionAction::Cancel => {
                if !self.ensure_touching_pointers_match(event.device_id, event.pointer_properties) {
                    return Err(format!(
                        "{}: Got ACTION_CANCEL, but the pointers don't match. \
                        Existing pointers: {:?}",
                        self.name, self.touching_pointer_ids_by_device
                    ));
                }
                self.touching_pointer_ids_by_device.remove(&event.device_id);
            }
            /*
             * The hovering protocol currently supports a single pointer only, because we do not
             * have ACTION_HOVER_POINTER_ENTER or ACTION_HOVER_POINTER_EXIT.
             * Still, we are keeping the infrastructure here pretty general in case that is
             * eventually supported.
             */
            MotionAction::HoverEnter => {
                if self.hovering_pointer_ids_by_device.contains_key(&event.device_id) {
                    return Err(format!(
                        "{}: Invalid HOVER_ENTER event - pointers already hovering for device {:?}:\
                        {:?}",
                        self.name, event.device_id, self.hovering_pointer_ids_by_device
                    ));
                }
                let it = self.hovering_pointer_ids_by_device.entry(event.device_id).or_default();
                it.insert(event.pointer_properties[0].id);
            }
            MotionAction::HoverMove => {
                // For compatibility reasons, we allow HOVER_MOVE without a prior HOVER_ENTER.
                // If there was no prior HOVER_ENTER, just start a new hovering pointer.
                let it = self.hovering_pointer_ids_by_device.entry(event.device_id).or_default();
                it.insert(event.pointer_properties[0].id);
            }
            MotionAction::HoverExit => {
                if !self.hovering_pointer_ids_by_device.contains_key(&event.device_id) {
                    return Err(format!(
                        "{}: Invalid HOVER_EXIT event - no pointers are hovering for device {:?}",
                        self.name, event.device_id
                    ));
                }
                let pointer_id = event.pointer_properties[0].id;
                let it = self.hovering_pointer_ids_by_device.get_mut(&event.device_id).unwrap();
                it.remove(&pointer_id);

                if !it.is_empty() {
                    return Err(format!(
                        "{}: Removed hovering pointer {}, but pointers are still\
                               hovering for device {:?}: {:?}",
                        self.name, pointer_id, event.device_id, it
                    ));
                }
                self.hovering_pointer_ids_by_device.remove(&event.device_id);
            }
            _ => return Ok(()),
        }
        Ok(())
    }

    /// Notify the verifier that the device has been reset, which will cause the verifier to erase
    /// the current internal state for this device. Subsequent events from this device are expected
    //// to start a new gesture.
    pub fn reset_device(&mut self, device_id: DeviceId) {
        self.touching_pointer_ids_by_device.remove(&device_id);
        self.hovering_pointer_ids_by_device.remove(&device_id);
    }

    fn ensure_touching_pointers_match(
        &self,
        device_id: DeviceId,
        pointer_properties: &[RustPointerProperties],
    ) -> bool {
        let Some(pointers) = self.touching_pointer_ids_by_device.get(&device_id) else {
            return false;
        };

        if pointers.len() != pointer_properties.len() {
            return false;
        }

        for pointer_property in pointer_properties.iter() {
            let pointer_id = pointer_property.id;
            if !pointers.contains(&pointer_id) {
                return false;
            }
        }
        true
    }
}

#[cfg(test)]
mod tests {
    use crate::input::MotionButton;
    use crate::input_verifier::InputVerifier;
    use crate::input_verifier::NotifyMotionArgs;
    use crate::DeviceId;
    use crate::MotionAction;
    use crate::MotionFlags;
    use crate::RustPointerProperties;
    use crate::Source;

    const BASE_POINTER_PROPERTIES: [RustPointerProperties; 1] = [RustPointerProperties { id: 0 }];
    const BASE_EVENT: NotifyMotionArgs = NotifyMotionArgs {
        device_id: DeviceId(1),
        source: Source::Touchscreen,
        action: MotionAction::Down,
        pointer_properties: &BASE_POINTER_PROPERTIES,
        flags: MotionFlags::empty(),
        button_state: MotionButton::empty(),
    };
    const BASE_MOUSE_EVENT: NotifyMotionArgs =
        NotifyMotionArgs { source: Source::Mouse, ..BASE_EVENT };

    #[test]
    /**
     * Send a DOWN event with 2 pointers and ensure that it's marked as invalid.
     */
    fn bad_down_event() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ true, /*verify_buttons*/ true);
        let pointer_properties =
            Vec::from([RustPointerProperties { id: 0 }, RustPointerProperties { id: 1 }]);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Down,
                pointer_properties: &pointer_properties,
                ..BASE_EVENT
            })
            .is_err());
    }

    #[test]
    fn single_pointer_stream() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        let pointer_properties = Vec::from([RustPointerProperties { id: 0 }]);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Down,
                pointer_properties: &pointer_properties,
                ..BASE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Move,
                pointer_properties: &pointer_properties,
                ..BASE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Up,
                pointer_properties: &pointer_properties,
                ..BASE_EVENT
            })
            .is_ok());
    }

    #[test]
    fn two_pointer_stream() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        let pointer_properties = Vec::from([RustPointerProperties { id: 0 }]);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Down,
                pointer_properties: &pointer_properties,
                ..BASE_EVENT
            })
            .is_ok());
        // POINTER 1 DOWN
        let two_pointer_properties =
            Vec::from([RustPointerProperties { id: 0 }, RustPointerProperties { id: 1 }]);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::PointerDown { action_index: 1 },
                pointer_properties: &two_pointer_properties,
                ..BASE_EVENT
            })
            .is_ok());
        // POINTER 0 UP
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::PointerUp { action_index: 0 },
                pointer_properties: &two_pointer_properties,
                ..BASE_EVENT
            })
            .is_ok());
        // ACTION_UP for pointer id=1
        let pointer_1_properties = Vec::from([RustPointerProperties { id: 1 }]);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Up,
                pointer_properties: &pointer_1_properties,
                ..BASE_EVENT
            })
            .is_ok());
    }

    #[test]
    fn multi_device_stream() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                device_id: DeviceId(1),
                action: MotionAction::Down,
                ..BASE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                device_id: DeviceId(1),
                action: MotionAction::Move,
                ..BASE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                device_id: DeviceId(2),
                action: MotionAction::Down,
                ..BASE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                device_id: DeviceId(2),
                action: MotionAction::Move,
                ..BASE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                device_id: DeviceId(1),
                action: MotionAction::Up,
                ..BASE_EVENT
            })
            .is_ok());
    }

    #[test]
    fn action_cancel() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Down,
                flags: MotionFlags::empty(),
                ..BASE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Cancel,
                flags: MotionFlags::CANCELED,
                ..BASE_EVENT
            })
            .is_ok());
    }

    #[test]
    fn invalid_action_cancel() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs { action: MotionAction::Down, ..BASE_EVENT })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs { action: MotionAction::Cancel, ..BASE_EVENT })
            .is_err());
    }

    #[test]
    fn invalid_up() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs { action: MotionAction::Up, ..BASE_EVENT })
            .is_err());
    }

    #[test]
    fn correct_hover_sequence() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs { action: MotionAction::HoverEnter, ..BASE_EVENT })
            .is_ok());

        assert!(verifier
            .process_movement(NotifyMotionArgs { action: MotionAction::HoverMove, ..BASE_EVENT })
            .is_ok());

        assert!(verifier
            .process_movement(NotifyMotionArgs { action: MotionAction::HoverExit, ..BASE_EVENT })
            .is_ok());

        assert!(verifier
            .process_movement(NotifyMotionArgs { action: MotionAction::HoverEnter, ..BASE_EVENT })
            .is_ok());
    }

    #[test]
    fn double_hover_enter() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs { action: MotionAction::HoverEnter, ..BASE_EVENT })
            .is_ok());

        assert!(verifier
            .process_movement(NotifyMotionArgs { action: MotionAction::HoverEnter, ..BASE_EVENT })
            .is_err());
    }

    // Send a MOVE without a preceding DOWN event. This is OK because it's from source
    // MOUSE_RELATIVE, which is used during pointer capture. The verifier should allow such event.
    #[test]
    fn relative_mouse_move() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                device_id: DeviceId(2),
                source: Source::MouseRelative,
                action: MotionAction::Move,
                ..BASE_EVENT
            })
            .is_ok());
    }

    // Send a MOVE event with incorrect number of pointers (one of the pointers is missing).
    #[test]
    fn move_with_wrong_number_of_pointers() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        let pointer_properties = Vec::from([RustPointerProperties { id: 0 }]);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Down,
                pointer_properties: &pointer_properties,
                ..BASE_EVENT
            })
            .is_ok());
        // POINTER 1 DOWN
        let two_pointer_properties =
            Vec::from([RustPointerProperties { id: 0 }, RustPointerProperties { id: 1 }]);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::PointerDown { action_index: 1 },
                pointer_properties: &two_pointer_properties,
                ..BASE_EVENT
            })
            .is_ok());
        // MOVE event with 1 pointer missing (the pointer with id = 1). It should be rejected
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Move,
                pointer_properties: &pointer_properties,
                ..BASE_EVENT
            })
            .is_err());
    }

    #[test]
    fn correct_button_press() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Primary },
                button_state: MotionButton::Primary,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
    }

    #[test]
    fn button_press_without_action_button() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::empty() },
                button_state: MotionButton::empty(),
                ..BASE_MOUSE_EVENT
            })
            .is_err());
    }

    #[test]
    fn button_press_with_multiple_action_buttons() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress {
                    action_button: MotionButton::Back | MotionButton::Forward
                },
                button_state: MotionButton::Back | MotionButton::Forward,
                ..BASE_MOUSE_EVENT
            })
            .is_err());
    }

    #[test]
    fn button_press_without_action_button_in_state() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Primary },
                button_state: MotionButton::empty(),
                ..BASE_MOUSE_EVENT
            })
            .is_err());
    }

    #[test]
    fn button_release_with_action_button_in_state() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Primary },
                button_state: MotionButton::Primary,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonRelease { action_button: MotionButton::Primary },
                button_state: MotionButton::Primary,
                ..BASE_MOUSE_EVENT
            })
            .is_err());
    }

    #[test]
    fn nonbutton_action_with_button_state_change() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::HoverEnter,
                button_state: MotionButton::empty(),
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::HoverMove,
                button_state: MotionButton::Back,
                ..BASE_MOUSE_EVENT
            })
            .is_err());
    }

    #[test]
    fn nonbutton_action_missing_button_state() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::HoverEnter,
                button_state: MotionButton::empty(),
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Back },
                button_state: MotionButton::Back,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::HoverMove,
                button_state: MotionButton::empty(),
                ..BASE_MOUSE_EVENT
            })
            .is_err());
    }

    #[test]
    fn up_without_button_release() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Down,
                button_state: MotionButton::Primary,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Primary },
                button_state: MotionButton::Primary,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        // This UP event shouldn't change the button state; a BUTTON_RELEASE before it should.
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Up,
                button_state: MotionButton::empty(),
                ..BASE_MOUSE_EVENT
            })
            .is_err());
    }

    #[test]
    fn button_press_for_already_pressed_button() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Back },
                button_state: MotionButton::Back,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Back },
                button_state: MotionButton::Back,
                ..BASE_MOUSE_EVENT
            })
            .is_err());
    }

    #[test]
    fn button_release_for_unpressed_button() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonRelease { action_button: MotionButton::Back },
                button_state: MotionButton::empty(),
                ..BASE_MOUSE_EVENT
            })
            .is_err());
    }

    #[test]
    fn correct_multiple_button_presses_without_down() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Back },
                button_state: MotionButton::Back,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Forward },
                button_state: MotionButton::Back | MotionButton::Forward,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
    }

    #[test]
    fn correct_down_with_button_press() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Down,
                button_state: MotionButton::Primary | MotionButton::Secondary,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Primary },
                button_state: MotionButton::Primary,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Secondary },
                button_state: MotionButton::Primary | MotionButton::Secondary,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        // Also check that the MOVE afterwards is OK, as that's where errors would be raised if not
        // enough BUTTON_PRESSes were sent.
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Move,
                button_state: MotionButton::Primary | MotionButton::Secondary,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
    }

    #[test]
    fn down_with_button_state_change_not_followed_by_button_press() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Down,
                button_state: MotionButton::Primary,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        // The DOWN event itself is OK, but it needs to be immediately followed by a BUTTON_PRESS.
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Move,
                button_state: MotionButton::Primary,
                ..BASE_MOUSE_EVENT
            })
            .is_err());
    }

    #[test]
    fn down_with_button_state_change_not_followed_by_enough_button_presses() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Down,
                button_state: MotionButton::Primary | MotionButton::Secondary,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        // The DOWN event itself is OK, but it needs to be immediately followed by two
        // BUTTON_PRESSes, one for each button.
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Primary },
                button_state: MotionButton::Primary,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Move,
                button_state: MotionButton::Primary,
                ..BASE_MOUSE_EVENT
            })
            .is_err());
    }

    #[test]
    fn down_missing_already_pressed_button() {
        let mut verifier =
            InputVerifier::new("Test", /*should_log*/ false, /*verify_buttons*/ true);
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::ButtonPress { action_button: MotionButton::Back },
                button_state: MotionButton::Back,
                ..BASE_MOUSE_EVENT
            })
            .is_ok());
        assert!(verifier
            .process_movement(NotifyMotionArgs {
                action: MotionAction::Down,
                button_state: MotionButton::empty(),
                ..BASE_MOUSE_EVENT
            })
            .is_err());
    }
}