Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6252af72 authored by Siarhei Vishniakou's avatar Siarhei Vishniakou
Browse files

Provide a consistent motion event stream in libinput_tests 

When the InputVerifier is enabled, some of the input tests fail because
they provide an inconsistent motion event stream to the InputPublisher.

In this CL, those are fixed. This should help us enable event
verification in the future.

There are still some failures remaining due to zero pointer tests that
will be addressed separately.

Bug: 211379801
Bug: 271455682
Test: enable InputVerifier in the code
Test: TEST=libinput_tests; m $TEST && $ANDROID_HOST_OUT/nativetest64/$TEST/$TEST
Change-Id: If19ea9bc50d2191ba2bdce3aad35390889db7f95
parent 197bd5d2

libs/input/tests/InputPublisherAndConsumer_test.cpp

+138 −49
Original line number Original line Diff line number Diff line
@@ -25,7 +25,22 @@ using android::base::Result; 




namespace android {

namespace android {





constexpr static float EPSILON = MotionEvent::ROUNDING_PRECISION;

namespace {



static constexpr float EPSILON = MotionEvent::ROUNDING_PRECISION;

static constexpr int32_t POINTER_1_DOWN =

        AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);

static constexpr int32_t POINTER_2_DOWN =

        AMOTION_EVENT_ACTION_POINTER_DOWN | (2 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);



struct Pointer {

    int32_t id;

    float x;

    float y;

    bool isResampled = false;

};



} // namespace





class InputPublisherAndConsumerTest : public testing::Test {

class InputPublisherAndConsumerTest : public testing::Test {

protected:

protected:
@@ -46,12 +61,28 @@ protected: 
        mConsumer = std::make_unique<InputConsumer>(mClientChannel);

        mConsumer = std::make_unique<InputConsumer>(mClientChannel);

    }

    }





    void PublishAndConsumeKeyEvent();

    void publishAndConsumeKeyEvent();

    void PublishAndConsumeMotionEvent();

    void publishAndConsumeMotionStream();

    void PublishAndConsumeFocusEvent();

    void publishAndConsumeFocusEvent();

    void PublishAndConsumeCaptureEvent();

    void publishAndConsumeCaptureEvent();

    void PublishAndConsumeDragEvent();

    void publishAndConsumeDragEvent();

    void PublishAndConsumeTouchModeEvent();

    void publishAndConsumeTouchModeEvent();

    void publishAndConsumeMotionEvent(int32_t action, nsecs_t downTime,

                                      const std::vector<Pointer>& pointers);



private:

    // The sequence number to use when publishing the next event

    uint32_t mSeq = 1;



    void publishAndConsumeMotionEvent(

            int32_t deviceId, uint32_t source, int32_t displayId, std::array<uint8_t, 32> hmac,

            int32_t action, int32_t actionButton, int32_t flags, int32_t edgeFlags,

            int32_t metaState, int32_t buttonState, MotionClassification classification,

            float xScale, float yScale, float xOffset, float yOffset, float xPrecision,

            float yPrecision, float xCursorPosition, float yCursorPosition, float rawXScale,

            float rawYScale, float rawXOffset, float rawYOffset, nsecs_t downTime,

            nsecs_t eventTime, const std::vector<PointerProperties>& pointerProperties,

            const std::vector<PointerCoords>& pointerCoords);

};

};





TEST_F(InputPublisherAndConsumerTest, GetChannel_ReturnsTheChannel) {

TEST_F(InputPublisherAndConsumerTest, GetChannel_ReturnsTheChannel) {
@@ -63,10 +94,10 @@ TEST_F(InputPublisherAndConsumerTest, GetChannel_ReturnsTheChannel) { 
              mConsumer->getChannel()->getConnectionToken());

              mConsumer->getChannel()->getConnectionToken());

}

}





