mozilla-central/layout/base/gtest/TestAccessibleCaretEventHub.cpp (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include <iostream>
#include <string>
#include "AccessibleCaretManager.h"
#include "mozilla/AccessibleCaretEventHub.h"
#include "mozilla/BasicEvents.h"
#include "mozilla/MouseEvents.h"
#include "mozilla/TouchEvents.h"
using ::testing::_;
using ::testing::AtLeast;
using ::testing::DefaultValue;
using ::testing::Eq;
using ::testing::InSequence;
using ::testing::MockFunction;
using ::testing::Return;
// -----------------------------------------------------------------------------
// This file test the state transitions of AccessibleCaretEventHub under
// various combination of events and callbacks.
namespace mozilla {
class MockAccessibleCaretManager : public AccessibleCaretManager {
public:
MockAccessibleCaretManager() : AccessibleCaretManager(nullptr) {}
MOCK_METHOD2(PressCaret,
nsresult(const nsPoint& aPoint, EventClassID aEventClass));
MOCK_METHOD1(DragCaret, nsresult(const nsPoint& aPoint));
MOCK_METHOD0(ReleaseCaret, nsresult());
MOCK_METHOD1(TapCaret, nsresult(const nsPoint& aPoint));
MOCK_METHOD1(SelectWordOrShortcut, nsresult(const nsPoint& aPoint));
MOCK_METHOD0(OnScrollStart, void());
MOCK_METHOD0(OnScrollEnd, void());
MOCK_METHOD0(OnScrollPositionChanged, void());
MOCK_METHOD0(OnBlur, void());
};
class MockAccessibleCaretEventHub : public AccessibleCaretEventHub {
public:
using AccessibleCaretEventHub::DragCaretState;
using AccessibleCaretEventHub::LongTapState;
using AccessibleCaretEventHub::NoActionState;
using AccessibleCaretEventHub::PressCaretState;
using AccessibleCaretEventHub::PressNoCaretState;
using AccessibleCaretEventHub::ScrollState;
MockAccessibleCaretEventHub() : AccessibleCaretEventHub(nullptr) {
mManager = MakeUnique<MockAccessibleCaretManager>();
mInitialized = true;
}
nsPoint GetTouchEventPosition(WidgetTouchEvent* aEvent,
int32_t aIdentifier) const override {
// Return the device point directly.
LayoutDeviceIntPoint touchIntPoint = aEvent->mTouches[0]->mRefPoint;
return nsPoint(touchIntPoint.x, touchIntPoint.y);
}
nsPoint GetMouseEventPosition(WidgetMouseEvent* aEvent) const override {
// Return the device point directly.
LayoutDeviceIntPoint mouseIntPoint = aEvent->AsGUIEvent()->mRefPoint;
return nsPoint(mouseIntPoint.x, mouseIntPoint.y);
}
MockAccessibleCaretManager* GetMockAccessibleCaretManager() {
return static_cast<MockAccessibleCaretManager*>(mManager.get());
}
};
// Print the name of the state for debugging.
static ::std::ostream& operator<<(
::std::ostream& aOstream,
const MockAccessibleCaretEventHub::State* aState) {
return aOstream << aState->Name();
}
class AccessibleCaretEventHubTester : public ::testing::Test {
public:
AccessibleCaretEventHubTester() {
DefaultValue<nsresult>::Set(NS_OK);
EXPECT_EQ(mHub->GetState(), MockAccessibleCaretEventHub::NoActionState());
// AccessibleCaretEventHub requires the caller to hold a ref to it. We just
// add ref here for the sake of convenience.
mHub.get()->AddRef();
}
~AccessibleCaretEventHubTester() override {
// Release the ref added in the constructor.
mHub.get()->Release();
}
static UniquePtr<WidgetEvent> CreateMouseEvent(EventMessage aMessage,
nscoord aX, nscoord aY) {
auto event = MakeUnique<WidgetMouseEvent>(true, aMessage, nullptr,
WidgetMouseEvent::eReal);
event->mButton = MouseButton::ePrimary;
event->mRefPoint = LayoutDeviceIntPoint(aX, aY);
return std::move(event);
}
static UniquePtr<WidgetEvent> CreateMousePressEvent(nscoord aX, nscoord aY) {
return CreateMouseEvent(eMouseDown, aX, aY);
}
static UniquePtr<WidgetEvent> CreateMouseMoveEvent(nscoord aX, nscoord aY) {
return CreateMouseEvent(eMouseMove, aX, aY);
}
static UniquePtr<WidgetEvent> CreateMouseReleaseEvent(nscoord aX,
nscoord aY) {
return CreateMouseEvent(eMouseUp, aX, aY);
}
static UniquePtr<WidgetEvent> CreateLongTapEvent(nscoord aX, nscoord aY) {
return CreateMouseEvent(eMouseLongTap, aX, aY);
}
static UniquePtr<WidgetEvent> CreateTouchEvent(EventMessage aMessage,
nscoord aX, nscoord aY) {
auto event = MakeUnique<WidgetTouchEvent>(true, aMessage, nullptr);
int32_t identifier = 0;
LayoutDeviceIntPoint point(aX, aY);
LayoutDeviceIntPoint radius(19, 19);
float rotationAngle = 0;
float force = 1;
RefPtr<dom::Touch> touch(
new dom::Touch(identifier, point, radius, rotationAngle, force));
event->mTouches.AppendElement(touch);
return std::move(event);
}
static UniquePtr<WidgetEvent> CreateTouchStartEvent(nscoord aX, nscoord aY) {
return CreateTouchEvent(eTouchStart, aX, aY);
}
static UniquePtr<WidgetEvent> CreateTouchMoveEvent(nscoord aX, nscoord aY) {
return CreateTouchEvent(eTouchMove, aX, aY);
}
static UniquePtr<WidgetEvent> CreateTouchEndEvent(nscoord aX, nscoord aY) {
return CreateTouchEvent(eTouchEnd, aX, aY);
}
static UniquePtr<WidgetEvent> CreateTouchCancelEvent(nscoord aX, nscoord aY) {
return CreateTouchEvent(eTouchCancel, aX, aY);
}
static UniquePtr<WidgetEvent> CreateWheelEvent(EventMessage aMessage) {
auto event = MakeUnique<WidgetWheelEvent>(true, aMessage, nullptr);
return std::move(event);
}
MOZ_CAN_RUN_SCRIPT_BOUNDARY void TestAsyncPanZoomScroll();
MOZ_CAN_RUN_SCRIPT_BOUNDARY
void HandleEventAndCheckState(
UniquePtr<WidgetEvent> aEvent,
MockAccessibleCaretEventHub::State* aExpectedState,
nsEventStatus aExpectedEventStatus) {
RefPtr<MockAccessibleCaretEventHub> hub(mHub);
nsEventStatus rv = hub->HandleEvent(aEvent.get());
EXPECT_EQ(hub->GetState(), aExpectedState);
EXPECT_EQ(rv, aExpectedEventStatus);
}
void CheckState(MockAccessibleCaretEventHub::State* aExpectedState) {
EXPECT_EQ(mHub->GetState(), aExpectedState);
}
template <typename PressEventCreator, typename ReleaseEventCreator>
MOZ_CAN_RUN_SCRIPT_BOUNDARY void TestPressReleaseOnNoCaret(
PressEventCreator aPressEventCreator,
ReleaseEventCreator aReleaseEventCreator);
template <typename PressEventCreator, typename ReleaseEventCreator>
MOZ_CAN_RUN_SCRIPT_BOUNDARY void TestPressReleaseOnCaret(
PressEventCreator aPressEventCreator,
ReleaseEventCreator aReleaseEventCreator);
template <typename PressEventCreator, typename MoveEventCreator,
typename ReleaseEventCreator>
MOZ_CAN_RUN_SCRIPT_BOUNDARY void TestPressMoveReleaseOnNoCaret(
PressEventCreator aPressEventCreator, MoveEventCreator aMoveEventCreator,
ReleaseEventCreator aReleaseEventCreator);
template <typename PressEventCreator, typename MoveEventCreator,
typename ReleaseEventCreator>
MOZ_CAN_RUN_SCRIPT_BOUNDARY void TestPressMoveReleaseOnCaret(
PressEventCreator aPressEventCreator, MoveEventCreator aMoveEventCreator,
ReleaseEventCreator aReleaseEventCreator);
template <typename PressEventCreator, typename ReleaseEventCreator>
MOZ_CAN_RUN_SCRIPT_BOUNDARY void TestLongTapWithSelectWordSuccessful(
PressEventCreator aPressEventCreator,
ReleaseEventCreator aReleaseEventCreator);
template <typename PressEventCreator, typename ReleaseEventCreator>
MOZ_CAN_RUN_SCRIPT_BOUNDARY void TestLongTapWithSelectWordFailed(
PressEventCreator aPressEventCreator,
ReleaseEventCreator aReleaseEventCreator);
template <typename PressEventCreator, typename MoveEventCreator,
typename ReleaseEventCreator>
MOZ_CAN_RUN_SCRIPT_BOUNDARY void TestEventDrivenAsyncPanZoomScroll(
PressEventCreator aPressEventCreator, MoveEventCreator aMoveEventCreator,
ReleaseEventCreator aReleaseEventCreator);
// Member variables
RefPtr<MockAccessibleCaretEventHub> mHub{new MockAccessibleCaretEventHub()};
}; // class AccessibleCaretEventHubTester
TEST_F(AccessibleCaretEventHubTester, TestMousePressReleaseOnNoCaret)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestPressReleaseOnNoCaret(CreateMousePressEvent, CreateMouseReleaseEvent);
}
TEST_F(AccessibleCaretEventHubTester, TestTouchPressReleaseOnNoCaret)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestPressReleaseOnNoCaret(CreateTouchStartEvent, CreateTouchEndEvent);
}
template <typename PressEventCreator, typename ReleaseEventCreator>
void AccessibleCaretEventHubTester::TestPressReleaseOnNoCaret(
PressEventCreator aPressEventCreator,
ReleaseEventCreator aReleaseEventCreator) {
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), PressCaret(_, _))
.WillOnce(Return(NS_ERROR_FAILURE));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), ReleaseCaret()).Times(0);
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), TapCaret(_)).Times(0);
HandleEventAndCheckState(aPressEventCreator(0, 0),
MockAccessibleCaretEventHub::PressNoCaretState(),
nsEventStatus_eIgnore);
HandleEventAndCheckState(aReleaseEventCreator(0, 0),
MockAccessibleCaretEventHub::NoActionState(),
nsEventStatus_eIgnore);
}
TEST_F(AccessibleCaretEventHubTester, TestMousePressReleaseOnCaret)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestPressReleaseOnCaret(CreateMousePressEvent, CreateMouseReleaseEvent);
}
TEST_F(AccessibleCaretEventHubTester, TestTouchPressReleaseOnCaret)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestPressReleaseOnCaret(CreateTouchStartEvent, CreateTouchEndEvent);
}
template <typename PressEventCreator, typename ReleaseEventCreator>
void AccessibleCaretEventHubTester::TestPressReleaseOnCaret(
PressEventCreator aPressEventCreator,
ReleaseEventCreator aReleaseEventCreator) {
{
InSequence dummy;
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), PressCaret(_, _))
.WillOnce(Return(NS_OK));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), SelectWordOrShortcut(_))
.Times(0);
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), ReleaseCaret());
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), TapCaret(_));
}
HandleEventAndCheckState(aPressEventCreator(0, 0),
MockAccessibleCaretEventHub::PressCaretState(),
nsEventStatus_eConsumeNoDefault);
HandleEventAndCheckState(CreateLongTapEvent(0, 0),
MockAccessibleCaretEventHub::PressCaretState(),
nsEventStatus_eConsumeNoDefault);
HandleEventAndCheckState(aReleaseEventCreator(0, 0),
MockAccessibleCaretEventHub::NoActionState(),
nsEventStatus_eConsumeNoDefault);
}
TEST_F(AccessibleCaretEventHubTester, TestMousePressMoveReleaseOnNoCaret)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestPressMoveReleaseOnNoCaret(CreateMousePressEvent, CreateMouseMoveEvent,
CreateMouseReleaseEvent);
}
TEST_F(AccessibleCaretEventHubTester, TestTouchPressMoveReleaseOnNoCaret)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestPressMoveReleaseOnNoCaret(CreateTouchStartEvent, CreateTouchMoveEvent,
CreateTouchEndEvent);
}
template <typename PressEventCreator, typename MoveEventCreator,
typename ReleaseEventCreator>
void AccessibleCaretEventHubTester::TestPressMoveReleaseOnNoCaret(
PressEventCreator aPressEventCreator, MoveEventCreator aMoveEventCreator,
ReleaseEventCreator aReleaseEventCreator) {
nscoord x0 = 0, y0 = 0;
nscoord x1 = 100, y1 = 100;
nscoord x2 = 300, y2 = 300;
nscoord x3 = 400, y3 = 400;
{
InSequence dummy;
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), PressCaret(_, _))
.WillOnce(Return(NS_ERROR_FAILURE));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), DragCaret(_)).Times(0);
}
HandleEventAndCheckState(aPressEventCreator(x0, y0),
MockAccessibleCaretEventHub::PressNoCaretState(),
nsEventStatus_eIgnore);
// A small move with the distance between (x0, y0) and (x1, y1) below the
// tolerance value.
HandleEventAndCheckState(aMoveEventCreator(x1, y1),
MockAccessibleCaretEventHub::PressNoCaretState(),
nsEventStatus_eIgnore);
// A large move to simulate a dragging to select text since the distance
// between (x0, y0) and (x2, y2) is above the tolerance value.
HandleEventAndCheckState(aMoveEventCreator(x2, y2),
MockAccessibleCaretEventHub::NoActionState(),
nsEventStatus_eIgnore);
HandleEventAndCheckState(aReleaseEventCreator(x3, y3),
MockAccessibleCaretEventHub::NoActionState(),
nsEventStatus_eIgnore);
}
TEST_F(AccessibleCaretEventHubTester, TestMousePressMoveReleaseOnCaret)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestPressMoveReleaseOnCaret(CreateMousePressEvent, CreateMouseMoveEvent,
CreateMouseReleaseEvent);
}
TEST_F(AccessibleCaretEventHubTester, TestTouchPressMoveReleaseOnCaret)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestPressMoveReleaseOnCaret(CreateTouchStartEvent, CreateTouchMoveEvent,
CreateTouchEndEvent);
}
template <typename PressEventCreator, typename MoveEventCreator,
typename ReleaseEventCreator>
void AccessibleCaretEventHubTester::TestPressMoveReleaseOnCaret(
PressEventCreator aPressEventCreator, MoveEventCreator aMoveEventCreator,
ReleaseEventCreator aReleaseEventCreator) {
nscoord x0 = 0, y0 = 0;
nscoord x1 = 100, y1 = 100;
nscoord x2 = 300, y2 = 300;
nscoord x3 = 400, y3 = 400;
{
InSequence dummy;
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), PressCaret(_, _))
.WillOnce(Return(NS_OK));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), DragCaret(_))
.Times(2) // two valid drag operations
.WillRepeatedly(Return(NS_OK));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), ReleaseCaret())
.WillOnce(Return(NS_OK));
}
HandleEventAndCheckState(aPressEventCreator(x0, y0),
MockAccessibleCaretEventHub::PressCaretState(),
nsEventStatus_eConsumeNoDefault);
// A small move with the distance between (x0, y0) and (x1, y1) below the
// tolerance value.
HandleEventAndCheckState(aMoveEventCreator(x1, y1),
MockAccessibleCaretEventHub::PressCaretState(),
nsEventStatus_eConsumeNoDefault);
// A large move forms a valid drag since the distance between (x0, y0) and
// (x2, y2) is above the tolerance value.
HandleEventAndCheckState(aMoveEventCreator(x2, y2),
MockAccessibleCaretEventHub::DragCaretState(),
nsEventStatus_eConsumeNoDefault);
// Also a valid drag since the distance between (x0, y0) and (x3, y3) above
// the tolerance value even if the distance between (x2, y2) and (x3, y3) is
// below the tolerance value.
HandleEventAndCheckState(aMoveEventCreator(x3, y3),
MockAccessibleCaretEventHub::DragCaretState(),
nsEventStatus_eConsumeNoDefault);
HandleEventAndCheckState(aReleaseEventCreator(x3, y3),
MockAccessibleCaretEventHub::NoActionState(),
nsEventStatus_eConsumeNoDefault);
}
TEST_F(AccessibleCaretEventHubTester,
TestTouchStartMoveEndOnCaretWithTouchCancelIgnored)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
nscoord x0 = 0, y0 = 0;
nscoord x1 = 100, y1 = 100;
nscoord x2 = 300, y2 = 300;
nscoord x3 = 400, y3 = 400;
{
InSequence dummy;
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), PressCaret(_, _))
.WillOnce(Return(NS_OK));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), DragCaret(_))
.WillOnce(Return(NS_OK));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), ReleaseCaret())
.WillOnce(Return(NS_OK));
}
// All the eTouchCancel events should be ignored in this test.
HandleEventAndCheckState(CreateTouchStartEvent(x0, y0),
MockAccessibleCaretEventHub::PressCaretState(),
nsEventStatus_eConsumeNoDefault);
HandleEventAndCheckState(CreateTouchCancelEvent(x0, y0),
MockAccessibleCaretEventHub::PressCaretState(),
nsEventStatus_eIgnore);
// A small move with the distance between (x0, y0) and (x1, y1) below the
// tolerance value.
HandleEventAndCheckState(CreateTouchMoveEvent(x1, y1),
MockAccessibleCaretEventHub::PressCaretState(),
nsEventStatus_eConsumeNoDefault);
HandleEventAndCheckState(CreateTouchCancelEvent(x1, y1),
MockAccessibleCaretEventHub::PressCaretState(),
nsEventStatus_eIgnore);
// A large move forms a valid drag since the distance between (x0, y0) and
// (x2, y2) is above the tolerance value.
HandleEventAndCheckState(CreateTouchMoveEvent(x2, y2),
MockAccessibleCaretEventHub::DragCaretState(),
nsEventStatus_eConsumeNoDefault);
HandleEventAndCheckState(CreateTouchCancelEvent(x2, y2),
MockAccessibleCaretEventHub::DragCaretState(),
nsEventStatus_eIgnore);
HandleEventAndCheckState(CreateTouchEndEvent(x3, y3),
MockAccessibleCaretEventHub::NoActionState(),
nsEventStatus_eConsumeNoDefault);
HandleEventAndCheckState(CreateTouchCancelEvent(x3, y3),
MockAccessibleCaretEventHub::NoActionState(),
nsEventStatus_eIgnore);
}
TEST_F(AccessibleCaretEventHubTester, TestMouseLongTapWithSelectWordSuccessful)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestLongTapWithSelectWordSuccessful(CreateMousePressEvent,
CreateMouseReleaseEvent);
}
TEST_F(AccessibleCaretEventHubTester, TestTouchLongTapWithSelectWordSuccessful)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestLongTapWithSelectWordSuccessful(CreateTouchStartEvent,
CreateTouchEndEvent);
}
template <typename PressEventCreator, typename ReleaseEventCreator>
void AccessibleCaretEventHubTester::TestLongTapWithSelectWordSuccessful(
PressEventCreator aPressEventCreator,
ReleaseEventCreator aReleaseEventCreator) {
MockFunction<void(::std::string aCheckPointName)> check;
{
InSequence dummy;
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), PressCaret(_, _))
.WillOnce(Return(NS_ERROR_FAILURE));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), SelectWordOrShortcut(_))
.WillOnce(Return(NS_OK));
EXPECT_CALL(check, Call("longtap with scrolling"));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), PressCaret(_, _))
.WillOnce(Return(NS_ERROR_FAILURE));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), SelectWordOrShortcut(_))
.WillOnce(Return(NS_OK));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollStart());
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollEnd());
}
// Test long tap without scrolling.
HandleEventAndCheckState(aPressEventCreator(0, 0),
MockAccessibleCaretEventHub::PressNoCaretState(),
nsEventStatus_eIgnore);
HandleEventAndCheckState(CreateLongTapEvent(0, 0),
MockAccessibleCaretEventHub::LongTapState(),
nsEventStatus_eIgnore);
HandleEventAndCheckState(aReleaseEventCreator(0, 0),
MockAccessibleCaretEventHub::NoActionState(),
nsEventStatus_eIgnore);
// On Fennec, after long tap, the script might scroll and zoom the input field
// to the center of the screen to make typing easier before the user lifts the
// finger.
check.Call("longtap with scrolling");
HandleEventAndCheckState(aPressEventCreator(1, 1),
MockAccessibleCaretEventHub::PressNoCaretState(),
nsEventStatus_eIgnore);
HandleEventAndCheckState(CreateLongTapEvent(1, 1),
MockAccessibleCaretEventHub::LongTapState(),
nsEventStatus_eIgnore);
RefPtr<MockAccessibleCaretEventHub> hub(mHub);
hub->AsyncPanZoomStarted();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
hub->ScrollPositionChanged();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
hub->AsyncPanZoomStopped();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::NoActionState());
HandleEventAndCheckState(aReleaseEventCreator(1, 1),
MockAccessibleCaretEventHub::NoActionState(),
nsEventStatus_eIgnore);
}
TEST_F(AccessibleCaretEventHubTester, TestMouseLongTapWithSelectWordFailed)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestLongTapWithSelectWordFailed(CreateMousePressEvent,
CreateMouseReleaseEvent);
}
TEST_F(AccessibleCaretEventHubTester, TestTouchLongTapWithSelectWordFailed)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestLongTapWithSelectWordFailed(CreateTouchStartEvent, CreateTouchEndEvent);
}
template <typename PressEventCreator, typename ReleaseEventCreator>
void AccessibleCaretEventHubTester::TestLongTapWithSelectWordFailed(
PressEventCreator aPressEventCreator,
ReleaseEventCreator aReleaseEventCreator) {
{
InSequence dummy;
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), PressCaret(_, _))
.WillOnce(Return(NS_ERROR_FAILURE));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), SelectWordOrShortcut(_))
.WillOnce(Return(NS_ERROR_FAILURE));
}
HandleEventAndCheckState(aPressEventCreator(0, 0),
MockAccessibleCaretEventHub::PressNoCaretState(),
nsEventStatus_eIgnore);
HandleEventAndCheckState(CreateLongTapEvent(0, 0),
MockAccessibleCaretEventHub::LongTapState(),
nsEventStatus_eIgnore);
HandleEventAndCheckState(aReleaseEventCreator(0, 0),
MockAccessibleCaretEventHub::NoActionState(),
nsEventStatus_eIgnore);
}
TEST_F(AccessibleCaretEventHubTester, TestTouchEventDrivenAsyncPanZoomScroll)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestEventDrivenAsyncPanZoomScroll(CreateTouchStartEvent, CreateTouchMoveEvent,
CreateTouchEndEvent);
}
TEST_F(AccessibleCaretEventHubTester, TestMouseEventDrivenAsyncPanZoomScroll)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
TestEventDrivenAsyncPanZoomScroll(CreateMousePressEvent, CreateMouseMoveEvent,
CreateMouseReleaseEvent);
}
template <typename PressEventCreator, typename MoveEventCreator,
typename ReleaseEventCreator>
void AccessibleCaretEventHubTester::TestEventDrivenAsyncPanZoomScroll(
PressEventCreator aPressEventCreator, MoveEventCreator aMoveEventCreator,
ReleaseEventCreator aReleaseEventCreator) {
MockFunction<void(::std::string aCheckPointName)> check;
{
InSequence dummy;
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), PressCaret(_, _))
.WillOnce(Return(NS_ERROR_FAILURE));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), DragCaret(_)).Times(0);
EXPECT_CALL(check, Call("1"));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollStart());
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollEnd());
EXPECT_CALL(check, Call("2"));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), PressCaret(_, _))
.WillOnce(Return(NS_ERROR_FAILURE));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), DragCaret(_)).Times(0);
EXPECT_CALL(check, Call("3"));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollStart());
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollEnd());
}
// Receive press event.
HandleEventAndCheckState(aPressEventCreator(0, 0),
MockAccessibleCaretEventHub::PressNoCaretState(),
nsEventStatus_eIgnore);
HandleEventAndCheckState(aMoveEventCreator(100, 100),
MockAccessibleCaretEventHub::PressNoCaretState(),
nsEventStatus_eIgnore);
check.Call("1");
// Event driven scroll started
RefPtr<MockAccessibleCaretEventHub> hub(mHub);
hub->AsyncPanZoomStarted();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
HandleEventAndCheckState(aMoveEventCreator(160, 160),
MockAccessibleCaretEventHub::ScrollState(),
nsEventStatus_eIgnore);
hub->ScrollPositionChanged();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
// Event driven scroll ended
hub->AsyncPanZoomStopped();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::NoActionState());
HandleEventAndCheckState(aReleaseEventCreator(210, 210),
MockAccessibleCaretEventHub::NoActionState(),
nsEventStatus_eIgnore);
check.Call("2");
// Receive another press event.
HandleEventAndCheckState(aPressEventCreator(220, 220),
MockAccessibleCaretEventHub::PressNoCaretState(),
nsEventStatus_eIgnore);
HandleEventAndCheckState(aMoveEventCreator(230, 230),
MockAccessibleCaretEventHub::PressNoCaretState(),
nsEventStatus_eIgnore);
check.Call("3");
// Another APZ scroll started
hub->AsyncPanZoomStarted();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
hub->ScrollPositionChanged();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
// Another APZ scroll ended
hub->AsyncPanZoomStopped();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::NoActionState());
HandleEventAndCheckState(aReleaseEventCreator(310, 310),
MockAccessibleCaretEventHub::NoActionState(),
nsEventStatus_eIgnore);
}
TEST_F(AccessibleCaretEventHubTester, TestAsyncPanZoomScroll)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION { TestAsyncPanZoomScroll(); }
void AccessibleCaretEventHubTester::TestAsyncPanZoomScroll() {
MockFunction<void(::std::string aCheckPointName)> check;
{
InSequence dummy;
EXPECT_CALL(check, Call("1"));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollStart());
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(),
OnScrollPositionChanged());
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollEnd());
EXPECT_CALL(check, Call("2"));
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollStart());
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(),
OnScrollPositionChanged());
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollEnd());
}
// First APZ scrolling.
check.Call("1");
RefPtr<MockAccessibleCaretEventHub> hub(mHub);
hub->AsyncPanZoomStarted();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
hub->ScrollPositionChanged();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
hub->AsyncPanZoomStopped();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::NoActionState());
// Second APZ scrolling.
check.Call("2");
hub->AsyncPanZoomStarted();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
hub->ScrollPositionChanged();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
hub->AsyncPanZoomStopped();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::NoActionState());
}
TEST_F(AccessibleCaretEventHubTester, TestAsyncPanZoomScrollStartedThenBlur)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
{
InSequence dummy;
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollStart());
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollEnd()).Times(0);
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnBlur());
}
RefPtr<MockAccessibleCaretEventHub> hub(mHub);
hub->AsyncPanZoomStarted();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
hub->ScrollPositionChanged();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
hub->NotifyBlur(true);
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::NoActionState());
}
TEST_F(AccessibleCaretEventHubTester, TestAsyncPanZoomScrollEndedThenBlur)
MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
{
InSequence dummy;
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollStart());
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnScrollEnd());
EXPECT_CALL(*mHub->GetMockAccessibleCaretManager(), OnBlur());
}
RefPtr<MockAccessibleCaretEventHub> hub(mHub);
hub->AsyncPanZoomStarted();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
hub->ScrollPositionChanged();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::ScrollState());
hub->AsyncPanZoomStopped();
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::NoActionState());
hub->NotifyBlur(true);
EXPECT_EQ(hub->GetState(), MockAccessibleCaretEventHub::NoActionState());
}
} // namespace mozilla