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

Commit 5a240aaf authored by Marissa Wall's avatar Marissa Wall
Browse files

test-hwc2: set layer buffer 

Test: Add "#define HAVE_NO_SURFACE_FLINGER" to
          frameworks/native/libs/gui/BufferQueueCore.cpp.
      Recompile and flash.
      Run "mm" in frameworks/native/services/surfaceflinger/tests/hwc2.
      Push test-hwc2 to device.
      Run "adb root && adb shell stop".
      Run test case. Ex: "./test-hwc2"

Change-Id: Ie42d1fd4c2d0248c4a3ecf09a9b5871d501f6172
parent ad761818

services/surfaceflinger/tests/hwc2/Android.mk

+18 −4
Original line number Diff line number Diff line
@@ -24,13 +24,27 @@ LOCAL_CFLAGS += \ 
    -g \

    -Wall -Wextra \

    -Werror \

    -fno-builtin

LOCAL_SHARED_LIBRARIES := libcutils libutils libhardware liblog

LOCAL_STATIC_LIBRARIES := libbase libadf libadfhwc

    -fno-builtin \

    -DEGL_EGLEXT_PROTOTYPES \

    -DGL_GLEXT_PROTOTYPES

LOCAL_SHARED_LIBRARIES := \

    libcutils \

    libutils \

    libhardware \

    libEGL \

    libGLESv2 \

    libui \

    libgui \

    liblog

LOCAL_STATIC_LIBRARIES := \

    libbase \

    libadf \

    libadfhwc

LOCAL_SRC_FILES := \

    Hwc2Test.cpp \

    Hwc2TestProperties.cpp \

    Hwc2TestLayer.cpp \

    Hwc2TestLayers.cpp

    Hwc2TestLayers.cpp \

    Hwc2TestBuffer.cpp



include $(BUILD_NATIVE_TEST)

services/surfaceflinger/tests/hwc2/Hwc2Test.cpp

+145 −46
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#include <unordered_set>

#include <gtest/gtest.h>

#include <dlfcn.h>

#include <android-base/unique_fd.h>

#include <hardware/hardware.h>



#define HWC2_INCLUDE_STRINGIFICATION
@@ -391,6 +392,23 @@ public: 
        }

    }



    void setLayerBuffer(hwc2_display_t display, hwc2_layer_t layer,

            buffer_handle_t buffer, int32_t acquireFence,

            hwc2_error_t* outErr = nullptr)

    {

        auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_BUFFER>(

                getFunction(HWC2_FUNCTION_SET_LAYER_BUFFER));

        ASSERT_TRUE(pfn) << "failed to get function";



        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,

                buffer, acquireFence));

        if (outErr) {

            *outErr = err;

        } else {

            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer buffer";

        }

    }



    void setLayerColor(hwc2_display_t display, hwc2_layer_t layer,

            hwc_color_t color, hwc2_error_t* outErr = nullptr)

    {
@@ -665,19 +683,19 @@ protected: 
     * Hwc2TestLayer to hwc2_layer_t on hwc2_display_t */

    using TestLayerPropertyFunction = void (*)(Hwc2Test* test,

            hwc2_display_t display, hwc2_layer_t layer,

            const Hwc2TestLayer& testLayer, hwc2_error_t* outErr);

            Hwc2TestLayer* testLayer, hwc2_error_t* outErr);



    /* Calls a set property function from Hwc2Test to set property values from

     * Hwc2TestLayers to hwc2_layer_t on hwc2_display_t */

    using TestLayerPropertiesFunction = void (*)(Hwc2Test* test,

            hwc2_display_t display, hwc2_layer_t layer,

            const Hwc2TestLayers& testLayers);

            Hwc2TestLayers* testLayers);



    /* Calls a set property function from Hwc2Test to set a bad property value

     * on hwc2_layer_t on hwc2_display_t */

    using TestLayerPropertyBadLayerFunction = void (*)(Hwc2Test* test,

            hwc2_display_t display, hwc2_layer_t layer,

            const Hwc2TestLayer& testLayer, hwc2_error_t* outErr);

            Hwc2TestLayer* testLayer, hwc2_error_t* outErr);



    /* Calls a set property function from Hwc2Test to set a bad property value

     * on hwc2_layer_t on hwc2_display_t */
@@ -711,7 +729,7 @@ protected: 
                    ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));



                    ASSERT_NO_FATAL_FAILURE(function(this, display, layer,

                            testLayer, nullptr));

                            &testLayer, nullptr));



                    ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));

                } while (advance(&testLayer));