void InputPublisherAndConsumerTest::PublishAndConsumeKeyEvent() {

void InputPublisherAndConsumerTest::publishAndConsumeKeyEvent() {

    status_t status;

    status_t status;





    constexpr uint32_t seq = 15;

    const uint32_t seq = mSeq++;

    int32_t eventId = InputEvent::nextId();

    int32_t eventId = InputEvent::nextId();

    constexpr int32_t deviceId = 1;

    constexpr int32_t deviceId = 1;

    constexpr uint32_t source = AINPUT_SOURCE_KEYBOARD;

    constexpr uint32_t source = AINPUT_SOURCE_KEYBOARD;
@@ -132,20 +163,43 @@ void InputPublisherAndConsumerTest::PublishAndConsumeKeyEvent() { 
            << "finished signal's consume time should be greater than publish time";

            << "finished signal's consume time should be greater than publish time";

}

}





void InputPublisherAndConsumerTest::PublishAndConsumeMotionEvent() {

void InputPublisherAndConsumerTest::publishAndConsumeMotionStream() {

    status_t status;

    const nsecs_t downTime = systemTime(SYSTEM_TIME_MONOTONIC);





    constexpr uint32_t seq = 15;

    publishAndConsumeMotionEvent(AMOTION_EVENT_ACTION_DOWN, downTime,

    int32_t eventId = InputEvent::nextId();

                                 {Pointer{.id = 0, .x = 20, .y = 30}});



    publishAndConsumeMotionEvent(POINTER_1_DOWN, downTime,

                                 {Pointer{.id = 0, .x = 20, .y = 30},

                                  Pointer{.id = 1, .x = 200, .y = 300}});



    publishAndConsumeMotionEvent(POINTER_2_DOWN, downTime,

                                 {Pointer{.id = 0, .x = 20, .y = 30},

                                  Pointer{.id = 1, .x = 200, .y = 300},

                                  Pointer{.id = 2, .x = 300, .y = 400}});



    // Provide a consistent input stream - cancel the gesture that was started above

    publishAndConsumeMotionEvent(AMOTION_EVENT_ACTION_CANCEL, downTime,

                                 {Pointer{.id = 0, .x = 20, .y = 30},

                                  Pointer{.id = 1, .x = 200, .y = 300},

                                  Pointer{.id = 2, .x = 300, .y = 400}});

}



void InputPublisherAndConsumerTest::publishAndConsumeMotionEvent(

        int32_t action, nsecs_t downTime, const std::vector<Pointer>& pointers) {

    constexpr int32_t deviceId = 1;

    constexpr int32_t deviceId = 1;

    constexpr uint32_t source = AINPUT_SOURCE_TOUCHSCREEN;

    constexpr uint32_t source = AINPUT_SOURCE_TOUCHSCREEN;

    constexpr int32_t displayId = ADISPLAY_ID_DEFAULT;

    constexpr int32_t displayId = ADISPLAY_ID_DEFAULT;

    constexpr std::array<uint8_t, 32> hmac = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10,

    constexpr std::array<uint8_t, 32> hmac = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10,

                                              11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,

                                              11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,

                                              22, 23, 24, 25, 26, 27, 28, 29, 30, 31};

                                              22, 23, 24, 25, 26, 27, 28, 29, 30, 31};

    constexpr int32_t action = AMOTION_EVENT_ACTION_MOVE;

    constexpr int32_t actionButton = 0;

    constexpr int32_t actionButton = 0;

    constexpr int32_t flags = AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;

    int32_t flags = AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;



    if (action == AMOTION_EVENT_ACTION_CANCEL) {

        flags |= AMOTION_EVENT_FLAG_CANCELED;

    }

    const size_t pointerCount = pointers.size();

    constexpr int32_t edgeFlags = AMOTION_EVENT_EDGE_FLAG_TOP;

    constexpr int32_t edgeFlags = AMOTION_EVENT_EDGE_FLAG_TOP;

    constexpr int32_t metaState = AMETA_ALT_LEFT_ON | AMETA_ALT_ON;

    constexpr int32_t metaState = AMETA_ALT_LEFT_ON | AMETA_ALT_ON;

    constexpr int32_t buttonState = AMOTION_EVENT_BUTTON_PRIMARY;

    constexpr int32_t buttonState = AMOTION_EVENT_BUTTON_PRIMARY;
@@ -162,20 +216,21 @@ void InputPublisherAndConsumerTest::PublishAndConsumeMotionEvent() { 
    constexpr float yPrecision = 0.5;

    constexpr float yPrecision = 0.5;

    constexpr float xCursorPosition = 1.3;

    constexpr float xCursorPosition = 1.3;

    constexpr float yCursorPosition = 50.6;

    constexpr float yCursorPosition = 50.6;

    constexpr nsecs_t downTime = 3;



    constexpr size_t pointerCount = 3;

    const nsecs_t eventTime = systemTime(SYSTEM_TIME_MONOTONIC);

    constexpr nsecs_t eventTime = 4;

    std::vector<PointerProperties> pointerProperties;

    const nsecs_t publishTime = systemTime(SYSTEM_TIME_MONOTONIC);

    std::vector<PointerCoords> pointerCoords;

    PointerProperties pointerProperties[pointerCount];

    PointerCoords pointerCoords[pointerCount];

    for (size_t i = 0; i < pointerCount; i++) {

    for (size_t i = 0; i < pointerCount; i++) {

        pointerProperties.push_back({});

        pointerProperties[i].clear();

        pointerProperties[i].clear();

        pointerProperties[i].id = (i + 2) % pointerCount;

        pointerProperties[i].id = pointers[i].id;

        pointerProperties[i].toolType = ToolType::FINGER;

        pointerProperties[i].toolType = ToolType::FINGER;





        pointerCoords.push_back({});

        pointerCoords[i].clear();

        pointerCoords[i].clear();

        pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, 100 * i);

        pointerCoords[i].isResampled = pointers[i].isResampled;

        pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, 200 * i);

        pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, pointers[i].x);

        pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, pointers[i].y);

        pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 0.5 * i);

        pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 0.5 * i);

        pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 0.7 * i);

        pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 0.7 * i);

        pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 1.5 * i);

        pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 1.5 * i);
