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