diff --git a/session_shells/gazelle/BUILD.gn b/session_shells/gazelle/BUILD.gn
index 5cb7a8f..f4e5186 100644
--- a/session_shells/gazelle/BUILD.gn
+++ b/session_shells/gazelle/BUILD.gn
@@ -15,6 +15,7 @@
   testonly = true
   deps = [
     "appkit:tests",
+    "pointer_fusion:tests",
     "wm:tests",
   ]
 }
diff --git a/session_shells/gazelle/pointer_fusion/BUILD.gn b/session_shells/gazelle/pointer_fusion/BUILD.gn
new file mode 100644
index 0000000..09bcb62
--- /dev/null
+++ b/session_shells/gazelle/pointer_fusion/BUILD.gn
@@ -0,0 +1,35 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+import("//build/components.gni")
+import("//build/rust/rustc_library.gni")
+
+rustc_library("pointer_fusion") {
+  name = "pointer_fusion"
+  with_unit_tests = true
+  version = "0.1.0"
+  edition = "2018"
+  sources = [
+    "src/lib.rs",
+    "src/pointer/mod.rs",
+    "src/pointer/mouse.rs",
+    "src/pointer/touch.rs",
+    "src/tests.rs",
+  ]
+  deps = [
+    "//sdk/fidl/fuchsia.ui.pointer:fuchsia.ui.pointer_rust",
+    "//src/lib/zircon/rust:fuchsia-zircon",
+    "//third_party/rust_crates:futures",
+    "//third_party/rust_crates:num",
+  ]
+  test_deps = [ "//src/lib/fuchsia" ]
+}
+
+fuchsia_unittest_package("pointer_fusion_tests") {
+  deps = [ ":pointer_fusion_test" ]
+}
+
+group("tests") {
+  testonly = true
+  deps = [ ":pointer_fusion_tests" ]
+}
diff --git a/session_shells/gazelle/pointer_fusion/src/lib.rs b/session_shells/gazelle/pointer_fusion/src/lib.rs
new file mode 100644
index 0000000..6689e40
--- /dev/null
+++ b/session_shells/gazelle/pointer_fusion/src/lib.rs
@@ -0,0 +1,113 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+mod pointer;
+
+#[cfg(test)]
+mod tests;
+
+use {
+    crate::pointer::PointerFusionState,
+    fidl_fuchsia_ui_pointer as fptr, fuchsia_zircon as zx,
+    futures::{
+        channel::mpsc::{self, UnboundedSender},
+        stream, Stream, StreamExt,
+    },
+};
+
+#[derive(Clone, Default, Debug)]
+pub enum DeviceKind {
+    #[default]
+    Touch,
+    Mouse,
+    Stylus,
+    InvertedStylus,
+    Trackpad,
+}
+
+#[derive(Clone, Default, Debug)]
+pub enum Phase {
+    #[default]
+    Cancel,
+    Add,
+    Remove,
+    Hover,
+    Down,
+    Move,
+    Up,
+}
+
+#[derive(Clone, Default, Debug)]
+pub enum SignalKind {
+    #[default]
+    None,
+    Scroll,
+    ScrollInertiaCancel,
+}
+
+pub const POINTER_BUTTON_1: i64 = 1 << 0;
+pub const POINTER_BUTTON_2: i64 = 1 << 1;
+pub const POINTER_BUTTON_3: i64 = 1 << 2;
+pub const POINTER_BUTTON_4: i64 = 1 << 3;
+pub const POINTER_BUTTON_5: i64 = 1 << 4;
+
+/// Information about the state of a pointer.
+#[derive(Clone, Default, Debug)]
+pub struct PointerEvent {
+    /// The monotonically increasing identifier that is present only on 'Down' events and
+    /// is 0 otherwise.
+    pub id: i64,
+    /// The kind of input device.
+    pub kind: DeviceKind,
+    /// The timestamp when the event originated. This is monotonically increasing for the same
+    /// [DeviceKind]. Timestamp for synthesized events is same as event synthesized from.
+    pub timestamp: zx::Time,
+    /// The current [Phase] of pointer event.
+    pub phase: Phase,
+    /// The unique device identifier.
+    pub device_id: u32,
+    /// The x position of the device, in the viewport's coordinate system, as reported by the raw
+    /// device event.
+    pub physical_x: f32,
+    /// The y position of the device, in the viewport's coordinate system, as reported by the raw
+    /// device event.
+    pub physical_y: f32,
+    /// The relative change in x position of the device from previous event in sequence.
+    pub physical_delta_x: f32,
+    /// The relative change in y position of the device from previous event in sequence.
+    pub physical_delta_y: f32,
+    /// The buttons pressed on the device represented as bitflags.
+    pub buttons: i64,
+    /// The event [SignalKind] for scroll events.
+    pub signal_kind: SignalKind,
+    /// The amount of scroll in x direction, in physical pixels.
+    pub scroll_delta_y: f64,
+    /// The amount of scroll in y direction, in physical pixels.
+    pub scroll_delta_x: f64,
+    /// Set if this [PointerEvent] was synthesized for maintaining legal input sequence.
+    pub synthesized: bool,
+}
+
+#[derive(Debug)]
+pub enum InputEvent {
+    MouseEvent(fptr::MouseEvent),
+    TouchEvent(fptr::TouchEvent),
+}
+
+/// Provides a stream of [PointerEvent] fused from [InputEvent::MouseEvent] and
+/// [InputEvent::TouchEvent].
+///
+/// * `pixel_ratio` -  The device pixel ratio used to convert from logical to physical coordinates.
+///
+/// Returns a tuple of [UnboundedSender] to send [InputEvent]s to and a [Stream] to read fused
+/// [PointerEvent]s from.
+pub fn pointer_fusion(
+    pixel_ratio: f32,
+) -> (UnboundedSender<InputEvent>, impl Stream<Item = PointerEvent>) {
+    let mut state = PointerFusionState::new(pixel_ratio);
+    let (input_sender, receiver) = mpsc::unbounded::<InputEvent>();
+    let pointer_stream = receiver.map(move |input| stream::iter(state.fuse_input(input))).flatten();
+
+    (input_sender, pointer_stream)
+}
diff --git a/session_shells/gazelle/pointer_fusion/src/pointer/mod.rs b/session_shells/gazelle/pointer_fusion/src/pointer/mod.rs
new file mode 100644
index 0000000..5d90b91
--- /dev/null
+++ b/session_shells/gazelle/pointer_fusion/src/pointer/mod.rs
@@ -0,0 +1,76 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+mod mouse;
+mod touch;
+
+use {
+    super::*,
+    fidl_fuchsia_ui_pointer as fptr, num,
+    std::collections::{HashMap, HashSet},
+    std::f32::EPSILON,
+};
+
+pub struct PointerFusionState {
+    pixel_ratio: f32,
+    mouse_device_info: HashMap<u32, fptr::MouseDeviceInfo>,
+    mouse_down: HashSet<u32>,
+    mouse_view_parameters: Option<fptr::ViewParameters>,
+    pointer_states: HashMap<u32, PointerState>,
+    next_pointer_id: i64,
+}
+
+impl PointerFusionState {
+    /// Constructs a [PointerFusionState] with a display [pixel_ratio] used to convert logical
+    /// coordinates into physical coordinates.
+    pub fn new(pixel_ratio: f32) -> Self {
+        PointerFusionState {
+            pixel_ratio,
+            mouse_device_info: HashMap::new(),
+            mouse_down: HashSet::new(),
+            mouse_view_parameters: None,
+            pointer_states: HashMap::new(),
+            next_pointer_id: 0,
+        }
+    }
+
+    pub fn fuse_input(&mut self, input: InputEvent) -> Vec<PointerEvent> {
+        match input {
+            InputEvent::MouseEvent(mouse_event) => self.fuse_mouse(mouse_event),
+            InputEvent::TouchEvent(touch_event) => self.fuse_touch(touch_event),
+        }
+    }
+}
+
+// The current information about a pointer derived from previous [PointerEvent]s. This is used to
+// sanitized the pointer stream and synthesize addition data like `physical_delta_x`.
+#[derive(Copy, Clone, Default)]
+struct PointerState {
+    id: i64,
+    is_down: bool,
+    physical_x: f32,
+    physical_y: f32,
+    buttons: i64,
+}
+
+impl PointerState {
+    pub(crate) fn from_event(event: &PointerEvent) -> Self {
+        let mut state = PointerState::default();
+        state.physical_x = event.physical_x;
+        state.physical_y = event.physical_y;
+        state
+    }
+
+    pub(crate) fn is_location_changed(&self, event: &PointerEvent) -> bool {
+        self.physical_x != event.physical_x || self.physical_y != event.physical_y
+    }
+
+    pub(crate) fn is_button_state_changed(&self, event: &PointerEvent) -> bool {
+        self.buttons != event.buttons
+    }
+
+    pub(crate) fn compute_delta(&self, event: &PointerEvent) -> (f32, f32) {
+        (event.physical_x - self.physical_x, event.physical_y - self.physical_y)
+    }
+}
diff --git a/session_shells/gazelle/pointer_fusion/src/pointer/mouse.rs b/session_shells/gazelle/pointer_fusion/src/pointer/mouse.rs
new file mode 100644
index 0000000..fed6308
--- /dev/null
+++ b/session_shells/gazelle/pointer_fusion/src/pointer/mouse.rs
@@ -0,0 +1,366 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use {
+    super::*, fidl_fuchsia_ui_pointer as fptr, fuchsia_zircon as zx, num, std::collections::HashSet,
+};
+
+const SCROLL_OFFSET_MULTIPLIER: i64 = 20;
+
+impl PointerFusionState {
+    // Converts raw [fptr::MouseEvent]s to one or more [PointerEvent]s.
+    pub(super) fn fuse_mouse(&mut self, event: fptr::MouseEvent) -> Vec<PointerEvent> {
+        if let Some(ref device_info) = event.device_info {
+            self.mouse_device_info.insert(device_info.id.unwrap_or(0), device_info.clone());
+        }
+
+        if event.view_parameters.is_some() {
+            self.mouse_view_parameters = event.view_parameters;
+        }
+
+        if has_valid_mouse_sample(&event) && self.mouse_view_parameters.is_some() {
+            let sample = event.pointer_sample.as_ref().unwrap();
+            let id = sample.device_id.unwrap();
+            if self.mouse_device_info.contains_key(&id) {
+                let any_button_down = sample.pressed_buttons.is_some();
+                let phase = compute_mouse_phase(any_button_down, &mut self.mouse_down, id);
+
+                let pointer_event = create_mouse_draft(
+                    &event,
+                    phase,
+                    self.mouse_view_parameters.as_ref().unwrap(),
+                    self.mouse_device_info.get(&id).unwrap(),
+                    self.pixel_ratio,
+                );
+
+                let sanitized_events = self.sanitize_pointer(pointer_event);
+                return sanitized_events;
+            }
+        }
+
+        vec![]
+    }
+
+    // Sanitizes the [PointerEvent] draft such that the resulting event stream is contextually
+    // correct. It may drop events or synthesize new events to keep the event stream sane.
+    //
+    // Note: It is still possible to craft an event stream that will cause an assert check to fail
+    // on debug builds.
+    fn sanitize_pointer(&mut self, mut event: PointerEvent) -> Vec<PointerEvent> {
+        let mut converted_pointers = vec![];
+        match event.signal_kind {
+            SignalKind::None => match event.phase {
+                // Drops the Cancel if the pointer is not previously added.
+                Phase::Cancel => {
+                    if let Some(state) = self.pointer_states.get_mut(&event.device_id) {
+                        assert!(state.is_down);
+
+                        event.id = state.id;
+                        // Synthesize a move event if the location does not match.
+                        if state.is_location_changed(&event) {
+                            let (physical_delta_x, physical_delta_y) = state.compute_delta(&event);
+                            let move_event = PointerEvent {
+                                physical_delta_x,
+                                physical_delta_y,
+                                phase: Phase::Move,
+                                synthesized: true,
+                                ..event.clone()
+                            };
+
+                            state.physical_x = move_event.physical_x;
+                            state.physical_y = move_event.physical_y;
+
+                            converted_pointers.push(move_event);
+                        }
+                        state.is_down = false;
+                        converted_pointers.push(event);
+                    }
+                }
+                Phase::Add => {
+                    assert!(!self.pointer_states.contains_key(&event.device_id));
+                    let state = PointerState::from_event(&event);
+                    self.pointer_states.insert(event.device_id, state);
+
+                    converted_pointers.push(event);
+                }
+                Phase::Remove => {
+                    assert!(self.pointer_states.contains_key(&event.device_id));
+                    if let Some(state) = self.pointer_states.get_mut(&event.device_id) {
+                        // Synthesize a Cancel event if pointer is down.
+                        if state.is_down {
+                            let mut cancel_event = event.clone();
+                            cancel_event.phase = Phase::Cancel;
+                            cancel_event.synthesized = true;
+                            cancel_event.id = state.id;
+
+                            state.is_down = false;
+                            converted_pointers.push(cancel_event);
+                        }
+
+                        // Synthesize a hover event if the location does not match.
+                        if state.is_location_changed(&event) {
+                            let (physical_delta_x, physical_delta_y) = state.compute_delta(&event);
+                            let hover_event = PointerEvent {
+                                physical_delta_x,
+                                physical_delta_y,
+                                phase: Phase::Hover,
+                                synthesized: true,
+                                ..event.clone()
+                            };
+
+                            state.physical_x = hover_event.physical_x;
+                            state.physical_y = hover_event.physical_y;
+
+                            converted_pointers.push(hover_event);
+                        }
+                    }
+                    self.pointer_states.remove(&event.device_id);
+                    converted_pointers.push(event);
+                }
+                Phase::Hover => {
+                    let mut state = match self.pointer_states.get_mut(&event.device_id) {
+                        Some(state) => *state,
+                        None => {
+                            // Synthesize add event if the pointer is not previously added.
+                            let mut add_event = event.clone();
+                            add_event.phase = Phase::Add;
+                            add_event.synthesized = true;
+                            let state = PointerState::from_event(&add_event);
+                            self.pointer_states.insert(add_event.device_id, state);
+
+                            converted_pointers.push(add_event);
+                            state
+                        }
+                    };
+
+                    assert!(!state.is_down);
+                    if state.is_location_changed(&event) {
+                        let (physical_delta_x, physical_delta_y) = state.compute_delta(&event);
+                        event.physical_delta_x = physical_delta_x;
+                        event.physical_delta_y = physical_delta_y;
+
+                        state.physical_x = event.physical_x;
+                        state.physical_y = event.physical_y;
+                        converted_pointers.push(event);
+                    }
+                }
+                Phase::Down => {
+                    let mut state = match self.pointer_states.get_mut(&event.device_id) {
+                        Some(state) => *state,
+                        None => {
+                            // Synthesize add event if the pointer is not previously added.
+                            let mut add_event = event.clone();
+                            add_event.phase = Phase::Add;
+                            add_event.synthesized = true;
+                            let state = PointerState::from_event(&add_event);
+                            self.pointer_states.insert(add_event.device_id, state);
+
+                            converted_pointers.push(add_event);
+                            state
+                        }
+                    };
+
+                    assert!(!state.is_down);
+                    // Synthesize a hover event if the location does not match.
+                    if state.is_location_changed(&event) {
+                        let (physical_delta_x, physical_delta_y) = state.compute_delta(&event);
+                        let hover_event = PointerEvent {
+                            physical_delta_x,
+                            physical_delta_y,
+                            phase: Phase::Hover,
+                            synthesized: true,
+                            ..event.clone()
+                        };
+
+                        state.physical_x = hover_event.physical_x;
+                        state.physical_y = hover_event.physical_y;
+
+                        converted_pointers.push(hover_event);
+                    }
+                    self.next_pointer_id += 1;
+                    state.id = self.next_pointer_id;
+                    state.is_down = true;
+                    state.buttons = event.buttons;
+                    self.pointer_states.insert(event.device_id, state);
+                    converted_pointers.push(event);
+                }
+                Phase::Move => {
+                    // Makes sure we have an existing pointer in down state
+                    let mut state =
+                        self.pointer_states.get_mut(&event.device_id).expect("State should exist");
+                    assert!(state.is_down);
+                    event.id = state.id;
+
+                    // Skip this event if location does not change.
+                    if state.is_location_changed(&event) || state.is_button_state_changed(&event) {
+                        let (physical_delta_x, physical_delta_y) = state.compute_delta(&event);
+                        event.physical_delta_x = physical_delta_x;
+                        event.physical_delta_y = physical_delta_y;
+
+                        state.physical_x = event.physical_x;
+                        state.physical_y = event.physical_y;
+                        state.buttons = event.buttons;
+                        converted_pointers.push(event);
+                    }
+                }
+                Phase::Up => {
+                    // Makes sure we have an existing pointer in down state
+                    let mut state =
+                        self.pointer_states.get_mut(&event.device_id).expect("State should exist");
+                    assert!(state.is_down);
+                    event.id = state.id;
+
+                    // Up phase should include which buttons where released.
+                    let new_buttons = event.buttons;
+                    event.buttons = state.buttons;
+
+                    // Synthesize a move event if the location does not match.
+                    if state.is_location_changed(&event) {
+                        let (physical_delta_x, physical_delta_y) = state.compute_delta(&event);
+                        let move_event = PointerEvent {
+                            physical_delta_x,
+                            physical_delta_y,
+                            phase: Phase::Move,
+                            synthesized: true,
+                            ..event.clone()
+                        };
+
+                        state.physical_x = move_event.physical_x;
+                        state.physical_y = move_event.physical_y;
+
+                        converted_pointers.push(move_event);
+                    }
+                    state.is_down = false;
+                    state.buttons = new_buttons;
+                    converted_pointers.push(event);
+                }
+            },
+            // Handle scroll events.
+            _ => {}
+        }
+        converted_pointers
+    }
+}
+
+fn compute_mouse_phase(any_button_down: bool, mouse_down: &mut HashSet<u32>, id: u32) -> Phase {
+    if !mouse_down.contains(&id) && !any_button_down {
+        return Phase::Hover;
+    } else if !mouse_down.contains(&id) && any_button_down {
+        mouse_down.insert(id);
+        return Phase::Down;
+    } else if mouse_down.contains(&id) && any_button_down {
+        return Phase::Move;
+    } else if mouse_down.contains(&id) && !any_button_down {
+        mouse_down.remove(&id);
+        return Phase::Up;
+    } else {
+        return Phase::Cancel;
+    }
+}
+
+fn create_mouse_draft(
+    event: &fptr::MouseEvent,
+    phase: Phase,
+    view_parameters: &fptr::ViewParameters,
+    device_info: &fptr::MouseDeviceInfo,
+    pixel_ratio: f32,
+) -> PointerEvent {
+    assert!(has_valid_mouse_sample(event));
+
+    let sample = event.pointer_sample.as_ref().unwrap();
+
+    let mut pointer = PointerEvent::default();
+    pointer.timestamp = zx::Time::from_nanos(event.timestamp.unwrap_or(0));
+    pointer.phase = phase;
+    pointer.kind = DeviceKind::Mouse;
+    pointer.device_id = sample.device_id.unwrap_or(0);
+
+    let [logical_x, logical_y] =
+        viewport_to_view_coordinates(sample.position_in_viewport.unwrap(), view_parameters);
+    pointer.physical_x = logical_x * pixel_ratio;
+    pointer.physical_y = logical_y * pixel_ratio;
+
+    if sample.pressed_buttons.is_some() && device_info.buttons.is_some() {
+        let mut pointer_buttons: i64 = 0;
+        let pressed = sample.pressed_buttons.as_ref().unwrap();
+        let device_buttons = device_info.buttons.as_ref().unwrap();
+        for button_id in pressed {
+            if let Some(index) = device_buttons.iter().position(|&r| r == *button_id) {
+                pointer_buttons |= 1 << index;
+            }
+        }
+        pointer.buttons = pointer_buttons;
+    }
+
+    if sample.scroll_h.is_some()
+        || sample.scroll_v.is_some()
+        || sample.scroll_h_physical_pixel.is_some()
+        || sample.scroll_v_physical_pixel.is_some()
+    {
+        let tick_x_20ths = sample.scroll_h.unwrap_or(0) * SCROLL_OFFSET_MULTIPLIER;
+        let tick_y_20ths = sample.scroll_v.unwrap_or(0) * SCROLL_OFFSET_MULTIPLIER;
+        let offset_x = sample.scroll_h_physical_pixel.unwrap_or(tick_x_20ths as f64);
+        let offset_y = sample.scroll_v_physical_pixel.unwrap_or(tick_y_20ths as f64);
+
+        pointer.scroll_delta_x = offset_x;
+        pointer.scroll_delta_y = offset_y;
+    }
+
+    pointer
+}
+
+fn has_valid_mouse_sample(event: &fptr::MouseEvent) -> bool {
+    if event.pointer_sample.is_none() {
+        return false;
+    }
+    let sample = event.pointer_sample.as_ref().unwrap();
+    sample.device_id.is_some()
+        && sample.position_in_viewport.is_some()
+        && (sample.pressed_buttons.is_none()
+            || !sample.pressed_buttons.as_ref().unwrap().is_empty())
+}
+
+fn viewport_to_view_coordinates(
+    viewport_coordinates: [f32; 2],
+    view_parameters: &fptr::ViewParameters,
+) -> [f32; 2] {
+    let viewport_to_view_transform = view_parameters.viewport_to_view_transform;
+    // The transform matrix is a FIDL array with matrix data in column-major
+    // order. For a matrix with data [a b c d e f g h i], and with the viewport
+    // coordinates expressed as homogeneous coordinates, the logical view
+    // coordinates are obtained with the following formula:
+    //   |a d g|   |x|   |x'|
+    //   |b e h| * |y| = |y'|
+    //   |c f i|   |1|   |w'|
+    // which we then normalize based on the w component:
+    //   if z' not zero: (x'/w', y'/w')
+    //   else (x', y')
+    let m = viewport_to_view_transform;
+    let x = viewport_coordinates[0];
+    let y = viewport_coordinates[1];
+    let xp = m[0] * x + m[3] * y + m[6];
+    let yp = m[1] * x + m[4] * y + m[7];
+    let wp = m[2] * x + m[5] * y + m[8];
+    let [x, y] = if wp > EPSILON { [xp / wp, yp / wp] } else { [xp, yp] };
+
+    clamp_to_view_space(x, y, view_parameters)
+}
+
+fn clamp_to_view_space(x: f32, y: f32, p: &fptr::ViewParameters) -> [f32; 2] {
+    let min_x = p.view.min[0];
+    let min_y = p.view.min[1];
+    let max_x = p.view.max[0];
+    let max_y = p.view.max[1];
+    if min_x <= x && x < max_x && min_y <= y && y < max_y {
+        return [x, y]; // No clamping to perform.
+    }
+
+    // View boundary is [min_x, max_x) x [min_y, max_y). Note that min is
+    // inclusive, but max is exclusive - so we subtract epsilon.
+    let max_x_inclusive = max_x - EPSILON;
+    let max_y_inclusive = max_y - EPSILON;
+    let clamped_x = num::clamp(x, min_x, max_x_inclusive);
+    let clamped_y = num::clamp(y, min_y, max_y_inclusive);
+    return [clamped_x, clamped_y];
+}
diff --git a/session_shells/gazelle/pointer_fusion/src/pointer/touch.rs b/session_shells/gazelle/pointer_fusion/src/pointer/touch.rs
new file mode 100644
index 0000000..4b35963
--- /dev/null
+++ b/session_shells/gazelle/pointer_fusion/src/pointer/touch.rs
@@ -0,0 +1,12 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use {super::*, fidl_fuchsia_ui_pointer as fptr};
+
+impl PointerFusionState {
+    pub(super) fn fuse_touch(&mut self, _event: fptr::TouchEvent) -> Vec<PointerEvent> {
+        // TODO(fxb/110099): Fuse touch events.
+        todo!("Fuse touch events");
+    }
+}
diff --git a/session_shells/gazelle/pointer_fusion/src/tests.rs b/session_shells/gazelle/pointer_fusion/src/tests.rs
new file mode 100644
index 0000000..5a3fa42
--- /dev/null
+++ b/session_shells/gazelle/pointer_fusion/src/tests.rs
@@ -0,0 +1,250 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use {
+    super::*,
+    fidl_fuchsia_ui_pointer as fptr,
+    // fidl_fuchsia_input_report as input_report,
+    futures::FutureExt,
+};
+
+#[fuchsia::test]
+async fn test_mouse_event_without_view_parameters() {
+    // Fusing mouse event without [fptr::ViewParameters] should not result in a PointerEvent.
+    let mouse_event = InputEvent::mouse();
+    let (sender, mut receiver) = pointer_fusion(1.0);
+    sender.unbounded_send(mouse_event).unwrap();
+    let pointer_event = receiver.next().now_or_never();
+    assert!(pointer_event.is_none(), "Received {:?}", pointer_event);
+}
+
+#[fuchsia::test]
+async fn test_mouse_event_without_mouse_sample() {
+    // Fusing mouse event without [fptr::MousePointerSample] should not result in a PointerEvent.
+    let mouse_event = InputEvent::mouse().view(1024.0, 600.0);
+    let (sender, mut receiver) = pointer_fusion(1.0);
+    sender.unbounded_send(mouse_event).unwrap();
+    let pointer_event = receiver.next().now_or_never();
+    assert!(pointer_event.is_none(), "Received {:?}", pointer_event);
+}
+
+#[fuchsia::test]
+async fn test_mouse_event_without_device_info() {
+    // Fusing mouse event without [fptr::MouseDeviceInfo] should not result in a PointerEvent.
+    let mouse_event = InputEvent::mouse().view(1024.0, 600.0).position(512.0, 300.0);
+    let (sender, mut receiver) = pointer_fusion(1.0);
+    sender.unbounded_send(mouse_event).unwrap();
+    let pointer_event = receiver.next().now_or_never();
+    assert!(pointer_event.is_none(), "Received {:?}", pointer_event);
+}
+
+#[fuchsia::test]
+async fn test_pixel_ratio() {
+    let mouse_event = InputEvent::mouse()
+        .view(1024.0, 600.0)
+        .device_info(42)
+        .position(512.0, 300.0)
+        .button_down();
+
+    let (sender, mut receiver) = pointer_fusion(2.0);
+    sender.unbounded_send(mouse_event).unwrap();
+
+    let pointer_event = receiver.next().await.unwrap();
+    assert!(matches!(pointer_event.phase, Phase::Add));
+    assert!(pointer_event.physical_x - 1024.0 < std::f32::EPSILON);
+    assert!(pointer_event.physical_y - 600.0 < std::f32::EPSILON);
+}
+
+#[fuchsia::test]
+async fn test_mouse_starts_with_add_event() {
+    let mouse_event =
+        InputEvent::mouse().view(1024.0, 600.0).device_info(42).position(512.0, 300.0);
+
+    let (sender, mut receiver) = pointer_fusion(1.0);
+    sender.unbounded_send(mouse_event).unwrap();
+    let pointer_event = receiver.next().await.unwrap();
+    assert!(matches!(pointer_event.phase, Phase::Add));
+}
+
+#[fuchsia::test]
+async fn test_mouse_tap() {
+    let mouse_event = InputEvent::mouse()
+        .view(1024.0, 600.0)
+        .device_info(42)
+        .position(512.0, 300.0)
+        .button_down();
+
+    let (sender, mut receiver) = pointer_fusion(1.0);
+    sender.unbounded_send(mouse_event).unwrap();
+
+    let pointer_event = receiver.next().await.unwrap();
+    assert!(matches!(pointer_event.phase, Phase::Add));
+
+    let pointer_event = receiver.next().await.unwrap();
+    assert!(matches!(pointer_event.phase, Phase::Down));
+
+    let mouse_event = InputEvent::mouse().device_info(42).position(512.0, 300.0);
+    sender.unbounded_send(mouse_event).unwrap();
+
+    let pointer_event = receiver.next().await.unwrap();
+    assert!(matches!(pointer_event.phase, Phase::Up));
+}
+
+#[fuchsia::test]
+async fn test_mouse_hover() {
+    let mouse_event =
+        InputEvent::mouse().view(1024.0, 600.0).device_info(42).position(512.0, 300.0);
+
+    let (sender, mut receiver) = pointer_fusion(1.0);
+    sender.unbounded_send(mouse_event).unwrap();
+
+    let pointer_event = receiver.next().await.unwrap();
+    assert!(matches!(pointer_event.phase, Phase::Add));
+
+    // Changing mouse x position should result in Hover event.
+    let mouse_event = InputEvent::mouse().device_info(42).position(540.0, 300.0);
+    sender.unbounded_send(mouse_event).unwrap();
+
+    let pointer_event = receiver.next().await.unwrap();
+    assert!(matches!(pointer_event.phase, Phase::Hover));
+    assert!(pointer_event.physical_x - 540.0 < std::f32::EPSILON);
+
+    // Changing mouse y position should result in Hover event.
+    let mouse_event = InputEvent::mouse().device_info(42).position(540.0, 320.0);
+    sender.unbounded_send(mouse_event).unwrap();
+
+    let pointer_event = receiver.next().await.unwrap();
+    assert!(matches!(pointer_event.phase, Phase::Hover));
+    assert!(pointer_event.physical_y - 320.0 < std::f32::EPSILON);
+}
+
+#[fuchsia::test]
+async fn test_mouse_move() {
+    let mouse_event = InputEvent::mouse()
+        .view(1024.0, 600.0)
+        .device_info(42)
+        .position(512.0, 300.0)
+        .button_down();
+
+    let (sender, mut receiver) = pointer_fusion(1.0);
+    sender.unbounded_send(mouse_event).unwrap();
+
+    let pointer_event = receiver.next().await.unwrap();
+    assert!(matches!(pointer_event.phase, Phase::Add));
+
+    let pointer_event = receiver.next().await.unwrap();
+    assert!(matches!(pointer_event.phase, Phase::Down));
+
+    // Changing the position should result in Move event.
+    let mouse_event = InputEvent::mouse().device_info(42).position(540.0, 320.0).button_down();
+    sender.unbounded_send(mouse_event).unwrap();
+
+    let pointer_event = receiver.next().await.unwrap();
+    assert!(matches!(pointer_event.phase, Phase::Move));
+    assert!(pointer_event.physical_delta_x == 28.0);
+    assert!(pointer_event.physical_delta_y == 20.0);
+
+    // Keeping the same position should not result in Move event.
+    let mouse_event = InputEvent::mouse().device_info(42).position(540.0, 320.0).button_down();
+    sender.unbounded_send(mouse_event).unwrap();
+
+    let pointer_event = receiver.next().now_or_never();
+    assert!(pointer_event.is_none(), "Received {:?}", pointer_event);
+}
+
+#[fuchsia::test]
+async fn test_mouse_no_spurious_hovers() {
+    let mouse_event =
+        InputEvent::mouse().view(1024.0, 600.0).device_info(42).position(512.0, 300.0);
+
+    let (sender, mut receiver) = pointer_fusion(1.0);
+    sender.unbounded_send(mouse_event).unwrap();
+
+    let pointer_event = receiver.next().await.unwrap();
+    assert!(matches!(pointer_event.phase, Phase::Add));
+
+    // Same position should not result in any hover event.
+    let mouse_event = InputEvent::mouse().device_info(42).position(512.0, 300.0);
+    sender.unbounded_send(mouse_event).unwrap();
+
+    let pointer_event = receiver.next().now_or_never();
+    assert!(pointer_event.is_none(), "Received {:?}", pointer_event);
+}
+
+trait TestMouseEvent {
+    fn mouse() -> Self;
+    fn view(self, width: f32, height: f32) -> Self;
+    fn device_info(self, id: u32) -> Self;
+    fn position(self, x: f32, y: f32) -> Self;
+    fn button_down(self) -> Self;
+}
+
+impl TestMouseEvent for InputEvent {
+    fn mouse() -> Self {
+        InputEvent::MouseEvent(fptr::MouseEvent { ..fptr::MouseEvent::EMPTY })
+    }
+
+    fn view(mut self, width: f32, height: f32) -> Self {
+        match self {
+            InputEvent::MouseEvent(ref mut event) => {
+                event.view_parameters = Some(fptr::ViewParameters {
+                    view: fptr::Rectangle { min: [0.0, 0.0], max: [width, height] },
+                    viewport: fptr::Rectangle { min: [0.0, 0.0], max: [width, height] },
+                    viewport_to_view_transform: [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0],
+                });
+            }
+            _ => {}
+        }
+        self
+    }
+
+    fn device_info(mut self, id: u32) -> Self {
+        match self {
+            InputEvent::MouseEvent(ref mut event) => {
+                event.device_info = Some(fptr::MouseDeviceInfo {
+                    id: Some(id),
+                    buttons: Some([0, 1, 2].to_vec()),
+                    relative_motion_range: None,
+                    ..fptr::MouseDeviceInfo::EMPTY
+                });
+            }
+            _ => {}
+        }
+        self
+    }
+
+    fn position(mut self, x: f32, y: f32) -> Self {
+        match self {
+            InputEvent::MouseEvent(ref mut event) => {
+                let device_id = event
+                    .device_info
+                    .as_ref()
+                    .unwrap_or(&fptr::MouseDeviceInfo {
+                        id: Some(0),
+                        ..fptr::MouseDeviceInfo::EMPTY
+                    })
+                    .id;
+                event.pointer_sample = Some(fptr::MousePointerSample {
+                    device_id,
+                    position_in_viewport: Some([x, y]),
+                    ..fptr::MousePointerSample::EMPTY
+                });
+            }
+            _ => {}
+        }
+        self
+    }
+
+    fn button_down(mut self) -> Self {
+        match self {
+            InputEvent::MouseEvent(ref mut event) => {
+                if let Some(ref mut pointer_sample) = event.pointer_sample {
+                    pointer_sample.pressed_buttons = Some(vec![0]);
+                }
+            }
+            _ => {}
+        }
+        self
+    }
+}