@@ -185,18 +240,40 @@ void InputPublisherAndConsumerTest::PublishAndConsumeMotionEvent() { 
        pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 3.5 * i);

        pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 3.5 * i);

    }

    }





    publishAndConsumeMotionEvent(deviceId, source, displayId, hmac, action, actionButton, flags,

                                 edgeFlags, metaState, buttonState, classification, xScale, yScale,

                                 xOffset, yOffset, xPrecision, yPrecision, xCursorPosition,

                                 yCursorPosition, rawXScale, rawYScale, rawXOffset, rawYOffset,

                                 downTime, eventTime, pointerProperties, pointerCoords);

}



void InputPublisherAndConsumerTest::publishAndConsumeMotionEvent(

        int32_t deviceId, uint32_t source, int32_t displayId, std::array<uint8_t, 32> hmac,

        int32_t action, int32_t actionButton, int32_t flags, int32_t edgeFlags, int32_t metaState,

        int32_t buttonState, MotionClassification classification, float xScale, float yScale,

        float xOffset, float yOffset, float xPrecision, float yPrecision, float xCursorPosition,

        float yCursorPosition, float rawXScale, float rawYScale, float rawXOffset, float rawYOffset,

        nsecs_t downTime, nsecs_t eventTime,

        const std::vector<PointerProperties>& pointerProperties,

        const std::vector<PointerCoords>& pointerCoords) {

    const uint32_t seq = mSeq++;

    const int32_t eventId = InputEvent::nextId();

    ui::Transform transform;

    ui::Transform transform;

    transform.set({xScale, 0, xOffset, 0, yScale, yOffset, 0, 0, 1});

    transform.set({xScale, 0, xOffset, 0, yScale, yOffset, 0, 0, 1});

    ui::Transform rawTransform;

    ui::Transform rawTransform;

    rawTransform.set({rawXScale, 0, rawXOffset, 0, rawYScale, rawYOffset, 0, 0, 1});

    rawTransform.set({rawXScale, 0, rawXOffset, 0, rawYScale, rawYOffset, 0, 0, 1});



    status_t status;

    ASSERT_EQ(pointerProperties.size(), pointerCoords.size());

    const size_t pointerCount = pointerProperties.size();

    const nsecs_t publishTime = systemTime(SYSTEM_TIME_MONOTONIC);

    status = mPublisher->publishMotionEvent(seq, eventId, deviceId, source, displayId, hmac, action,

    status = mPublisher->publishMotionEvent(seq, eventId, deviceId, source, displayId, hmac, action,

                                            actionButton, flags, edgeFlags, metaState, buttonState,

                                            actionButton, flags, edgeFlags, metaState, buttonState,

                                            classification, transform, xPrecision, yPrecision,

                                            classification, transform, xPrecision, yPrecision,

                                            xCursorPosition, yCursorPosition, rawTransform,

                                            xCursorPosition, yCursorPosition, rawTransform,

                                            downTime, eventTime, pointerCount, pointerProperties,

                                            downTime, eventTime, pointerCount,

                                            pointerCoords);

                                            pointerProperties.data(), pointerCoords.data());

    ASSERT_EQ(OK, status)

    ASSERT_EQ(OK, status) << "publisher publishMotionEvent should return OK";

            << "publisher publishMotionEvent should return OK";





    uint32_t consumeSeq;

    uint32_t consumeSeq;

    InputEvent* event;

    InputEvent* event;
@@ -280,7 +357,7 @@ void InputPublisherAndConsumerTest::PublishAndConsumeMotionEvent() { 
            << "finished signal's consume time should be greater than publish time";

            << "finished signal's consume time should be greater than publish time";

}

}





