/*
 * Copyright (C) 2016 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.
 */

package com.android.server.accessibility;

import static android.view.KeyCharacterMap.VIRTUAL_KEYBOARD;
import static android.view.MotionEvent.ACTION_DOWN;
import static android.view.MotionEvent.ACTION_HOVER_MOVE;
import static android.view.MotionEvent.ACTION_UP;
import static android.view.WindowManagerPolicyConstants.FLAG_INJECTED_FROM_ACCESSIBILITY;
import static android.view.WindowManagerPolicyConstants.FLAG_PASS_TO_USER;

import static org.hamcrest.CoreMatchers.allOf;
import static org.hamcrest.CoreMatchers.anyOf;
import static org.hamcrest.CoreMatchers.everyItem;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.hamcrest.MockitoHamcrest.argThat;

import android.accessibilityservice.GestureDescription.GestureStep;
import android.accessibilityservice.GestureDescription.TouchPoint;
import android.accessibilityservice.IAccessibilityServiceClient;
import android.graphics.Point;
import android.os.Handler;
import android.os.Message;
import android.os.RemoteException;
import android.view.Display;
import android.view.InputDevice;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.accessibility.AccessibilityEvent;

import androidx.test.runner.AndroidJUnit4;

import com.android.server.accessibility.test.MessageCapturingHandler;
import com.android.server.accessibility.utils.MotionEventMatcher;

import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.TypeSafeMatcher;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Tests for MotionEventInjector
 */
@RunWith(AndroidJUnit4.class)
public class MotionEventInjectorTest {
    private static final String LOG_TAG = "MotionEventInjectorTest";
    private static final Matcher<MotionEvent> IS_ACTION_DOWN =
            new MotionEventActionMatcher(ACTION_DOWN);
    private static final Matcher<MotionEvent> IS_ACTION_POINTER_DOWN =
            new MotionEventActionMatcher(MotionEvent.ACTION_POINTER_DOWN);
    private static final Matcher<MotionEvent> IS_ACTION_UP =
            new MotionEventActionMatcher(ACTION_UP);
    private static final Matcher<MotionEvent> IS_ACTION_POINTER_UP =
            new MotionEventActionMatcher(MotionEvent.ACTION_POINTER_UP);
    private static final Matcher<MotionEvent> IS_ACTION_CANCEL =
            new MotionEventActionMatcher(MotionEvent.ACTION_CANCEL);
    private static final Matcher<MotionEvent> IS_ACTION_MOVE =
            new MotionEventActionMatcher(MotionEvent.ACTION_MOVE);

    private static final Point LINE_START = new Point(100, 200);
    private static final Point LINE_END = new Point(100, 300);
    private static final int LINE_DURATION = 100;
    private static final int LINE_SEQUENCE = 50;

    private static final Point CLICK_POINT = new Point(1000, 2000);
    private static final int CLICK_DURATION = 10;
    private static final int CLICK_SEQUENCE = 51;

    private static final int MOTION_EVENT_SOURCE = InputDevice.SOURCE_TOUCHSCREEN;
    private static final int OTHER_EVENT_SOURCE = InputDevice.SOURCE_MOUSE;

    private static final Point CONTINUED_LINE_START = new Point(500, 300);
    private static final Point CONTINUED_LINE_MID1 = new Point(500, 400);
    private static final Point CONTINUED_LINE_MID2 = new Point(600, 300);
    private static final Point CONTINUED_LINE_END = new Point(600, 400);
    private static final int CONTINUED_LINE_STROKE_ID_1 = 100;
    private static final int CONTINUED_LINE_STROKE_ID_2 = 101;
    private static final int CONTINUED_LINE_INTERVAL = 100;
    private static final int CONTINUED_LINE_SEQUENCE_1 = 52;
    private static final int CONTINUED_LINE_SEQUENCE_2 = 53;

    private static final float PRESSURE = 1;
    private static final float X_PRECISION = 1;
    private static final float Y_PRECISION = 1;
    private static final int EDGEFLAGS = 0;
    private static final float POINTER_SIZE = 1;
    private static final int METASTATE = 0;

    MotionEventInjector mMotionEventInjector;
    IAccessibilityServiceClient mServiceInterface;
    AccessibilityTraceManager mTrace;
    List<GestureStep> mLineList = new ArrayList<>();
    List<GestureStep> mClickList = new ArrayList<>();
    List<GestureStep> mContinuedLineList1 = new ArrayList<>();
    List<GestureStep> mContinuedLineList2 = new ArrayList<>();

    MotionEvent mClickDownEvent;
    MotionEvent mClickUpEvent;
    MotionEvent mHoverMoveEvent;

    ArgumentCaptor<MotionEvent> mCaptor1 = ArgumentCaptor.forClass(MotionEvent.class);
    ArgumentCaptor<MotionEvent> mCaptor2 = ArgumentCaptor.forClass(MotionEvent.class);
    MessageCapturingHandler mMessageCapturingHandler;
    Matcher<MotionEvent> mIsLineStart;
    Matcher<MotionEvent> mIsLineMiddle;
    Matcher<MotionEvent> mIsLineEnd;
    Matcher<MotionEvent> mIsClickDown;
    Matcher<MotionEvent> mIsClickUp;