@@ -743,7 +761,7 @@ protected: 


                do {

                    ASSERT_NO_FATAL_FAILURE(function(this, display, layer,

                            testLayer, nullptr));

                            &testLayer, nullptr));

                } while (advance(&testLayer));



                ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
@@ -776,7 +794,7 @@ protected: 


                for (auto layer : layers) {

                    EXPECT_NO_FATAL_FAILURE(function(this, display, layer,

                            testLayers));

                            &testLayers));

                }



                ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers)));
@@ -810,19 +828,19 @@ protected: 
                Hwc2TestLayer testLayer(coverage, displayArea);



                ASSERT_NO_FATAL_FAILURE(function(this, display, layer,

                        testLayer, &err));

                        &testLayer, &err));

                EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";



                ASSERT_NO_FATAL_FAILURE(createLayer(display, &layer));



                ASSERT_NO_FATAL_FAILURE(function(this, display, layer + 1,

                        testLayer, &err));

                        &testLayer, &err));

                EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";



                ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));



                ASSERT_NO_FATAL_FAILURE(function(this, display, layer,

                        testLayer, &err));

                        &testLayer, &err));

                EXPECT_EQ(err, HWC2_ERROR_BAD_LAYER) << "returned wrong error code";

            }

        }
@@ -918,29 +936,50 @@ void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData, 
}



void setBlendMode(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)

        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{

    EXPECT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, layer,

            testLayer.getBlendMode(), outErr));

            testLayer->getBlendMode(), outErr));

}



void setBuffer(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{

    buffer_handle_t handle;

    android::base::unique_fd acquireFence;

    hwc2_composition_t composition = testLayer->getComposition();



    if (composition == HWC2_COMPOSITION_CLIENT

            || composition == HWC2_COMPOSITION_SOLID_COLOR

            || composition == HWC2_COMPOSITION_SIDEBAND)

        return;



    if (testLayer->getBuffer(&handle, &acquireFence) < 0)

        return;



    ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, layer,

            composition));

    EXPECT_NO_FATAL_FAILURE(test->setLayerBuffer(display, layer,

            handle, acquireFence, outErr));

}



void setColor(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)

        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{

    ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display,

            layer, HWC2_COMPOSITION_SOLID_COLOR));

    ASSERT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display,

            layer, testLayer.getPlaneAlpha()));

            layer, testLayer->getPlaneAlpha()));

    ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display,

            layer, testLayer.getBlendMode()));

            layer, testLayer->getBlendMode()));

    EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, layer,

            testLayer.getColor(), outErr));

            testLayer->getColor(), outErr));

}



void setComposition(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)

        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{

    hwc2_composition_t composition = testLayer.getComposition();

    hwc2_composition_t composition = testLayer->getComposition();

    hwc2_error_t err = HWC2_ERROR_NONE;



    ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display, layer,
@@ -959,65 +998,65 @@ void setComposition(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 
}



void setCursorPosition(Hwc2Test* test, hwc2_display_t display,

        hwc2_layer_t layer, const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)

        hwc2_layer_t layer, Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{

    ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display,

            layer, HWC2_COMPOSITION_CURSOR));



    const hwc_rect_t cursorPosition = testLayer.getCursorPosition();

    const hwc_rect_t cursorPosition = testLayer->getCursorPosition();

    EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display, layer,

            cursorPosition.left, cursorPosition.top, outErr));

}



void setDataspace(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)

        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{

    EXPECT_NO_FATAL_FAILURE(test->setLayerDataspace(display, layer,

            testLayer.getDataspace(), outErr));

            testLayer->getDataspace(), outErr));

}



void setDisplayFrame(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)

        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{

    EXPECT_NO_FATAL_FAILURE(test->setLayerDisplayFrame(display, layer,

            testLayer.getDisplayFrame(), outErr));

            testLayer->getDisplayFrame(), outErr));

}



void setPlaneAlpha(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        const Hwc2TestLayer& testLayer, hwc2_error_t *outErr)

        Hwc2TestLayer* testLayer, hwc2_error_t *outErr)

{

    ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display, layer,

            testLayer.getBlendMode()));

            testLayer->getBlendMode()));

    EXPECT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display, layer,

            testLayer.getPlaneAlpha(), outErr));

            testLayer->getPlaneAlpha(), outErr));

}