void InputPublisherAndConsumerTest::PublishAndConsumeFocusEvent() {

void InputPublisherAndConsumerTest::publishAndConsumeFocusEvent() {

    status_t status;

    status_t status;





    constexpr uint32_t seq = 15;

    constexpr uint32_t seq = 15;
@@ -321,7 +398,7 @@ void InputPublisherAndConsumerTest::PublishAndConsumeFocusEvent() { 
            << "finished signal's consume time should be greater than publish time";

            << "finished signal's consume time should be greater than publish time";

}

}





void InputPublisherAndConsumerTest::PublishAndConsumeCaptureEvent() {

void InputPublisherAndConsumerTest::publishAndConsumeCaptureEvent() {

    status_t status;

    status_t status;





    constexpr uint32_t seq = 42;

    constexpr uint32_t seq = 42;
@@ -361,7 +438,7 @@ void InputPublisherAndConsumerTest::PublishAndConsumeCaptureEvent() { 
            << "finished signal's consume time should be greater than publish time";

            << "finished signal's consume time should be greater than publish time";

}

}





void InputPublisherAndConsumerTest::PublishAndConsumeDragEvent() {

void InputPublisherAndConsumerTest::publishAndConsumeDragEvent() {

    status_t status;

    status_t status;





    constexpr uint32_t seq = 15;

    constexpr uint32_t seq = 15;
@@ -405,7 +482,7 @@ void InputPublisherAndConsumerTest::PublishAndConsumeDragEvent() { 
            << "finished signal's consume time should be greater than publish time";

            << "finished signal's consume time should be greater than publish time";

}

}





void InputPublisherAndConsumerTest::PublishAndConsumeTouchModeEvent() {

void InputPublisherAndConsumerTest::publishAndConsumeTouchModeEvent() {

    status_t status;

    status_t status;





    constexpr uint32_t seq = 15;

    constexpr uint32_t seq = 15;
@@ -462,27 +539,27 @@ TEST_F(InputPublisherAndConsumerTest, SendTimeline) { 
}

}





TEST_F(InputPublisherAndConsumerTest, PublishKeyEvent_EndToEnd) {

TEST_F(InputPublisherAndConsumerTest, PublishKeyEvent_EndToEnd) {

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeKeyEvent());

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeKeyEvent());

}

}





TEST_F(InputPublisherAndConsumerTest, PublishMotionEvent_EndToEnd) {

TEST_F(InputPublisherAndConsumerTest, PublishMotionEvent_EndToEnd) {

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent());

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeMotionStream());

}

}





TEST_F(InputPublisherAndConsumerTest, PublishFocusEvent_EndToEnd) {

TEST_F(InputPublisherAndConsumerTest, PublishFocusEvent_EndToEnd) {

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeFocusEvent());

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeFocusEvent());

}

}





TEST_F(InputPublisherAndConsumerTest, PublishCaptureEvent_EndToEnd) {

TEST_F(InputPublisherAndConsumerTest, PublishCaptureEvent_EndToEnd) {

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeCaptureEvent());

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeCaptureEvent());

}

}





TEST_F(InputPublisherAndConsumerTest, PublishDragEvent_EndToEnd) {

TEST_F(InputPublisherAndConsumerTest, PublishDragEvent_EndToEnd) {

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeDragEvent());

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeDragEvent());

}

}





TEST_F(InputPublisherAndConsumerTest, PublishTouchModeEvent_EndToEnd) {

TEST_F(InputPublisherAndConsumerTest, PublishTouchModeEvent_EndToEnd) {

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeTouchModeEvent());

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeTouchModeEvent());

}

}





