Merge "Make PointerEventDispatcherTest faster" into main

        val sent = SpyInputEventSender.Timeline(

            inputEventId = 1, gpuCompletedTime = 3, presentTime = 2)

        mReceiver.reportTimeline(sent.inputEventId, sent.gpuCompletedTime, sent.presentTime)

        val received = mSender.getTimeline()

        assertEquals(null, received)

        mSender.assertNoEvents()

        // Sender will no longer receive callbacks for this fd, even if receiver sends a valid

        // timeline later

        mReceiver.reportTimeline(2 /*inputEventId*/, 3 /*gpuCompletedTime*/, 4 /*presentTime*/)

        val receivedSecondTimeline = mSender.getTimeline()

        assertEquals(null, receivedSecondTimeline)

        mSender.assertNoEvents()

    }

    /**

import com.android.server.UiThread

import com.android.server.wm.PointerEventDispatcher

import org.junit.Assert.assertEquals

import org.junit.Assert.assertNull

import org.junit.After

import org.junit.Before

import org.junit.Test

        // Since the listener raises an exception during the event handling, the event should be

        // marked as 'not handled'.

        assertEquals(SpyInputEventSender.FinishedSignal(seq, handled = false), finishedSignal)

        // Ensure that there aren't double finish calls. This would crash if there's a call

        // to finish twice.

        assertNull(mSender.getFinishedSignal())

        // Ensure that there aren't double finish calls.

        mSender.assertNoEvents()

    }

}

import java.util.concurrent.LinkedBlockingQueue

import java.util.concurrent.TimeUnit

import org.junit.Assert.assertNull

private fun <T> getEvent(queue: LinkedBlockingQueue<T>): T? {

    return queue.poll(DEFAULT_DISPATCHING_TIMEOUT_MILLIS.toLong(), TimeUnit.MILLISECONDS)

}

private fun <T> assertNoEvents(queue: LinkedBlockingQueue<T>) {

    // Poll the queue with a shorter timeout, to make the check faster.

    assertNull(queue.poll(100L, TimeUnit.MILLISECONDS))

}

class SpyInputEventReceiver(channel: InputChannel, looper: Looper) :

        InputEventReceiver(channel, looper) {

    private val mInputEvents = LinkedBlockingQueue<InputEvent>()

    fun getTimeline(): Timeline? {

        return getEvent(mTimelines)

    }

    fun assertNoEvents() {

        assertNoEvents(mFinishedSignals)

        assertNoEvents(mTimelines)

    }

}