    @Before
    public void setUp() {
        mMessageCapturingHandler = new MessageCapturingHandler(new Handler.Callback() {
            @Override
            public boolean handleMessage(Message msg) {
                return mMotionEventInjector.handleMessage(msg);
            }
        });
        mTrace = mock(AccessibilityTraceManager.class);
        mMotionEventInjector = new MotionEventInjector(mMessageCapturingHandler, mTrace);
        mServiceInterface = mock(IAccessibilityServiceClient.class);

        mLineList = createSimpleGestureFromPoints(0, 0, false, LINE_DURATION, LINE_START, LINE_END);
        mClickList = createSimpleGestureFromPoints(
                0, 0, false, CLICK_DURATION, CLICK_POINT, CLICK_POINT);
        mContinuedLineList1 = createSimpleGestureFromPoints(CONTINUED_LINE_STROKE_ID_1, 0, true,
                CONTINUED_LINE_INTERVAL, CONTINUED_LINE_START, CONTINUED_LINE_MID1);
        mContinuedLineList2 = createSimpleGestureFromPoints(CONTINUED_LINE_STROKE_ID_2,
                CONTINUED_LINE_STROKE_ID_1, false, CONTINUED_LINE_INTERVAL, CONTINUED_LINE_MID1,
                CONTINUED_LINE_MID2, CONTINUED_LINE_END);

        mClickDownEvent = MotionEvent.obtain(0, 0, ACTION_DOWN, CLICK_POINT.x, CLICK_POINT.y,
                 PRESSURE, POINTER_SIZE, METASTATE, X_PRECISION, Y_PRECISION, VIRTUAL_KEYBOARD,
                 EDGEFLAGS);
        mClickDownEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
        mClickUpEvent = MotionEvent.obtain(0, CLICK_DURATION, ACTION_UP, CLICK_POINT.x,
                CLICK_POINT.y, PRESSURE, POINTER_SIZE, METASTATE, X_PRECISION, Y_PRECISION,
                VIRTUAL_KEYBOARD, EDGEFLAGS);
        mClickUpEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);

        mHoverMoveEvent = MotionEvent.obtain(0, 0, ACTION_HOVER_MOVE, CLICK_POINT.x, CLICK_POINT.y,
                PRESSURE, POINTER_SIZE, METASTATE, X_PRECISION, Y_PRECISION, VIRTUAL_KEYBOARD,
                EDGEFLAGS);
        mHoverMoveEvent.setSource(InputDevice.SOURCE_MOUSE);

