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