Jeff Brown | ebbd5d1 | 2011-02-17 13:01:34 -0800 | [diff] [blame] | 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 | */ |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 16 | |
Mathias Agopian | b93a03f | 2012-02-17 15:34:57 -0800 | [diff] [blame] | 17 | #include <androidfw/InputTransport.h> |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 18 | #include <utils/Timers.h> |
| 19 | #include <utils/StopWatch.h> |
| 20 | #include <gtest/gtest.h> |
| 21 | #include <unistd.h> |
| 22 | #include <time.h> |
| 23 | #include <sys/mman.h> |
| 24 | #include <cutils/ashmem.h> |
| 25 | |
| 26 | #include "../../utils/tests/TestHelpers.h" |
| 27 | |
| 28 | namespace android { |
| 29 | |
| 30 | class InputPublisherAndConsumerTest : public testing::Test { |
| 31 | protected: |
| 32 | sp<InputChannel> serverChannel, clientChannel; |
| 33 | InputPublisher* mPublisher; |
| 34 | InputConsumer* mConsumer; |
| 35 | PreallocatedInputEventFactory mEventFactory; |
| 36 | |
| 37 | virtual void SetUp() { |
| 38 | status_t result = InputChannel::openInputChannelPair(String8("channel name"), |
| 39 | serverChannel, clientChannel); |
| 40 | |
| 41 | mPublisher = new InputPublisher(serverChannel); |
| 42 | mConsumer = new InputConsumer(clientChannel); |
| 43 | } |
| 44 | |
| 45 | virtual void TearDown() { |
| 46 | if (mPublisher) { |
| 47 | delete mPublisher; |
| 48 | mPublisher = NULL; |
| 49 | } |
| 50 | |
| 51 | if (mConsumer) { |
| 52 | delete mConsumer; |
| 53 | mConsumer = NULL; |
| 54 | } |
| 55 | |
| 56 | serverChannel.clear(); |
| 57 | clientChannel.clear(); |
| 58 | } |
| 59 | |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 60 | void PublishAndConsumeKeyEvent(); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 61 | void PublishAndConsumeMotionEvent(); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 62 | }; |
| 63 | |
| 64 | TEST_F(InputPublisherAndConsumerTest, GetChannel_ReturnsTheChannel) { |
| 65 | EXPECT_EQ(serverChannel.get(), mPublisher->getChannel().get()); |
| 66 | EXPECT_EQ(clientChannel.get(), mConsumer->getChannel().get()); |
| 67 | } |
| 68 | |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 69 | void InputPublisherAndConsumerTest::PublishAndConsumeKeyEvent() { |
| 70 | status_t status; |
| 71 | |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 72 | const uint32_t seq = 15; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 73 | const int32_t deviceId = 1; |
Jeff Brown | c5ed591 | 2010-07-14 18:48:53 -0700 | [diff] [blame] | 74 | const int32_t source = AINPUT_SOURCE_KEYBOARD; |
| 75 | const int32_t action = AKEY_EVENT_ACTION_DOWN; |
| 76 | const int32_t flags = AKEY_EVENT_FLAG_FROM_SYSTEM; |
Jeff Brown | fd03582 | 2010-06-30 16:10:35 -0700 | [diff] [blame] | 77 | const int32_t keyCode = AKEYCODE_ENTER; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 78 | const int32_t scanCode = 13; |
Jeff Brown | c5ed591 | 2010-07-14 18:48:53 -0700 | [diff] [blame] | 79 | const int32_t metaState = AMETA_ALT_LEFT_ON | AMETA_ALT_ON; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 80 | const int32_t repeatCount = 1; |
| 81 | const nsecs_t downTime = 3; |
| 82 | const nsecs_t eventTime = 4; |
| 83 | |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 84 | status = mPublisher->publishKeyEvent(seq, deviceId, source, action, flags, |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 85 | keyCode, scanCode, metaState, repeatCount, downTime, eventTime); |
| 86 | ASSERT_EQ(OK, status) |
| 87 | << "publisher publishKeyEvent should return OK"; |
| 88 | |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 89 | uint32_t consumeSeq; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 90 | InputEvent* event; |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 91 | status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, &consumeSeq, &event); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 92 | ASSERT_EQ(OK, status) |
| 93 | << "consumer consume should return OK"; |
| 94 | |
| 95 | ASSERT_TRUE(event != NULL) |
| 96 | << "consumer should have returned non-NULL event"; |
Jeff Brown | c5ed591 | 2010-07-14 18:48:53 -0700 | [diff] [blame] | 97 | ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, event->getType()) |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 98 | << "consumer should have returned a key event"; |
| 99 | |
| 100 | KeyEvent* keyEvent = static_cast<KeyEvent*>(event); |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 101 | EXPECT_EQ(seq, consumeSeq); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 102 | EXPECT_EQ(deviceId, keyEvent->getDeviceId()); |
Jeff Brown | c5ed591 | 2010-07-14 18:48:53 -0700 | [diff] [blame] | 103 | EXPECT_EQ(source, keyEvent->getSource()); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 104 | EXPECT_EQ(action, keyEvent->getAction()); |
| 105 | EXPECT_EQ(flags, keyEvent->getFlags()); |
| 106 | EXPECT_EQ(keyCode, keyEvent->getKeyCode()); |
| 107 | EXPECT_EQ(scanCode, keyEvent->getScanCode()); |
| 108 | EXPECT_EQ(metaState, keyEvent->getMetaState()); |
| 109 | EXPECT_EQ(repeatCount, keyEvent->getRepeatCount()); |
| 110 | EXPECT_EQ(downTime, keyEvent->getDownTime()); |
| 111 | EXPECT_EQ(eventTime, keyEvent->getEventTime()); |
| 112 | |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 113 | status = mConsumer->sendFinishedSignal(seq, true); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 114 | ASSERT_EQ(OK, status) |
| 115 | << "consumer sendFinishedSignal should return OK"; |
| 116 | |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 117 | uint32_t finishedSeq = 0; |
Jeff Brown | 3915bb8 | 2010-11-05 15:02:16 -0700 | [diff] [blame] | 118 | bool handled = false; |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 119 | status = mPublisher->receiveFinishedSignal(&finishedSeq, &handled); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 120 | ASSERT_EQ(OK, status) |
| 121 | << "publisher receiveFinishedSignal should return OK"; |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 122 | ASSERT_EQ(seq, finishedSeq) |
| 123 | << "publisher receiveFinishedSignal should have returned the original sequence number"; |
Jeff Brown | 3915bb8 | 2010-11-05 15:02:16 -0700 | [diff] [blame] | 124 | ASSERT_TRUE(handled) |
| 125 | << "publisher receiveFinishedSignal should have set handled to consumer's reply"; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 126 | } |
| 127 | |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 128 | void InputPublisherAndConsumerTest::PublishAndConsumeMotionEvent() { |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 129 | status_t status; |
| 130 | |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 131 | const uint32_t seq = 15; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 132 | const int32_t deviceId = 1; |
Jeff Brown | c5ed591 | 2010-07-14 18:48:53 -0700 | [diff] [blame] | 133 | const int32_t source = AINPUT_SOURCE_TOUCHSCREEN; |
| 134 | const int32_t action = AMOTION_EVENT_ACTION_MOVE; |
Jeff Brown | 85a3176 | 2010-09-01 17:01:00 -0700 | [diff] [blame] | 135 | const int32_t flags = AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED; |
Jeff Brown | c5ed591 | 2010-07-14 18:48:53 -0700 | [diff] [blame] | 136 | const int32_t edgeFlags = AMOTION_EVENT_EDGE_FLAG_TOP; |
| 137 | const int32_t metaState = AMETA_ALT_LEFT_ON | AMETA_ALT_ON; |
Jeff Brown | fe9f8ab | 2011-05-06 18:20:01 -0700 | [diff] [blame] | 138 | const int32_t buttonState = AMOTION_EVENT_BUTTON_PRIMARY; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 139 | const float xOffset = -10; |
| 140 | const float yOffset = -20; |
| 141 | const float xPrecision = 0.25; |
| 142 | const float yPrecision = 0.5; |
| 143 | const nsecs_t downTime = 3; |
| 144 | const size_t pointerCount = 3; |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 145 | const nsecs_t eventTime = 4; |
Jeff Brown | fe9f8ab | 2011-05-06 18:20:01 -0700 | [diff] [blame] | 146 | PointerProperties pointerProperties[pointerCount]; |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 147 | PointerCoords pointerCoords[pointerCount]; |
Jeff Brown | fe9f8ab | 2011-05-06 18:20:01 -0700 | [diff] [blame] | 148 | for (size_t i = 0; i < pointerCount; i++) { |
| 149 | pointerProperties[i].clear(); |
| 150 | pointerProperties[i].id = (i + 2) % pointerCount; |
| 151 | pointerProperties[i].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 152 | |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 153 | pointerCoords[i].clear(); |
| 154 | pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, 100 * i); |
| 155 | pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, 200 * i); |
| 156 | pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 0.5 * i); |
| 157 | pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 0.7 * i); |
| 158 | pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 1.5 * i); |
| 159 | pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 1.7 * i); |
| 160 | pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 2.5 * i); |
| 161 | pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 2.7 * i); |
| 162 | pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 3.5 * i); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 163 | } |
| 164 | |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 165 | status = mPublisher->publishMotionEvent(seq, deviceId, source, action, flags, edgeFlags, |
Jeff Brown | fe9f8ab | 2011-05-06 18:20:01 -0700 | [diff] [blame] | 166 | metaState, buttonState, xOffset, yOffset, xPrecision, yPrecision, |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 167 | downTime, eventTime, pointerCount, |
| 168 | pointerProperties, pointerCoords); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 169 | ASSERT_EQ(OK, status) |
| 170 | << "publisher publishMotionEvent should return OK"; |
| 171 | |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 172 | uint32_t consumeSeq; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 173 | InputEvent* event; |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 174 | status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, &consumeSeq, &event); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 175 | ASSERT_EQ(OK, status) |
| 176 | << "consumer consume should return OK"; |
| 177 | |
| 178 | ASSERT_TRUE(event != NULL) |
| 179 | << "consumer should have returned non-NULL event"; |
Jeff Brown | c5ed591 | 2010-07-14 18:48:53 -0700 | [diff] [blame] | 180 | ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, event->getType()) |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 181 | << "consumer should have returned a motion event"; |
| 182 | |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 183 | MotionEvent* motionEvent = static_cast<MotionEvent*>(event); |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 184 | EXPECT_EQ(seq, consumeSeq); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 185 | EXPECT_EQ(deviceId, motionEvent->getDeviceId()); |
Jeff Brown | c5ed591 | 2010-07-14 18:48:53 -0700 | [diff] [blame] | 186 | EXPECT_EQ(source, motionEvent->getSource()); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 187 | EXPECT_EQ(action, motionEvent->getAction()); |
Jeff Brown | 85a3176 | 2010-09-01 17:01:00 -0700 | [diff] [blame] | 188 | EXPECT_EQ(flags, motionEvent->getFlags()); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 189 | EXPECT_EQ(edgeFlags, motionEvent->getEdgeFlags()); |
| 190 | EXPECT_EQ(metaState, motionEvent->getMetaState()); |
Jeff Brown | fe9f8ab | 2011-05-06 18:20:01 -0700 | [diff] [blame] | 191 | EXPECT_EQ(buttonState, motionEvent->getButtonState()); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 192 | EXPECT_EQ(xPrecision, motionEvent->getXPrecision()); |
| 193 | EXPECT_EQ(yPrecision, motionEvent->getYPrecision()); |
| 194 | EXPECT_EQ(downTime, motionEvent->getDownTime()); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 195 | EXPECT_EQ(eventTime, motionEvent->getEventTime()); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 196 | EXPECT_EQ(pointerCount, motionEvent->getPointerCount()); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 197 | EXPECT_EQ(0U, motionEvent->getHistorySize()); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 198 | |
| 199 | for (size_t i = 0; i < pointerCount; i++) { |
| 200 | SCOPED_TRACE(i); |
Jeff Brown | fe9f8ab | 2011-05-06 18:20:01 -0700 | [diff] [blame] | 201 | EXPECT_EQ(pointerProperties[i].id, motionEvent->getPointerId(i)); |
| 202 | EXPECT_EQ(pointerProperties[i].toolType, motionEvent->getToolType(i)); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 203 | |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 204 | EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X), |
Jeff Brown | 91c69ab | 2011-02-14 17:03:18 -0800 | [diff] [blame] | 205 | motionEvent->getRawX(i)); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 206 | EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y), |
Jeff Brown | 91c69ab | 2011-02-14 17:03:18 -0800 | [diff] [blame] | 207 | motionEvent->getRawY(i)); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 208 | EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X) + xOffset, |
Jeff Brown | 91c69ab | 2011-02-14 17:03:18 -0800 | [diff] [blame] | 209 | motionEvent->getX(i)); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 210 | EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y) + yOffset, |
Jeff Brown | 91c69ab | 2011-02-14 17:03:18 -0800 | [diff] [blame] | 211 | motionEvent->getY(i)); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 212 | EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE), |
Jeff Brown | 91c69ab | 2011-02-14 17:03:18 -0800 | [diff] [blame] | 213 | motionEvent->getPressure(i)); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 214 | EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE), |
Jeff Brown | 91c69ab | 2011-02-14 17:03:18 -0800 | [diff] [blame] | 215 | motionEvent->getSize(i)); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 216 | EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR), |
Jeff Brown | 91c69ab | 2011-02-14 17:03:18 -0800 | [diff] [blame] | 217 | motionEvent->getTouchMajor(i)); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 218 | EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR), |
Jeff Brown | 91c69ab | 2011-02-14 17:03:18 -0800 | [diff] [blame] | 219 | motionEvent->getTouchMinor(i)); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 220 | EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR), |
Jeff Brown | 91c69ab | 2011-02-14 17:03:18 -0800 | [diff] [blame] | 221 | motionEvent->getToolMajor(i)); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 222 | EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR), |
Jeff Brown | 91c69ab | 2011-02-14 17:03:18 -0800 | [diff] [blame] | 223 | motionEvent->getToolMinor(i)); |
Jeff Brown | cbee6d6 | 2012-02-03 20:11:27 -0800 | [diff] [blame] | 224 | EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION), |
Jeff Brown | 91c69ab | 2011-02-14 17:03:18 -0800 | [diff] [blame] | 225 | motionEvent->getOrientation(i)); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 226 | } |
| 227 | |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 228 | status = mConsumer->sendFinishedSignal(seq, false); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 229 | ASSERT_EQ(OK, status) |
| 230 | << "consumer sendFinishedSignal should return OK"; |
| 231 | |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 232 | uint32_t finishedSeq = 0; |
Jeff Brown | 3915bb8 | 2010-11-05 15:02:16 -0700 | [diff] [blame] | 233 | bool handled = true; |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 234 | status = mPublisher->receiveFinishedSignal(&finishedSeq, &handled); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 235 | ASSERT_EQ(OK, status) |
| 236 | << "publisher receiveFinishedSignal should return OK"; |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 237 | ASSERT_EQ(seq, finishedSeq) |
| 238 | << "publisher receiveFinishedSignal should have returned the original sequence number"; |
Jeff Brown | 3915bb8 | 2010-11-05 15:02:16 -0700 | [diff] [blame] | 239 | ASSERT_FALSE(handled) |
| 240 | << "publisher receiveFinishedSignal should have set handled to consumer's reply"; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 241 | } |
| 242 | |
| 243 | TEST_F(InputPublisherAndConsumerTest, PublishKeyEvent_EndToEnd) { |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 244 | ASSERT_NO_FATAL_FAILURE(PublishAndConsumeKeyEvent()); |
| 245 | } |
| 246 | |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 247 | TEST_F(InputPublisherAndConsumerTest, PublishMotionEvent_EndToEnd) { |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 248 | ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent()); |
| 249 | } |
| 250 | |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 251 | TEST_F(InputPublisherAndConsumerTest, PublishMotionEvent_WhenPointerCountLessThan1_ReturnsError) { |
| 252 | status_t status; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 253 | const size_t pointerCount = 0; |
Jeff Brown | fe9f8ab | 2011-05-06 18:20:01 -0700 | [diff] [blame] | 254 | PointerProperties pointerProperties[pointerCount]; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 255 | PointerCoords pointerCoords[pointerCount]; |
| 256 | |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 257 | status = mPublisher->publishMotionEvent(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
Jeff Brown | fe9f8ab | 2011-05-06 18:20:01 -0700 | [diff] [blame] | 258 | pointerCount, pointerProperties, pointerCoords); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 259 | ASSERT_EQ(BAD_VALUE, status) |
| 260 | << "publisher publishMotionEvent should return BAD_VALUE"; |
| 261 | } |
| 262 | |
| 263 | TEST_F(InputPublisherAndConsumerTest, PublishMotionEvent_WhenPointerCountGreaterThanMax_ReturnsError) { |
| 264 | status_t status; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 265 | const size_t pointerCount = MAX_POINTERS + 1; |
Jeff Brown | fe9f8ab | 2011-05-06 18:20:01 -0700 | [diff] [blame] | 266 | PointerProperties pointerProperties[pointerCount]; |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 267 | PointerCoords pointerCoords[pointerCount]; |
Jeff Brown | fe9f8ab | 2011-05-06 18:20:01 -0700 | [diff] [blame] | 268 | for (size_t i = 0; i < pointerCount; i++) { |
| 269 | pointerProperties[i].clear(); |
| 270 | pointerCoords[i].clear(); |
| 271 | } |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 272 | |
Jeff Brown | 072ec96 | 2012-02-07 14:46:57 -0800 | [diff] [blame] | 273 | status = mPublisher->publishMotionEvent(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
Jeff Brown | fe9f8ab | 2011-05-06 18:20:01 -0700 | [diff] [blame] | 274 | pointerCount, pointerProperties, pointerCoords); |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 275 | ASSERT_EQ(BAD_VALUE, status) |
| 276 | << "publisher publishMotionEvent should return BAD_VALUE"; |
| 277 | } |
| 278 | |
| 279 | TEST_F(InputPublisherAndConsumerTest, PublishMultipleEvents_EndToEnd) { |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 280 | ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent()); |
| 281 | ASSERT_NO_FATAL_FAILURE(PublishAndConsumeKeyEvent()); |
| 282 | ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent()); |
| 283 | ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent()); |
| 284 | ASSERT_NO_FATAL_FAILURE(PublishAndConsumeKeyEvent()); |
| 285 | } |
| 286 | |
Jeff Brown | 5c225b1 | 2010-06-16 01:53:36 -0700 | [diff] [blame] | 287 | } // namespace android |