void setSourceCrop(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)

        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{

    EXPECT_NO_FATAL_FAILURE(test->setLayerSourceCrop(display, layer,

            testLayer.getSourceCrop(), outErr));

            testLayer->getSourceCrop(), outErr));

}



void setSurfaceDamage(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)

        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{

    EXPECT_NO_FATAL_FAILURE(test->setLayerSurfaceDamage(display, layer,

            testLayer.getSurfaceDamage(), outErr));

            testLayer->getSurfaceDamage(), outErr));

}



void setTransform(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)

        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{

    EXPECT_NO_FATAL_FAILURE(test->setLayerTransform(display, layer,

            testLayer.getTransform(), outErr));

            testLayer->getTransform(), outErr));

}



void setZOrder(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)

        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{

    EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer,

            testLayer.getZOrder(), outErr));

            testLayer->getZOrder(), outErr));

}



bool advanceBlendMode(Hwc2TestLayer* testLayer)
@@ -1025,6 +1064,13 @@ bool advanceBlendMode(Hwc2TestLayer* testLayer) 
    return testLayer->advanceBlendMode();

}



bool advanceBuffer(Hwc2TestLayer* testLayer)

{

    if (testLayer->advanceComposition())

        return true;

    return testLayer->advanceBufferArea();

}



bool advanceColor(Hwc2TestLayer* testLayer)

{

    /* Color depends on blend mode so advance blend mode last so color is not
@@ -1948,9 +1994,9 @@ TEST_F(Hwc2Test, SET_CURSOR_POSITION_composition_type_unset) 
{

    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,

            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

                    const Hwc2TestLayer& testLayer, hwc2_error_t* outErr) {

                    Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {



                const hwc_rect_t cursorPosition = testLayer.getCursorPosition();

                const hwc_rect_t cursorPosition = testLayer->getCursorPosition();

                EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display, layer,

                        cursorPosition.left, cursorPosition.top, outErr));

            },
@@ -1978,9 +2024,9 @@ TEST_F(Hwc2Test, SET_CURSOR_POSITION_bad_layer) 
{

    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,

            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,

                    const Hwc2TestLayer& testLayer, hwc2_error_t* outErr) {

                    Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {



                const hwc_rect_t cursorPosition = testLayer.getCursorPosition();

                const hwc_rect_t cursorPosition = testLayer->getCursorPosition();

                EXPECT_NO_FATAL_FAILURE(test->setCursorPosition(display,

                        badLayer, cursorPosition.left, cursorPosition.top,

                        outErr));
@@ -2022,6 +2068,59 @@ TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_bad_parameter) 
    ));

}



/* TESTCASE: Tests that the HWC2 can set the buffer of a layer. */

TEST_F(Hwc2Test, SET_LAYER_BUFFER)

{

    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,

            setBuffer, advanceBuffer));

}



/* TESTCASE: Tests that the HWC2 can update the buffer of a layer. */

TEST_F(Hwc2Test, SET_LAYER_BUFFER_update)

{

    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,

            setBuffer, advanceBuffer));

}



/* TESTCASE: Tests that the HWC2 cannot set the buffer of a bad layer. */

TEST_F(Hwc2Test, SET_LAYER_BUFFER_bad_layer)

{

    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,

            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,

                    Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {



                buffer_handle_t handle = nullptr;

                android::base::unique_fd acquireFence;



                /* If there is not available buffer for the given buffer

                 * properties, it should not fail this test case */

                if (testLayer->getBuffer(&handle, &acquireFence) == 0) {

                    *outErr = HWC2_ERROR_BAD_LAYER;

                    return;

                }



                ASSERT_NO_FATAL_FAILURE(test->setLayerBuffer(display, badLayer,

                        handle, acquireFence, outErr));

            }

    ));

}



/* TESTCASE: Tests that the HWC2 can set an invalid buffer for a layer. */

TEST_F(Hwc2Test, SET_LAYER_BUFFER_bad_parameter)

{

    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadParameter(

            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

                    hwc2_error_t* outErr) {



                buffer_handle_t handle = nullptr;

                int32_t acquireFence = -1;



                ASSERT_NO_FATAL_FAILURE(test->setLayerBuffer(display, layer,

                        handle, acquireFence, outErr));

            }

    ));

}



/* TESTCASE: Tests that the HWC2 can set the color of a layer. */

TEST_F(Hwc2Test, SET_LAYER_COLOR)