        mIsLineStart = allOf(IS_ACTION_DOWN, isAtPoint(LINE_START), hasStandardInitialization(),
                hasTimeFromDown(0));
        mIsLineMiddle = allOf(IS_ACTION_MOVE, isAtPoint(LINE_END), hasStandardInitialization(),
                hasTimeFromDown(LINE_DURATION));
        mIsLineEnd = allOf(IS_ACTION_UP, isAtPoint(LINE_END), hasStandardInitialization(),
                hasTimeFromDown(LINE_DURATION));
        mIsClickDown = allOf(IS_ACTION_DOWN, isAtPoint(CLICK_POINT), hasStandardInitialization(),
                hasTimeFromDown(0));
        mIsClickUp = allOf(IS_ACTION_UP, isAtPoint(CLICK_POINT), hasStandardInitialization(),
                hasTimeFromDown(CLICK_DURATION));
    }

    @After
    public void tearDown() {
        mMessageCapturingHandler.removeAllMessages();
    }


    @Test
    public void testInjectEvents_shouldEmergeInOrderWithCorrectTiming() throws RemoteException {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);
        verifyNoMoreInteractions(next);
        mMessageCapturingHandler.sendOneMessage(); // Send a motion event

        final int expectedFlags = FLAG_PASS_TO_USER | FLAG_INJECTED_FROM_ACCESSIBILITY;
        verify(next).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), eq(expectedFlags));
        verify(next).onMotionEvent(argThat(mIsLineStart), argThat(mIsLineStart), eq(expectedFlags));
        verifyNoMoreInteractions(next);
        reset(next);

        Matcher<MotionEvent> hasRightDownTime = hasDownTime(mCaptor1.getValue().getDownTime());

        mMessageCapturingHandler.sendOneMessage(); // Send a motion event
        verify(next).onMotionEvent(argThat(allOf(mIsLineMiddle, hasRightDownTime)),
                argThat(allOf(mIsLineMiddle, hasRightDownTime)), eq(expectedFlags));
        verifyNoMoreInteractions(next);
        reset(next);

        verifyZeroInteractions(mServiceInterface);

        mMessageCapturingHandler.sendOneMessage(); // Send a motion event
        verify(next).onMotionEvent(argThat(allOf(mIsLineEnd, hasRightDownTime)),
                argThat(allOf(mIsLineEnd, hasRightDownTime)), eq(expectedFlags));
        verifyNoMoreInteractions(next);

        verify(mServiceInterface).onPerformGestureResult(LINE_SEQUENCE, true);
        verifyNoMoreInteractions(mServiceInterface);
    }

    @Test
    public void testInjectEvents_gestureWithTooManyPoints_shouldNotCrash() throws  Exception {
        int tooManyPointsCount = 20;
        TouchPoint[] startTouchPoints = new TouchPoint[tooManyPointsCount];
        TouchPoint[] endTouchPoints = new TouchPoint[tooManyPointsCount];
        for (int i = 0; i < tooManyPointsCount; i++) {
            startTouchPoints[i] = new TouchPoint();
            startTouchPoints[i].mIsStartOfPath = true;
            startTouchPoints[i].mX = i;
            startTouchPoints[i].mY = i;
            endTouchPoints[i] = new TouchPoint();
            endTouchPoints[i].mIsEndOfPath = true;
            endTouchPoints[i].mX = i;
            endTouchPoints[i].mY = i;
        }
        List<GestureStep> events = Arrays.asList(
                new GestureStep(0, tooManyPointsCount, startTouchPoints),
                new GestureStep(CLICK_DURATION, tooManyPointsCount, endTouchPoints));
        attachMockNext(mMotionEventInjector);
        injectEventsSync(events, mServiceInterface, CLICK_SEQUENCE);
        mMessageCapturingHandler.sendAllMessages();
        verify(mServiceInterface).onPerformGestureResult(eq(CLICK_SEQUENCE), anyBoolean());
    }

    @Test
    public void testRegularEvent_afterGestureComplete_shouldPassToNext() {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        reset(next);
        mMotionEventInjector.onMotionEvent(mClickDownEvent, mClickDownEvent, 0);
        verify(next).onMotionEvent(argThat(mIsClickDown), argThat(mIsClickDown),
                eq(FLAG_INJECTED_FROM_ACCESSIBILITY));
    }

    @Test
    public void testInjectEvents_withRealGestureUnderway_shouldCancelRealAndPassInjected() {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        mMotionEventInjector.onMotionEvent(mClickDownEvent, mClickDownEvent, 0);
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);

        verify(next, times(2)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        assertThat(mCaptor1.getAllValues().get(0), mIsClickDown);
        assertThat(mCaptor1.getAllValues().get(1), IS_ACTION_CANCEL);
        reset(next);

        mMessageCapturingHandler.sendOneMessage(); // Send a motion event
        verify(next).onMotionEvent(
                argThat(mIsLineStart), argThat(mIsLineStart),
                eq(FLAG_PASS_TO_USER | FLAG_INJECTED_FROM_ACCESSIBILITY));
    }

    @Test
    public void testInjectEvents_withRealMouseGestureUnderway_shouldContinueRealAndPassInjected() {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        MotionEvent mouseEvent = MotionEvent.obtain(mClickDownEvent);
        mouseEvent.setSource(InputDevice.SOURCE_MOUSE);
        MotionEventMatcher isMouseEvent = new MotionEventMatcher(mouseEvent);
        mMotionEventInjector.onMotionEvent(mouseEvent, mouseEvent, 0);
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);

        mMessageCapturingHandler.sendOneMessage(); // Send a motion event
        verify(next, times(2)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        assertThat(mCaptor1.getAllValues().get(0), isMouseEvent);
        assertThat(mCaptor1.getAllValues().get(1), mIsLineStart);
    }

    @Test
    public void testInjectEvents_withRealGestureFinished_shouldJustPassInjected() {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        mMotionEventInjector.onMotionEvent(mClickDownEvent, mClickDownEvent, 0);
        mMotionEventInjector.onMotionEvent(mClickUpEvent, mClickUpEvent, 0);

        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);
        verify(next, times(2)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        assertThat(mCaptor1.getAllValues().get(0), mIsClickDown);
        assertThat(mCaptor1.getAllValues().get(1), mIsClickUp);
        reset(next);

        mMessageCapturingHandler.sendOneMessage(); // Send a motion event
        verify(next).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(),
                eq(FLAG_PASS_TO_USER | FLAG_INJECTED_FROM_ACCESSIBILITY));
        verify(next).onMotionEvent(
                argThat(mIsLineStart), argThat(mIsLineStart),
                eq(FLAG_PASS_TO_USER | FLAG_INJECTED_FROM_ACCESSIBILITY));
    }

    @Test
    public void testOnMotionEvents_openInjectedGestureInProgress_shouldCancelAndNotifyAndPassReal()
            throws RemoteException {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);
        mMessageCapturingHandler.sendOneMessage(); // Send a motion event
        mMotionEventInjector.onMotionEvent(mClickDownEvent, mClickDownEvent, 0);

        verify(next, times(3)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        assertThat(mCaptor1.getAllValues().get(0), mIsLineStart);
        assertThat(mCaptor1.getAllValues().get(1), IS_ACTION_CANCEL);
        assertThat(mCaptor1.getAllValues().get(2), mIsClickDown);
        verify(mServiceInterface).onPerformGestureResult(LINE_SEQUENCE, false);
    }

    @Test
    public void
            testOnMotionEvents_fromMouseWithInjectedGestureInProgress_shouldNotCancelAndPassReal()
            throws RemoteException {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);
        mMessageCapturingHandler.sendOneMessage(); // Send a motion event
        mMotionEventInjector.onMotionEvent(mHoverMoveEvent, mHoverMoveEvent, 0);
        mMessageCapturingHandler.sendAllMessages();

        verify(next, times(3)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        assertThat(mCaptor1.getAllValues().get(0), mIsLineStart);
        assertThat(mCaptor1.getAllValues().get(1), mIsLineMiddle);
        assertThat(mCaptor1.getAllValues().get(2), mIsLineEnd);
        verify(mServiceInterface).onPerformGestureResult(LINE_SEQUENCE, true);
    }

    @Test
    public void testOnMotionEvents_closedInjectedGestureInProgress_shouldOnlyNotifyAndPassReal()
            throws RemoteException {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        // Tack a click down to the end of the line
        TouchPoint clickTouchPoint = new TouchPoint();
        clickTouchPoint.mIsStartOfPath = true;
        clickTouchPoint.mX = CLICK_POINT.x;
        clickTouchPoint.mY = CLICK_POINT.y;
        mLineList.add(new GestureStep(0, 1, new TouchPoint[] {clickTouchPoint}));

        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);

        // Send 3 motion events, leaving the extra down in the queue
        mMessageCapturingHandler.sendOneMessage();
        mMessageCapturingHandler.sendOneMessage();
        mMessageCapturingHandler.sendOneMessage();

        mMotionEventInjector.onMotionEvent(mClickDownEvent, mClickDownEvent, 0);

        verify(next, times(4)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        assertThat(mCaptor1.getAllValues().get(0), mIsLineStart);
        assertThat(mCaptor1.getAllValues().get(1), mIsLineMiddle);
        assertThat(mCaptor1.getAllValues().get(2), mIsLineEnd);
        assertThat(mCaptor1.getAllValues().get(3), mIsClickDown);
        verify(mServiceInterface).onPerformGestureResult(LINE_SEQUENCE, false);
        assertFalse(mMessageCapturingHandler.hasMessages());
    }

    @Test
    public void testInjectEvents_openInjectedGestureInProgress_shouldCancelAndNotifyAndPassNew()
            throws RemoteException {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);
        mMessageCapturingHandler.sendOneMessage(); // Send a motion event

        injectEventsSync(mClickList, mServiceInterface, CLICK_SEQUENCE);
        mMessageCapturingHandler.sendOneMessage(); // Send a motion event

        verify(mServiceInterface, times(1)).onPerformGestureResult(LINE_SEQUENCE, false);
        verify(next, times(3)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        assertThat(mCaptor1.getAllValues().get(0), mIsLineStart);
        assertThat(mCaptor1.getAllValues().get(1), IS_ACTION_CANCEL);
        assertThat(mCaptor1.getAllValues().get(2), mIsClickDown);
    }

    @Test
    public void testInjectEvents_closedInjectedGestureInProgress_shouldOnlyNotifyAndPassNew()
            throws RemoteException {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        // Tack a click down to the end of the line
        TouchPoint clickTouchPoint = new TouchPoint();
        clickTouchPoint.mIsStartOfPath = true;
        clickTouchPoint.mX = CLICK_POINT.x;
        clickTouchPoint.mY = CLICK_POINT.y;
        mLineList.add(new GestureStep(0, 1, new TouchPoint[] {clickTouchPoint}));
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);

        // Send 3 motion events, leaving newEvent in the queue
        mMessageCapturingHandler.sendOneMessage();
        mMessageCapturingHandler.sendOneMessage();
        mMessageCapturingHandler.sendOneMessage();

        injectEventsSync(mClickList, mServiceInterface, CLICK_SEQUENCE);
        mMessageCapturingHandler.sendOneMessage(); // Send a motion event

        verify(mServiceInterface).onPerformGestureResult(LINE_SEQUENCE, false);
        verify(next, times(4)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        assertThat(mCaptor1.getAllValues().get(0), mIsLineStart);
        assertThat(mCaptor1.getAllValues().get(1), mIsLineMiddle);
        assertThat(mCaptor1.getAllValues().get(2), mIsLineEnd);
        assertThat(mCaptor1.getAllValues().get(3), mIsClickDown);
    }

    @Test
    public void testContinuedGesture_continuationArrivesAfterDispatched_gestureCompletes()
            throws Exception {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(mContinuedLineList1, mServiceInterface, CONTINUED_LINE_SEQUENCE_1);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_1, true);
        injectEventsSync(mContinuedLineList2, mServiceInterface, CONTINUED_LINE_SEQUENCE_2);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_2, true);
        verify(next, times(5)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        List<MotionEvent> events = mCaptor1.getAllValues();
        long downTime = events.get(0).getDownTime();
        assertThat(events.get(0), allOf(isAtPoint(CONTINUED_LINE_START), IS_ACTION_DOWN,
                hasEventTime(downTime)));
        assertThat(events, everyItem(hasDownTime(downTime)));
        assertThat(events.get(1), allOf(isAtPoint(CONTINUED_LINE_MID1), IS_ACTION_MOVE,
                hasEventTime(downTime + CONTINUED_LINE_INTERVAL)));
        // Timing will restart when the gesture continues
        long secondSequenceStart = events.get(2).getEventTime();
        assertTrue(secondSequenceStart >= events.get(1).getEventTime());
        assertThat(events.get(2), allOf(isAtPoint(CONTINUED_LINE_MID2), IS_ACTION_MOVE));
        assertThat(events.get(3), allOf(isAtPoint(CONTINUED_LINE_END), IS_ACTION_MOVE,
                hasEventTime(secondSequenceStart + CONTINUED_LINE_INTERVAL)));
        assertThat(events.get(4), allOf(isAtPoint(CONTINUED_LINE_END), IS_ACTION_UP,
                hasEventTime(secondSequenceStart + CONTINUED_LINE_INTERVAL)));
    }

    @Test
    public void testContinuedGesture_withTwoTouchPoints_gestureCompletes()
            throws Exception {
        // Run one point through the continued line backwards
        int backLineId1 = 30;
        int backLineId2 = 30;
        List<GestureStep> continuedBackLineList1 = createSimpleGestureFromPoints(backLineId1, 0,
                true, CONTINUED_LINE_INTERVAL, CONTINUED_LINE_END, CONTINUED_LINE_MID2);
        List<GestureStep> continuedBackLineList2 = createSimpleGestureFromPoints(backLineId2,
                backLineId1, false, CONTINUED_LINE_INTERVAL, CONTINUED_LINE_MID2,
                CONTINUED_LINE_MID1, CONTINUED_LINE_START);
        List<GestureStep> combinedLines1 = combineGestureSteps(
                mContinuedLineList1, continuedBackLineList1);
        List<GestureStep> combinedLines2 = combineGestureSteps(
                mContinuedLineList2, continuedBackLineList2);

        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(combinedLines1, mServiceInterface, CONTINUED_LINE_SEQUENCE_1);
        injectEventsSync(combinedLines2, mServiceInterface, CONTINUED_LINE_SEQUENCE_2);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_1, true);
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_2, true);
        verify(next, times(7)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        List<MotionEvent> events = mCaptor1.getAllValues();
        long downTime = events.get(0).getDownTime();
        assertThat(events.get(0), allOf(
                anyOf(isAtPoint(CONTINUED_LINE_END), isAtPoint(CONTINUED_LINE_START)),
                IS_ACTION_DOWN, hasEventTime(downTime)));
        assertThat(events, everyItem(hasDownTime(downTime)));
        assertThat(events.get(1), allOf(containsPoints(CONTINUED_LINE_START, CONTINUED_LINE_END),
                IS_ACTION_POINTER_DOWN, hasEventTime(downTime)));
        assertThat(events.get(2), allOf(containsPoints(CONTINUED_LINE_MID1, CONTINUED_LINE_MID2),
                IS_ACTION_MOVE, hasEventTime(downTime + CONTINUED_LINE_INTERVAL)));
        assertThat(events.get(3), allOf(containsPoints(CONTINUED_LINE_MID1, CONTINUED_LINE_MID2),
                IS_ACTION_MOVE, hasEventTime(downTime + CONTINUED_LINE_INTERVAL * 2)));
        assertThat(events.get(4), allOf(containsPoints(CONTINUED_LINE_START, CONTINUED_LINE_END),
                IS_ACTION_MOVE, hasEventTime(downTime + CONTINUED_LINE_INTERVAL * 3)));
        assertThat(events.get(5), allOf(containsPoints(CONTINUED_LINE_START, CONTINUED_LINE_END),
                IS_ACTION_POINTER_UP, hasEventTime(downTime + CONTINUED_LINE_INTERVAL * 3)));
        assertThat(events.get(6), allOf(
                anyOf(isAtPoint(CONTINUED_LINE_END), isAtPoint(CONTINUED_LINE_START)),
                IS_ACTION_UP, hasEventTime(downTime + CONTINUED_LINE_INTERVAL * 3)));
    }


    @Test
    public void testContinuedGesture_continuationArrivesWhileDispatching_gestureCompletes()
            throws Exception {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(mContinuedLineList1, mServiceInterface, CONTINUED_LINE_SEQUENCE_1);
        mMessageCapturingHandler.sendOneMessage(); // Send a motion event
        injectEventsSync(mContinuedLineList2, mServiceInterface, CONTINUED_LINE_SEQUENCE_2);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_1, true);
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_2, true);
        verify(next, times(5)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        List<MotionEvent> events = mCaptor1.getAllValues();
        long downTime = events.get(0).getDownTime();
        assertThat(events.get(0), allOf(isAtPoint(CONTINUED_LINE_START), IS_ACTION_DOWN,
                hasEventTime(downTime)));
        assertThat(events, everyItem(hasDownTime(downTime)));
        assertThat(events.get(1), allOf(isAtPoint(CONTINUED_LINE_MID1), IS_ACTION_MOVE,
                hasEventTime(downTime + CONTINUED_LINE_INTERVAL)));
        assertThat(events.get(2), allOf(isAtPoint(CONTINUED_LINE_MID2), IS_ACTION_MOVE,
                hasEventTime(downTime + CONTINUED_LINE_INTERVAL * 2)));
        assertThat(events.get(3), allOf(isAtPoint(CONTINUED_LINE_END), IS_ACTION_MOVE,
                hasEventTime(downTime + CONTINUED_LINE_INTERVAL * 3)));
        assertThat(events.get(4), allOf(isAtPoint(CONTINUED_LINE_END), IS_ACTION_UP,
                hasEventTime(downTime + CONTINUED_LINE_INTERVAL * 3)));
    }

    @Test
    public void testContinuedGesture_twoContinuationsArriveWhileDispatching_gestureCompletes()
            throws Exception {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(mContinuedLineList1, mServiceInterface, CONTINUED_LINE_SEQUENCE_1);
        // Continue line again
        List<GestureStep> continuedLineList2 = createSimpleGestureFromPoints(
                CONTINUED_LINE_STROKE_ID_2, CONTINUED_LINE_STROKE_ID_1, true,
                CONTINUED_LINE_INTERVAL, CONTINUED_LINE_MID1,
                CONTINUED_LINE_MID2, CONTINUED_LINE_END);
        // Finish line by backtracking
        int strokeId3 = CONTINUED_LINE_STROKE_ID_2 + 1;
        int sequence3 = CONTINUED_LINE_SEQUENCE_2 + 1;
        List<GestureStep> continuedLineList3 = createSimpleGestureFromPoints(strokeId3,
                CONTINUED_LINE_STROKE_ID_2, false, CONTINUED_LINE_INTERVAL, CONTINUED_LINE_END,
                CONTINUED_LINE_MID2);

        mMessageCapturingHandler.sendOneMessage(); // Send a motion event
        injectEventsSync(continuedLineList2, mServiceInterface, CONTINUED_LINE_SEQUENCE_2);
        injectEventsSync(continuedLineList3, mServiceInterface, sequence3);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_1, true);
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_2, true);
        verify(mServiceInterface).onPerformGestureResult(sequence3, true);
        verify(next, times(6)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        List<MotionEvent> events = mCaptor1.getAllValues();
        long downTime = events.get(0).getDownTime();
        assertThat(events.get(0), allOf(isAtPoint(CONTINUED_LINE_START), IS_ACTION_DOWN,
                hasEventTime(downTime)));
        assertThat(events, everyItem(hasDownTime(downTime)));
        assertThat(events.get(1), allOf(isAtPoint(CONTINUED_LINE_MID1), IS_ACTION_MOVE,
                hasEventTime(downTime + CONTINUED_LINE_INTERVAL)));
        assertThat(events.get(2), allOf(isAtPoint(CONTINUED_LINE_MID2), IS_ACTION_MOVE,
                hasEventTime(downTime + CONTINUED_LINE_INTERVAL * 2)));
        assertThat(events.get(3), allOf(isAtPoint(CONTINUED_LINE_END), IS_ACTION_MOVE,
                hasEventTime(downTime + CONTINUED_LINE_INTERVAL * 3)));
        assertThat(events.get(4), allOf(isAtPoint(CONTINUED_LINE_MID2), IS_ACTION_MOVE,
                hasEventTime(downTime + CONTINUED_LINE_INTERVAL * 4)));
        assertThat(events.get(5), allOf(isAtPoint(CONTINUED_LINE_MID2), IS_ACTION_UP,
                hasEventTime(downTime + CONTINUED_LINE_INTERVAL * 4)));
    }

    @Test
    public void testContinuedGesture_nonContinuingGestureArrivesDuringDispatch_gestureCanceled()
            throws Exception {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(mContinuedLineList1, mServiceInterface, CONTINUED_LINE_SEQUENCE_1);
        mMessageCapturingHandler.sendOneMessage(); // Send a motion event
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_1, false);
        verify(mServiceInterface).onPerformGestureResult(LINE_SEQUENCE, true);
        verify(next, times(5)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        List<MotionEvent> events = mCaptor1.getAllValues();
        assertThat(events.get(0), allOf(isAtPoint(CONTINUED_LINE_START), IS_ACTION_DOWN));
        assertThat(events.get(1), IS_ACTION_CANCEL);
        assertThat(events.get(2), allOf(isAtPoint(LINE_START), IS_ACTION_DOWN));
        assertThat(events.get(3), allOf(isAtPoint(LINE_END), IS_ACTION_MOVE));
        assertThat(events.get(4), allOf(isAtPoint(LINE_END), IS_ACTION_UP));
    }

    @Test
    public void testContinuedGesture_nonContinuingGestureArrivesAfterDispatch_gestureCanceled()
            throws Exception {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(mContinuedLineList1, mServiceInterface, CONTINUED_LINE_SEQUENCE_1);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_1, true);
        verify(mServiceInterface).onPerformGestureResult(LINE_SEQUENCE, true);
        verify(next, times(6)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        List<MotionEvent> events = mCaptor1.getAllValues();
        assertThat(events.get(0), allOf(isAtPoint(CONTINUED_LINE_START), IS_ACTION_DOWN));
        assertThat(events.get(1), allOf(isAtPoint(CONTINUED_LINE_MID1), IS_ACTION_MOVE));
        assertThat(events.get(2), IS_ACTION_CANCEL);
        assertThat(events.get(3), allOf(isAtPoint(LINE_START), IS_ACTION_DOWN));
        assertThat(events.get(4), allOf(isAtPoint(LINE_END), IS_ACTION_MOVE));
        assertThat(events.get(5), allOf(isAtPoint(LINE_END), IS_ACTION_UP));
    }

    @Test
    public void testContinuedGesture_misMatchedContinuationArrives_bothGesturesCanceled()
            throws Exception {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(mContinuedLineList1, mServiceInterface, CONTINUED_LINE_SEQUENCE_1);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_1, true);
        List<GestureStep> discontinuousGesture = mContinuedLineList2
                .subList(1, mContinuedLineList2.size());
        injectEventsSync(discontinuousGesture, mServiceInterface, CONTINUED_LINE_SEQUENCE_2);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_2, false);
        verify(next, times(3)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        List<MotionEvent> events = mCaptor1.getAllValues();
        assertThat(events.get(0), allOf(isAtPoint(CONTINUED_LINE_START), IS_ACTION_DOWN));
        assertThat(events.get(1), allOf(isAtPoint(CONTINUED_LINE_MID1), IS_ACTION_MOVE));
        assertThat(events.get(2), allOf(isAtPoint(CONTINUED_LINE_MID1), IS_ACTION_CANCEL));
    }

    @Test
    public void testContinuedGesture_continuationArrivesFromOtherService_bothGesturesCanceled()
            throws Exception {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        IAccessibilityServiceClient otherService = mock(IAccessibilityServiceClient.class);
        injectEventsSync(mContinuedLineList1, mServiceInterface, CONTINUED_LINE_SEQUENCE_1);
        mMessageCapturingHandler.sendOneMessage(); // Send a motion events
        injectEventsSync(mContinuedLineList2, otherService, CONTINUED_LINE_SEQUENCE_2);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_1, false);
        verify(otherService).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_2, false);
        verify(next, times(2)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        List<MotionEvent> events = mCaptor1.getAllValues();
        assertThat(events.get(0), allOf(isAtPoint(CONTINUED_LINE_START), IS_ACTION_DOWN));
        assertThat(events.get(1), IS_ACTION_CANCEL);
    }

    @Test
    public void testContinuedGesture_realGestureArrivesInBetween_getsCanceled()
            throws Exception {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        injectEventsSync(mContinuedLineList1, mServiceInterface, CONTINUED_LINE_SEQUENCE_1);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_1, true);

        mMotionEventInjector.onMotionEvent(mClickDownEvent, mClickDownEvent, 0);

        injectEventsSync(mContinuedLineList2, mServiceInterface, CONTINUED_LINE_SEQUENCE_2);
        mMessageCapturingHandler.sendAllMessages(); // Send all motion events
        verify(mServiceInterface).onPerformGestureResult(CONTINUED_LINE_SEQUENCE_2, false);
        verify(next, times(4)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        List<MotionEvent> events = mCaptor1.getAllValues();
        assertThat(events.get(0), allOf(isAtPoint(CONTINUED_LINE_START), IS_ACTION_DOWN));
        assertThat(events.get(1), allOf(isAtPoint(CONTINUED_LINE_MID1), IS_ACTION_MOVE));
        assertThat(events.get(2), IS_ACTION_CANCEL);
        assertThat(events.get(3), allOf(isAtPoint(CLICK_POINT), IS_ACTION_DOWN));
    }

    @Test
    public void testClearEvents_realGestureInProgress_shouldForgetAboutGesture() {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        mMotionEventInjector.onMotionEvent(mClickDownEvent, mClickDownEvent, 0);
        mMotionEventInjector.clearEvents(MOTION_EVENT_SOURCE);
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);
        mMessageCapturingHandler.sendOneMessage(); // Send a motion event

        verify(next, times(2)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        assertThat(mCaptor1.getAllValues().get(0), mIsClickDown);
        assertThat(mCaptor1.getAllValues().get(1), mIsLineStart);
    }

    @Test
    public void testClearEventsOnOtherSource_realGestureInProgress_shouldNotForgetAboutGesture() {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        mMotionEventInjector.onMotionEvent(mClickDownEvent, mClickDownEvent, 0);
        mMotionEventInjector.clearEvents(OTHER_EVENT_SOURCE);
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);
        mMessageCapturingHandler.sendOneMessage(); // Send a motion event

        verify(next, times(3)).onMotionEvent(mCaptor1.capture(), mCaptor2.capture(), anyInt());
        assertThat(mCaptor1.getAllValues().get(0), mIsClickDown);
        assertThat(mCaptor1.getAllValues().get(1), IS_ACTION_CANCEL);
        assertThat(mCaptor1.getAllValues().get(2), mIsLineStart);
    }

    @Test
    public void testOnDestroy_shouldCancelGestures() throws RemoteException {
        mMotionEventInjector.onDestroy();
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);
        verify(mServiceInterface).onPerformGestureResult(LINE_SEQUENCE, false);
    }

    @Test
    public void testInjectEvents_withNoNext_shouldCancel() throws RemoteException {
        injectEventsSync(mLineList, mServiceInterface, LINE_SEQUENCE);
        verify(mServiceInterface).onPerformGestureResult(LINE_SEQUENCE, false);
    }

    @Test
    public void testOnMotionEvent_withNoNext_shouldNotCrash() {
        mMotionEventInjector.onMotionEvent(mClickDownEvent, mClickDownEvent, 0);
    }

    @Test
    public void testOnKeyEvent_shouldPassToNext() {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        KeyEvent event = new KeyEvent(0, 0);
        mMotionEventInjector.onKeyEvent(event, 0);
        verify(next).onKeyEvent(event, 0);
    }

    @Test
    public void testOnKeyEvent_withNoNext_shouldNotCrash() {
        KeyEvent event = new KeyEvent(0, 0);
        mMotionEventInjector.onKeyEvent(event, 0);
    }

    @Test
    public void testOnAccessibilityEvent_shouldPassToNext() {
        EventStreamTransformation next = attachMockNext(mMotionEventInjector);
        AccessibilityEvent event = AccessibilityEvent.obtain();
        mMotionEventInjector.onAccessibilityEvent(event);
        verify(next).onAccessibilityEvent(event);
    }

    @Test
    public void testOnAccessibilityEvent_withNoNext_shouldNotCrash() {
        AccessibilityEvent event = AccessibilityEvent.obtain();
        mMotionEventInjector.onAccessibilityEvent(event);
    }

    private void injectEventsSync(List<GestureStep> gestureSteps,
            IAccessibilityServiceClient serviceInterface, int sequence) {
        mMotionEventInjector.injectEvents(gestureSteps, serviceInterface, sequence,
                Display.DEFAULT_DISPLAY);
        // Dispatch the message sent by the injector. Our simple handler doesn't guarantee stuff
        // happens in order.
        mMessageCapturingHandler.sendLastMessage();
    }

    private List<GestureStep> createSimpleGestureFromPoints(int strokeId, int continuedStrokeId,
            boolean continued, long interval, Point... points) {
        List<GestureStep> gesture = new ArrayList<>(points.length);
        TouchPoint[] touchPoints = new TouchPoint[1];
        touchPoints[0] = new TouchPoint();
        for (int i = 0; i < points.length; i++) {
            touchPoints[0].mX = points[i].x;
            touchPoints[0].mY = points[i].y;
            touchPoints[0].mIsStartOfPath = ((i == 0) && (continuedStrokeId <= 0));
            touchPoints[0].mContinuedStrokeId = continuedStrokeId;
            touchPoints[0].mStrokeId = strokeId;
            touchPoints[0].mIsEndOfPath = ((i == points.length - 1) && !continued);
            gesture.add(new GestureStep(interval * i, 1, touchPoints));
        }
        return gesture;
    }

    List<GestureStep> combineGestureSteps(List<GestureStep> list1, List<GestureStep> list2) {
        assertEquals(list1.size(), list2.size());
        List<GestureStep> gesture = new ArrayList<>(list1.size());
        for (int i = 0; i < list1.size(); i++) {
            int numPoints1 = list1.get(i).numTouchPoints;
            int numPoints2 = list2.get(i).numTouchPoints;
            TouchPoint[] touchPoints = new TouchPoint[numPoints1 + numPoints2];
            for (int j = 0; j < numPoints1; j++) {
                touchPoints[j] = new TouchPoint();
                touchPoints[j].copyFrom(list1.get(i).touchPoints[j]);
            }
            for (int j = 0; j < numPoints2; j++) {
                touchPoints[numPoints1 + j] = new TouchPoint();
                touchPoints[numPoints1 + j].copyFrom(list2.get(i).touchPoints[j]);
            }
            gesture.add(new GestureStep(list1.get(i).timeSinceGestureStart,
                    numPoints1 + numPoints2, touchPoints));
        }
        return gesture;
    }

    private EventStreamTransformation attachMockNext(MotionEventInjector motionEventInjector) {
        EventStreamTransformation next = mock(EventStreamTransformation.class);
        motionEventInjector.setNext(next);
        return next;
    }

    private static class MotionEventActionMatcher extends TypeSafeMatcher<MotionEvent> {
        int mAction;

        MotionEventActionMatcher(int action) {
            super();
            mAction = action;
        }

        @Override
        protected boolean matchesSafely(MotionEvent motionEvent) {
            return motionEvent.getActionMasked() == mAction;
        }

        @Override
        public void describeTo(Description description) {
            description.appendText("Matching to action " + mAction);
        }
    }

    private static TypeSafeMatcher<MotionEvent> isAtPoint(final Point point) {
        return new TypeSafeMatcher<MotionEvent>() {
            @Override
            protected boolean matchesSafely(MotionEvent event) {
                return ((event.getX() == point.x) && (event.getY() == point.y));
            }

            @Override
            public void describeTo(Description description) {
                description.appendText("Is at point " + point);
            }
        };
    }

    private static TypeSafeMatcher<MotionEvent> containsPoints(final Point... points) {
        return new TypeSafeMatcher<MotionEvent>() {
            @Override
            protected boolean matchesSafely(MotionEvent event) {
                MotionEvent.PointerCoords coords = new MotionEvent.PointerCoords();
                for (int i = 0; i < points.length; i++) {
                    boolean havePoint = false;
                    for (int j = 0; j < points.length; j++) {
                        event.getPointerCoords(j, coords);
                        if ((points[i].x == coords.x) && (points[i].y == coords.y)) {
                            havePoint = true;
                        }
                    }
                    if (!havePoint) {
                        return false;
                    }
                }
                return true;
            }

            @Override
            public void describeTo(Description description) {
                description.appendText("Contains points " + Arrays.toString(points));
            }
        };
    }

    private static TypeSafeMatcher<MotionEvent> hasDownTime(final long downTime) {
        return new TypeSafeMatcher<MotionEvent>() {
            @Override
            protected boolean matchesSafely(MotionEvent event) {
                return event.getDownTime() == downTime;
            }

            @Override
            public void describeTo(Description description) {
                description.appendText("Down time = " + downTime);
            }
        };
    }

    private static TypeSafeMatcher<MotionEvent> hasEventTime(final long eventTime) {
        return new TypeSafeMatcher<MotionEvent>() {
            @Override
            protected boolean matchesSafely(MotionEvent event) {
                return event.getEventTime() == eventTime;
            }

            @Override
            public void describeTo(Description description) {
                description.appendText("Event time = " + eventTime);
            }
        };
    }

    private static TypeSafeMatcher<MotionEvent> hasTimeFromDown(final long timeFromDown) {
        return new TypeSafeMatcher<MotionEvent>() {
            @Override
            protected boolean matchesSafely(MotionEvent event) {
                return (event.getEventTime() - event.getDownTime()) == timeFromDown;
            }

            @Override
            public void describeTo(Description description) {
                description.appendText("Time from down to event times = " + timeFromDown);
            }
        };
    }

    private static TypeSafeMatcher<MotionEvent> hasStandardInitialization() {
        return new TypeSafeMatcher<MotionEvent>() {
            @Override
            protected boolean matchesSafely(MotionEvent event) {
                return (0 == event.getActionIndex()) && (VIRTUAL_KEYBOARD == event.getDeviceId())
                        && (EDGEFLAGS == event.getEdgeFlags()) && (0 == event.getFlags())
                        && (METASTATE == event.getMetaState()) && (0F == event.getOrientation())
                        && (0F == event.getTouchMajor()) && (0F == event.getTouchMinor())
                        && (X_PRECISION == event.getXPrecision())
                        && (Y_PRECISION == event.getYPrecision())
                        && (POINTER_SIZE == event.getSize())
                        && (1 == event.getPointerCount()) && (PRESSURE == event.getPressure())
                        && (InputDevice.SOURCE_TOUCHSCREEN == event.getSource());
            }

            @Override
            public void describeTo(Description description) {
                description.appendText("Has standard values for all parameters");
            }
        };
    }
}