1 /*
2  * Copyright (C) 2010 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "TestHelpers.h"
18 
19 #include <unistd.h>
20 #include <sys/mman.h>
21 #include <time.h>
22 
23 #include <attestation/HmacKeyManager.h>
24 #include <cutils/ashmem.h>
25 #include <gtest/gtest.h>
26 #include <gui/constants.h>
27 #include <input/InputTransport.h>
28 #include <utils/StopWatch.h>
29 #include <utils/Timers.h>
30 
31 using android::base::Result;
32 
33 namespace android {
34 
35 class InputPublisherAndConsumerTest : public testing::Test {
36 protected:
37     std::shared_ptr<InputChannel> mServerChannel, mClientChannel;
38     std::unique_ptr<InputPublisher> mPublisher;
39     std::unique_ptr<InputConsumer> mConsumer;
40     PreallocatedInputEventFactory mEventFactory;
41 
SetUp()42     void SetUp() override {
43         std::unique_ptr<InputChannel> serverChannel, clientChannel;
44         status_t result = InputChannel::openInputChannelPair("channel name",
45                 serverChannel, clientChannel);
46         ASSERT_EQ(OK, result);
47         mServerChannel = std::move(serverChannel);
48         mClientChannel = std::move(clientChannel);
49 
50         mPublisher = std::make_unique<InputPublisher>(mServerChannel);
51         mConsumer = std::make_unique<InputConsumer>(mClientChannel);
52     }
53 
54     void PublishAndConsumeKeyEvent();
55     void PublishAndConsumeMotionEvent();
56     void PublishAndConsumeFocusEvent();
57     void PublishAndConsumeCaptureEvent();
58     void PublishAndConsumeDragEvent();
59 };
60 
TEST_F(InputPublisherAndConsumerTest,GetChannel_ReturnsTheChannel)61 TEST_F(InputPublisherAndConsumerTest, GetChannel_ReturnsTheChannel) {
62     ASSERT_NE(nullptr, mPublisher->getChannel());
63     ASSERT_NE(nullptr, mConsumer->getChannel());
64     EXPECT_EQ(mServerChannel.get(), mPublisher->getChannel().get());
65     EXPECT_EQ(mClientChannel.get(), mConsumer->getChannel().get());
66     ASSERT_EQ(mPublisher->getChannel()->getConnectionToken(),
67               mConsumer->getChannel()->getConnectionToken());
68 }
69 
PublishAndConsumeKeyEvent()70 void InputPublisherAndConsumerTest::PublishAndConsumeKeyEvent() {
71     status_t status;
72 
73     constexpr uint32_t seq = 15;
74     int32_t eventId = InputEvent::nextId();
75     constexpr int32_t deviceId = 1;
76     constexpr uint32_t source = AINPUT_SOURCE_KEYBOARD;
77     constexpr int32_t displayId = ADISPLAY_ID_DEFAULT;
78     constexpr std::array<uint8_t, 32> hmac = {31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21,
79                                               20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,
80                                               9,  8,  7,  6,  5,  4,  3,  2,  1,  0};
81     constexpr int32_t action = AKEY_EVENT_ACTION_DOWN;
82     constexpr int32_t flags = AKEY_EVENT_FLAG_FROM_SYSTEM;
83     constexpr int32_t keyCode = AKEYCODE_ENTER;
84     constexpr int32_t scanCode = 13;
85     constexpr int32_t metaState = AMETA_ALT_LEFT_ON | AMETA_ALT_ON;
86     constexpr int32_t repeatCount = 1;
87     constexpr nsecs_t downTime = 3;
88     constexpr nsecs_t eventTime = 4;
89     const nsecs_t publishTime = systemTime(SYSTEM_TIME_MONOTONIC);
90 
91     status = mPublisher->publishKeyEvent(seq, eventId, deviceId, source, displayId, hmac, action,
92                                          flags, keyCode, scanCode, metaState, repeatCount, downTime,
93                                          eventTime);
94     ASSERT_EQ(OK, status)
95             << "publisher publishKeyEvent should return OK";
96 
97     uint32_t consumeSeq;
98     InputEvent* event;
99     status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, -1, &consumeSeq, &event);
100     ASSERT_EQ(OK, status)
101             << "consumer consume should return OK";
102 
103     ASSERT_TRUE(event != nullptr)
104             << "consumer should have returned non-NULL event";
105     ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, event->getType())
106             << "consumer should have returned a key event";
107 
108     KeyEvent* keyEvent = static_cast<KeyEvent*>(event);
109     EXPECT_EQ(seq, consumeSeq);
110     EXPECT_EQ(eventId, keyEvent->getId());
111     EXPECT_EQ(deviceId, keyEvent->getDeviceId());
112     EXPECT_EQ(source, keyEvent->getSource());
113     EXPECT_EQ(displayId, keyEvent->getDisplayId());
114     EXPECT_EQ(hmac, keyEvent->getHmac());
115     EXPECT_EQ(action, keyEvent->getAction());
116     EXPECT_EQ(flags, keyEvent->getFlags());
117     EXPECT_EQ(keyCode, keyEvent->getKeyCode());
118     EXPECT_EQ(scanCode, keyEvent->getScanCode());
119     EXPECT_EQ(metaState, keyEvent->getMetaState());
120     EXPECT_EQ(repeatCount, keyEvent->getRepeatCount());
121     EXPECT_EQ(downTime, keyEvent->getDownTime());
122     EXPECT_EQ(eventTime, keyEvent->getEventTime());
123 
124     status = mConsumer->sendFinishedSignal(seq, true);
125     ASSERT_EQ(OK, status)
126             << "consumer sendFinishedSignal should return OK";
127 
128     Result<InputPublisher::ConsumerResponse> result = mPublisher->receiveConsumerResponse();
129     ASSERT_TRUE(result.ok()) << "receiveConsumerResponse should return OK";
130     ASSERT_TRUE(std::holds_alternative<InputPublisher::Finished>(*result));
131     const InputPublisher::Finished& finish = std::get<InputPublisher::Finished>(*result);
132     ASSERT_EQ(seq, finish.seq)
133             << "receiveConsumerResponse should have returned the original sequence number";
134     ASSERT_TRUE(finish.handled)
135             << "receiveConsumerResponse should have set handled to consumer's reply";
136     ASSERT_GE(finish.consumeTime, publishTime)
137             << "finished signal's consume time should be greater than publish time";
138 }
139 
PublishAndConsumeMotionEvent()140 void InputPublisherAndConsumerTest::PublishAndConsumeMotionEvent() {
141     status_t status;
142 
143     constexpr uint32_t seq = 15;
144     int32_t eventId = InputEvent::nextId();
145     constexpr int32_t deviceId = 1;
146     constexpr uint32_t source = AINPUT_SOURCE_TOUCHSCREEN;
147     constexpr int32_t displayId = ADISPLAY_ID_DEFAULT;
148     constexpr std::array<uint8_t, 32> hmac = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10,
149                                               11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
150                                               22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
151     constexpr int32_t action = AMOTION_EVENT_ACTION_MOVE;
152     constexpr int32_t actionButton = 0;
153     constexpr int32_t flags = AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;
154     constexpr int32_t edgeFlags = AMOTION_EVENT_EDGE_FLAG_TOP;
155     constexpr int32_t metaState = AMETA_ALT_LEFT_ON | AMETA_ALT_ON;
156     constexpr int32_t buttonState = AMOTION_EVENT_BUTTON_PRIMARY;
157     constexpr MotionClassification classification = MotionClassification::AMBIGUOUS_GESTURE;
158     constexpr float xScale = 2;
159     constexpr float yScale = 3;
160     constexpr float xOffset = -10;
161     constexpr float yOffset = -20;
162     constexpr float xPrecision = 0.25;
163     constexpr float yPrecision = 0.5;
164     constexpr float xCursorPosition = 1.3;
165     constexpr float yCursorPosition = 50.6;
166     constexpr uint32_t displayOrientation = ui::Transform::ROT_0;
167     constexpr int32_t displayWidth = 1000;
168     constexpr int32_t displayHeight = 2000;
169     constexpr nsecs_t downTime = 3;
170     constexpr size_t pointerCount = 3;
171     constexpr nsecs_t eventTime = 4;
172     const nsecs_t publishTime = systemTime(SYSTEM_TIME_MONOTONIC);
173     PointerProperties pointerProperties[pointerCount];
174     PointerCoords pointerCoords[pointerCount];
175     for (size_t i = 0; i < pointerCount; i++) {
176         pointerProperties[i].clear();
177         pointerProperties[i].id = (i + 2) % pointerCount;
178         pointerProperties[i].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
179 
180         pointerCoords[i].clear();
181         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, 100 * i);
182         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, 200 * i);
183         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 0.5 * i);
184         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 0.7 * i);
185         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 1.5 * i);
186         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 1.7 * i);
187         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 2.5 * i);
188         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 2.7 * i);
189         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 3.5 * i);
190     }
191 
192     ui::Transform transform;
193     transform.set({xScale, 0, xOffset, 0, yScale, yOffset, 0, 0, 1});
194     status = mPublisher->publishMotionEvent(seq, eventId, deviceId, source, displayId, hmac, action,
195                                             actionButton, flags, edgeFlags, metaState, buttonState,
196                                             classification, transform, xPrecision, yPrecision,
197                                             xCursorPosition, yCursorPosition, displayOrientation,
198                                             displayWidth, displayHeight, downTime, eventTime,
199                                             pointerCount, pointerProperties, pointerCoords);
200     ASSERT_EQ(OK, status)
201             << "publisher publishMotionEvent should return OK";
202 
203     uint32_t consumeSeq;
204     InputEvent* event;
205     status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, -1, &consumeSeq, &event);
206     ASSERT_EQ(OK, status)
207             << "consumer consume should return OK";
208 
209     ASSERT_TRUE(event != nullptr)
210             << "consumer should have returned non-NULL event";
211     ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, event->getType())
212             << "consumer should have returned a motion event";
213 
214     MotionEvent* motionEvent = static_cast<MotionEvent*>(event);
215     EXPECT_EQ(seq, consumeSeq);
216     EXPECT_EQ(eventId, motionEvent->getId());
217     EXPECT_EQ(deviceId, motionEvent->getDeviceId());
218     EXPECT_EQ(source, motionEvent->getSource());
219     EXPECT_EQ(displayId, motionEvent->getDisplayId());
220     EXPECT_EQ(hmac, motionEvent->getHmac());
221     EXPECT_EQ(action, motionEvent->getAction());
222     EXPECT_EQ(flags, motionEvent->getFlags());
223     EXPECT_EQ(edgeFlags, motionEvent->getEdgeFlags());
224     EXPECT_EQ(metaState, motionEvent->getMetaState());
225     EXPECT_EQ(buttonState, motionEvent->getButtonState());
226     EXPECT_EQ(classification, motionEvent->getClassification());
227     EXPECT_EQ(transform, motionEvent->getTransform());
228     EXPECT_EQ(xOffset, motionEvent->getXOffset());
229     EXPECT_EQ(yOffset, motionEvent->getYOffset());
230     EXPECT_EQ(xPrecision, motionEvent->getXPrecision());
231     EXPECT_EQ(yPrecision, motionEvent->getYPrecision());
232     EXPECT_EQ(xCursorPosition, motionEvent->getRawXCursorPosition());
233     EXPECT_EQ(yCursorPosition, motionEvent->getRawYCursorPosition());
234     EXPECT_EQ(xCursorPosition * xScale + xOffset, motionEvent->getXCursorPosition());
235     EXPECT_EQ(yCursorPosition * yScale + yOffset, motionEvent->getYCursorPosition());
236     EXPECT_EQ(displayOrientation, motionEvent->getDisplayOrientation());
237     EXPECT_EQ(displayWidth, motionEvent->getDisplaySize().x);
238     EXPECT_EQ(displayHeight, motionEvent->getDisplaySize().y);
239     EXPECT_EQ(downTime, motionEvent->getDownTime());
240     EXPECT_EQ(eventTime, motionEvent->getEventTime());
241     EXPECT_EQ(pointerCount, motionEvent->getPointerCount());
242     EXPECT_EQ(0U, motionEvent->getHistorySize());
243 
244     for (size_t i = 0; i < pointerCount; i++) {
245         SCOPED_TRACE(i);
246         EXPECT_EQ(pointerProperties[i].id, motionEvent->getPointerId(i));
247         EXPECT_EQ(pointerProperties[i].toolType, motionEvent->getToolType(i));
248 
249         EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
250                 motionEvent->getRawX(i));
251         EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
252                 motionEvent->getRawY(i));
253         EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X) * xScale + xOffset,
254                   motionEvent->getX(i));
255         EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y) * yScale + yOffset,
256                   motionEvent->getY(i));
257         EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
258                 motionEvent->getPressure(i));
259         EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
260                 motionEvent->getSize(i));
261         EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
262                 motionEvent->getTouchMajor(i));
263         EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
264                 motionEvent->getTouchMinor(i));
265         EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
266                 motionEvent->getToolMajor(i));
267         EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
268                 motionEvent->getToolMinor(i));
269         EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION),
270                 motionEvent->getOrientation(i));
271     }
272 
273     status = mConsumer->sendFinishedSignal(seq, false);
274     ASSERT_EQ(OK, status)
275             << "consumer sendFinishedSignal should return OK";
276 
277     Result<InputPublisher::ConsumerResponse> result = mPublisher->receiveConsumerResponse();
278     ASSERT_TRUE(result.ok()) << "receiveConsumerResponse should return OK";
279     ASSERT_TRUE(std::holds_alternative<InputPublisher::Finished>(*result));
280     const InputPublisher::Finished& finish = std::get<InputPublisher::Finished>(*result);
281     ASSERT_EQ(seq, finish.seq)
282             << "receiveConsumerResponse should have returned the original sequence number";
283     ASSERT_FALSE(finish.handled)
284             << "receiveConsumerResponse should have set handled to consumer's reply";
285     ASSERT_GE(finish.consumeTime, publishTime)
286             << "finished signal's consume time should be greater than publish time";
287 }
288 
PublishAndConsumeFocusEvent()289 void InputPublisherAndConsumerTest::PublishAndConsumeFocusEvent() {
290     status_t status;
291 
292     constexpr uint32_t seq = 15;
293     int32_t eventId = InputEvent::nextId();
294     constexpr bool hasFocus = true;
295     constexpr bool inTouchMode = true;
296     const nsecs_t publishTime = systemTime(SYSTEM_TIME_MONOTONIC);
297 
298     status = mPublisher->publishFocusEvent(seq, eventId, hasFocus, inTouchMode);
299     ASSERT_EQ(OK, status) << "publisher publishFocusEvent should return OK";
300 
301     uint32_t consumeSeq;
302     InputEvent* event;
303     status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, -1, &consumeSeq, &event);
304     ASSERT_EQ(OK, status) << "consumer consume should return OK";
305 
306     ASSERT_TRUE(event != nullptr) << "consumer should have returned non-NULL event";
307     ASSERT_EQ(AINPUT_EVENT_TYPE_FOCUS, event->getType())
308             << "consumer should have returned a focus event";
309 
310     FocusEvent* focusEvent = static_cast<FocusEvent*>(event);
311     EXPECT_EQ(seq, consumeSeq);
312     EXPECT_EQ(eventId, focusEvent->getId());
313     EXPECT_EQ(hasFocus, focusEvent->getHasFocus());
314     EXPECT_EQ(inTouchMode, focusEvent->getInTouchMode());
315 
316     status = mConsumer->sendFinishedSignal(seq, true);
317     ASSERT_EQ(OK, status) << "consumer sendFinishedSignal should return OK";
318 
319     Result<InputPublisher::ConsumerResponse> result = mPublisher->receiveConsumerResponse();
320     ASSERT_TRUE(result.ok()) << "receiveConsumerResponse should return OK";
321     ASSERT_TRUE(std::holds_alternative<InputPublisher::Finished>(*result));
322     const InputPublisher::Finished& finish = std::get<InputPublisher::Finished>(*result);
323 
324     ASSERT_EQ(seq, finish.seq)
325             << "receiveConsumerResponse should have returned the original sequence number";
326     ASSERT_TRUE(finish.handled)
327             << "receiveConsumerResponse should have set handled to consumer's reply";
328     ASSERT_GE(finish.consumeTime, publishTime)
329             << "finished signal's consume time should be greater than publish time";
330 }
331 
PublishAndConsumeCaptureEvent()332 void InputPublisherAndConsumerTest::PublishAndConsumeCaptureEvent() {
333     status_t status;
334 
335     constexpr uint32_t seq = 42;
336     int32_t eventId = InputEvent::nextId();
337     constexpr bool captureEnabled = true;
338     const nsecs_t publishTime = systemTime(SYSTEM_TIME_MONOTONIC);
339 
340     status = mPublisher->publishCaptureEvent(seq, eventId, captureEnabled);
341     ASSERT_EQ(OK, status) << "publisher publishCaptureEvent should return OK";
342 
343     uint32_t consumeSeq;
344     InputEvent* event;
345     status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, -1, &consumeSeq, &event);
346     ASSERT_EQ(OK, status) << "consumer consume should return OK";
347 
348     ASSERT_TRUE(event != nullptr) << "consumer should have returned non-NULL event";
349     ASSERT_EQ(AINPUT_EVENT_TYPE_CAPTURE, event->getType())
350             << "consumer should have returned a capture event";
351 
352     const CaptureEvent* captureEvent = static_cast<CaptureEvent*>(event);
353     EXPECT_EQ(seq, consumeSeq);
354     EXPECT_EQ(eventId, captureEvent->getId());
355     EXPECT_EQ(captureEnabled, captureEvent->getPointerCaptureEnabled());
356 
357     status = mConsumer->sendFinishedSignal(seq, true);
358     ASSERT_EQ(OK, status) << "consumer sendFinishedSignal should return OK";
359 
360     Result<InputPublisher::ConsumerResponse> result = mPublisher->receiveConsumerResponse();
361     ASSERT_TRUE(result.ok()) << "receiveConsumerResponse should return OK";
362     ASSERT_TRUE(std::holds_alternative<InputPublisher::Finished>(*result));
363     const InputPublisher::Finished& finish = std::get<InputPublisher::Finished>(*result);
364     ASSERT_EQ(seq, finish.seq)
365             << "receiveConsumerResponse should have returned the original sequence number";
366     ASSERT_TRUE(finish.handled)
367             << "receiveConsumerResponse should have set handled to consumer's reply";
368     ASSERT_GE(finish.consumeTime, publishTime)
369             << "finished signal's consume time should be greater than publish time";
370 }
371 
PublishAndConsumeDragEvent()372 void InputPublisherAndConsumerTest::PublishAndConsumeDragEvent() {
373     status_t status;
374 
375     constexpr uint32_t seq = 15;
376     int32_t eventId = InputEvent::nextId();
377     constexpr bool isExiting = false;
378     constexpr float x = 10;
379     constexpr float y = 15;
380     const nsecs_t publishTime = systemTime(SYSTEM_TIME_MONOTONIC);
381 
382     status = mPublisher->publishDragEvent(seq, eventId, x, y, isExiting);
383     ASSERT_EQ(OK, status) << "publisher publishDragEvent should return OK";
384 
385     uint32_t consumeSeq;
386     InputEvent* event;
387     status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, -1, &consumeSeq, &event);
388     ASSERT_EQ(OK, status) << "consumer consume should return OK";
389 
390     ASSERT_TRUE(event != nullptr) << "consumer should have returned non-NULL event";
391     ASSERT_EQ(AINPUT_EVENT_TYPE_DRAG, event->getType())
392             << "consumer should have returned a drag event";
393 
394     const DragEvent& dragEvent = static_cast<const DragEvent&>(*event);
395     EXPECT_EQ(seq, consumeSeq);
396     EXPECT_EQ(eventId, dragEvent.getId());
397     EXPECT_EQ(isExiting, dragEvent.isExiting());
398     EXPECT_EQ(x, dragEvent.getX());
399     EXPECT_EQ(y, dragEvent.getY());
400 
401     status = mConsumer->sendFinishedSignal(seq, true);
402     ASSERT_EQ(OK, status) << "consumer sendFinishedSignal should return OK";
403 
404     Result<InputPublisher::ConsumerResponse> result = mPublisher->receiveConsumerResponse();
405     ASSERT_TRUE(result.ok()) << "receiveConsumerResponse should return OK";
406     ASSERT_TRUE(std::holds_alternative<InputPublisher::Finished>(*result));
407     const InputPublisher::Finished& finish = std::get<InputPublisher::Finished>(*result);
408     ASSERT_EQ(seq, finish.seq)
409             << "receiveConsumerResponse should have returned the original sequence number";
410     ASSERT_TRUE(finish.handled)
411             << "receiveConsumerResponse should have set handled to consumer's reply";
412     ASSERT_GE(finish.consumeTime, publishTime)
413             << "finished signal's consume time should be greater than publish time";
414 }
415 
TEST_F(InputPublisherAndConsumerTest,SendTimeline)416 TEST_F(InputPublisherAndConsumerTest, SendTimeline) {
417     const int32_t inputEventId = 20;
418     std::array<nsecs_t, GraphicsTimeline::SIZE> graphicsTimeline;
419     graphicsTimeline[GraphicsTimeline::GPU_COMPLETED_TIME] = 30;
420     graphicsTimeline[GraphicsTimeline::PRESENT_TIME] = 40;
421     status_t status = mConsumer->sendTimeline(inputEventId, graphicsTimeline);
422     ASSERT_EQ(OK, status);
423 
424     Result<InputPublisher::ConsumerResponse> result = mPublisher->receiveConsumerResponse();
425     ASSERT_TRUE(result.ok()) << "receiveConsumerResponse should return OK";
426     ASSERT_TRUE(std::holds_alternative<InputPublisher::Timeline>(*result));
427     const InputPublisher::Timeline& timeline = std::get<InputPublisher::Timeline>(*result);
428     ASSERT_EQ(inputEventId, timeline.inputEventId);
429     ASSERT_EQ(graphicsTimeline, timeline.graphicsTimeline);
430 }
431 
TEST_F(InputPublisherAndConsumerTest,PublishKeyEvent_EndToEnd)432 TEST_F(InputPublisherAndConsumerTest, PublishKeyEvent_EndToEnd) {
433     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeKeyEvent());
434 }
435 
TEST_F(InputPublisherAndConsumerTest,PublishMotionEvent_EndToEnd)436 TEST_F(InputPublisherAndConsumerTest, PublishMotionEvent_EndToEnd) {
437     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent());
438 }
439 
TEST_F(InputPublisherAndConsumerTest,PublishFocusEvent_EndToEnd)440 TEST_F(InputPublisherAndConsumerTest, PublishFocusEvent_EndToEnd) {
441     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeFocusEvent());
442 }
443 
TEST_F(InputPublisherAndConsumerTest,PublishCaptureEvent_EndToEnd)444 TEST_F(InputPublisherAndConsumerTest, PublishCaptureEvent_EndToEnd) {
445     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeCaptureEvent());
446 }
447 
TEST_F(InputPublisherAndConsumerTest,PublishDragEvent_EndToEnd)448 TEST_F(InputPublisherAndConsumerTest, PublishDragEvent_EndToEnd) {
449     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeDragEvent());
450 }
451 
TEST_F(InputPublisherAndConsumerTest,PublishMotionEvent_WhenSequenceNumberIsZero_ReturnsError)452 TEST_F(InputPublisherAndConsumerTest, PublishMotionEvent_WhenSequenceNumberIsZero_ReturnsError) {
453     status_t status;
454     const size_t pointerCount = 1;
455     PointerProperties pointerProperties[pointerCount];
456     PointerCoords pointerCoords[pointerCount];
457     for (size_t i = 0; i < pointerCount; i++) {
458         pointerProperties[i].clear();
459         pointerCoords[i].clear();
460     }
461 
462     ui::Transform identityTransform;
463     status = mPublisher->publishMotionEvent(0, InputEvent::nextId(), 0, 0, 0, INVALID_HMAC, 0, 0, 0,
464                                             0, 0, 0, MotionClassification::NONE, identityTransform,
465                                             0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
466                                             AMOTION_EVENT_INVALID_CURSOR_POSITION,
467                                             ui::Transform::ROT_0, 0, 0, 0, 0, pointerCount,
468                                             pointerProperties, pointerCoords);
469     ASSERT_EQ(BAD_VALUE, status)
470             << "publisher publishMotionEvent should return BAD_VALUE";
471 }
472 
TEST_F(InputPublisherAndConsumerTest,PublishMotionEvent_WhenPointerCountLessThan1_ReturnsError)473 TEST_F(InputPublisherAndConsumerTest, PublishMotionEvent_WhenPointerCountLessThan1_ReturnsError) {
474     status_t status;
475     const size_t pointerCount = 0;
476     PointerProperties pointerProperties[pointerCount];
477     PointerCoords pointerCoords[pointerCount];
478 
479     ui::Transform identityTransform;
480     status = mPublisher->publishMotionEvent(1, InputEvent::nextId(), 0, 0, 0, INVALID_HMAC, 0, 0, 0,
481                                             0, 0, 0, MotionClassification::NONE, identityTransform,
482                                             0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
483                                             AMOTION_EVENT_INVALID_CURSOR_POSITION,
484                                             ui::Transform::ROT_0, 0, 0, 0, 0, pointerCount,
485                                             pointerProperties, pointerCoords);
486     ASSERT_EQ(BAD_VALUE, status)
487             << "publisher publishMotionEvent should return BAD_VALUE";
488 }
489 
TEST_F(InputPublisherAndConsumerTest,PublishMotionEvent_WhenPointerCountGreaterThanMax_ReturnsError)490 TEST_F(InputPublisherAndConsumerTest,
491         PublishMotionEvent_WhenPointerCountGreaterThanMax_ReturnsError) {
492     status_t status;
493     const size_t pointerCount = MAX_POINTERS + 1;
494     PointerProperties pointerProperties[pointerCount];
495     PointerCoords pointerCoords[pointerCount];
496     for (size_t i = 0; i < pointerCount; i++) {
497         pointerProperties[i].clear();
498         pointerCoords[i].clear();
499     }
500 
501     ui::Transform identityTransform;
502     status = mPublisher->publishMotionEvent(1, InputEvent::nextId(), 0, 0, 0, INVALID_HMAC, 0, 0, 0,
503                                             0, 0, 0, MotionClassification::NONE, identityTransform,
504                                             0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
505                                             AMOTION_EVENT_INVALID_CURSOR_POSITION,
506                                             ui::Transform::ROT_0, 0, 0, 0, 0, pointerCount,
507                                             pointerProperties, pointerCoords);
508     ASSERT_EQ(BAD_VALUE, status)
509             << "publisher publishMotionEvent should return BAD_VALUE";
510 }
511 
TEST_F(InputPublisherAndConsumerTest,PublishMultipleEvents_EndToEnd)512 TEST_F(InputPublisherAndConsumerTest, PublishMultipleEvents_EndToEnd) {
513     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent());
514     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeKeyEvent());
515     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent());
516     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeFocusEvent());
517     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent());
518     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeKeyEvent());
519     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeCaptureEvent());
520     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeDragEvent());
521     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent());
522     ASSERT_NO_FATAL_FAILURE(PublishAndConsumeKeyEvent());
523 }
524 
525 } // namespace android
526