TEST_F(InputPublisherAndConsumerTest, PublishMotionEvent_WhenSequenceNumberIsZero_ReturnsError) {

TEST_F(InputPublisherAndConsumerTest, PublishMotionEvent_WhenSequenceNumberIsZero_ReturnsError) {
@@ -546,17 +623,29 @@ TEST_F(InputPublisherAndConsumerTest, 
}

}





TEST_F(InputPublisherAndConsumerTest, PublishMultipleEvents_EndToEnd) {

TEST_F(InputPublisherAndConsumerTest, PublishMultipleEvents_EndToEnd) {

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent());

    const nsecs_t downTime = systemTime(SYSTEM_TIME_MONOTONIC);

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeKeyEvent());



    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent());

    publishAndConsumeMotionEvent(AMOTION_EVENT_ACTION_DOWN, downTime,

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeFocusEvent());

                                 {Pointer{.id = 0, .x = 20, .y = 30}});

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent());

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeKeyEvent());

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeKeyEvent());

    publishAndConsumeMotionEvent(POINTER_1_DOWN, downTime,

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeCaptureEvent());

                                 {Pointer{.id = 0, .x = 20, .y = 30},

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeDragEvent());

                                  Pointer{.id = 1, .x = 200, .y = 300}});

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeMotionEvent());

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeFocusEvent());

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeKeyEvent());

    publishAndConsumeMotionEvent(POINTER_2_DOWN, downTime,

    ASSERT_NO_FATAL_FAILURE(PublishAndConsumeTouchModeEvent());

                                 {Pointer{.id = 0, .x = 20, .y = 30},

                                  Pointer{.id = 1, .x = 200, .y = 300},

                                  Pointer{.id = 2, .x = 200, .y = 300}});

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeKeyEvent());

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeCaptureEvent());

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeDragEvent());

    // Provide a consistent input stream - cancel the gesture that was started above

    publishAndConsumeMotionEvent(AMOTION_EVENT_ACTION_CANCEL, downTime,

                                 {Pointer{.id = 0, .x = 20, .y = 30},

                                  Pointer{.id = 1, .x = 200, .y = 300},

                                  Pointer{.id = 2, .x = 200, .y = 300}});

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeKeyEvent());

    ASSERT_NO_FATAL_FAILURE(publishAndConsumeTouchModeEvent());

}

}





} // namespace android
 
} // namespace android

libs/input/tests/TouchResampling_test.cpp

+6 −2
Original line number Original line Diff line number Diff line
@@ -27,6 +27,8 @@ using namespace std::chrono_literals; 




namespace android {

namespace android {





namespace {



struct Pointer {

struct Pointer {

    int32_t id;

    int32_t id;

    float x;

    float x;
@@ -41,6 +43,8 @@ struct InputEventEntry { 
    int32_t action;

    int32_t action;

};

};





} // namespace



class TouchResamplingTest : public testing::Test {

class TouchResamplingTest : public testing::Test {

protected:

protected:

    std::unique_ptr<InputPublisher> mPublisher;

    std::unique_ptr<InputPublisher> mPublisher;
@@ -587,13 +591,13 @@ TEST_F(TouchResamplingTest, TwoPointersAreResampledIndependently) { 
    // First pointer id=0 leaves the screen

    // First pointer id=0 leaves the screen

    entries = {

    entries = {

            //      id  x    y

            //      id  x    y

            {80ms, {{1, 600, 600}}, actionPointer0Up},

            {80ms, {{0, 120, 120}, {1, 600, 600}}, actionPointer0Up},

    };

    };

    publishInputEventEntries(entries);

    publishInputEventEntries(entries);

    frameTime = 90ms;

    frameTime = 90ms;

    expectedEntries = {

    expectedEntries = {

            //      id  x    y

            //      id  x    y

            {80ms, {{1, 600, 600}}, actionPointer0Up},

            {80ms, {{0, 120, 120}, {1, 600, 600}}, actionPointer0Up},

            // no resampled event for ACTION_POINTER_UP

            // no resampled event for ACTION_POINTER_UP

    };

    };

    consumeInputEventEntries(expectedEntries, frameTime);

    consumeInputEventEntries(expectedEntries, frameTime);