{
@@ -2042,10 +2141,10 @@ TEST_F(Hwc2Test, SET_LAYER_COLOR_composition_type_unset) 
{

    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Basic,

            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

                    const Hwc2TestLayer& testLayer, hwc2_error_t* outErr) {

                    Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {



                EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, layer,

                        testLayer.getColor(), outErr));

                        testLayer->getColor(), outErr));

            },



            advanceColor));
@@ -2056,10 +2155,10 @@ TEST_F(Hwc2Test, SET_LAYER_COLOR_bad_layer) 
{

    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,

            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,

                    const Hwc2TestLayer& testLayer, hwc2_error_t* outErr) {

                    Hwc2TestLayer* testLayer, hwc2_error_t* outErr) {



                EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, badLayer,

                        testLayer.getColor(), outErr));

                        testLayer->getColor(), outErr));

            }

    ));

}
@@ -2125,10 +2224,10 @@ TEST_F(Hwc2Test, SET_LAYER_PLANE_ALPHA_bad_layer) 
{

    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,

            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t badLayer,

                    const Hwc2TestLayer& testLayer, hwc2_error_t *outErr) {

                    Hwc2TestLayer* testLayer, hwc2_error_t *outErr) {



                    EXPECT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display,

                            badLayer, testLayer.getPlaneAlpha(), outErr));

                            badLayer, testLayer->getPlaneAlpha(), outErr));

            }

    ));

}
@@ -2201,10 +2300,10 @@ TEST_F(Hwc2Test, SET_LAYER_Z_ORDER) 
{

    ASSERT_NO_FATAL_FAILURE(setLayerProperties(Hwc2TestCoverage::Complete, 10,

            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

                    const Hwc2TestLayers& testLayers) {

                    Hwc2TestLayers* testLayers) {



                EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer,

                        testLayers.getZOrder(layer)));

                        testLayers->getZOrder(layer)));

            }

    ));

}

services/surfaceflinger/tests/hwc2/Hwc2TestBuffer.cpp

0 → 100644
+452 −0

File added.

Preview size limit exceeded, changes collapsed.

services/surfaceflinger/tests/hwc2/Hwc2TestBuffer.h

0 → 100644
+58 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef _HWC2_TEST_BUFFER_H

#define _HWC2_TEST_BUFFER_H



#include <android-base/unique_fd.h>

#include <hardware/hwcomposer2.h>



#include <gui/GraphicBufferAlloc.h>

#include <ui/GraphicBuffer.h>



#include "Hwc2TestProperties.h"



class Hwc2TestFenceGenerator;



class Hwc2TestBuffer {

public:

    Hwc2TestBuffer();

    ~Hwc2TestBuffer();



    void updateBufferArea(const Area& bufferArea);



    int  get(buffer_handle_t* outHandle, int32_t* outFence);



protected:

    int generateBuffer();



    void setColor(int32_t x, int32_t y, android_pixel_format_t format,

            uint32_t stride, uint8_t* img, uint8_t r, uint8_t g, uint8_t b,

            uint8_t a);



    android::GraphicBufferAlloc mGraphicBufferAlloc;

    android::sp<android::GraphicBuffer> mGraphicBuffer;



    std::unique_ptr<Hwc2TestFenceGenerator> mFenceGenerator;



    Area mBufferArea = {-1, -1};

    const android_pixel_format_t mFormat = HAL_PIXEL_FORMAT_RGBA_8888;



    bool mValidBuffer = false;

    buffer_handle_t mHandle = nullptr;

};



#endif /* ifndef _HWC2_TEST_BUFFER_H */

services/surfaceflinger/tests/hwc2/Hwc2TestLayer.cpp

+10 −0
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ Hwc2TestLayer::Hwc2TestLayer(Hwc2TestCoverage coverage, const Area& displayArea, 
      mTransform(coverage),

      mZOrder(zOrder)

{

    mBufferArea.setDependent(&mBuffer);

    mBufferArea.setDependent(&mSourceCrop);

    mBufferArea.setDependent(&mSurfaceDamage);

    mBlendMode.setDependent(&mColor);
@@ -52,6 +53,15 @@ std::string Hwc2TestLayer::dump() const 
    return dmp.str();

}



int Hwc2TestLayer::getBuffer(buffer_handle_t* outHandle,

        android::base::unique_fd* outAcquireFence)

{

    int32_t acquireFence;

    int ret = mBuffer.get(outHandle, &acquireFence);

    outAcquireFence->reset(acquireFence);

    return ret;

}



void Hwc2TestLayer::reset()

{

    for (auto property : mProperties) {