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

Commit 60806c7d authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "SF: Split DisplayTransactionTest"

parents fac95177 07b1ff37

services/surfaceflinger/tests/unittests/Android.bp

+12 −0
Original line number Diff line number Diff line
@@ -41,6 +41,8 @@ cc_test { 
        "DisplayIdentificationTest.cpp",

        "DisplayIdGeneratorTest.cpp",

        "DisplayTransactionTest.cpp",

        "DisplayDevice_GetBestColorModeTest.cpp",

        "DisplayDevice_SetProjectionTest.cpp",

        "EventThreadTest.cpp",

        "FrameTimelineTest.cpp",

        "HWComposerTest.cpp",
@@ -50,6 +52,16 @@ cc_test { 
        "LayerMetadataTest.cpp",

        "MessageQueueTest.cpp",

        "PromiseTest.cpp",

        "SurfaceFlinger_CreateDisplayTest.cpp",

        "SurfaceFlinger_DestroyDisplayTest.cpp",

        "SurfaceFlinger_GetDisplayNativePrimariesTest.cpp",

        "SurfaceFlinger_HandleTransactionLockedTest.cpp",

        "SurfaceFlinger_NotifyPowerBoostTest.cpp",

        "SurfaceFlinger_OnHotplugReceivedTest.cpp",

        "SurfaceFlinger_OnInitializeDisplaysTest.cpp",

        "SurfaceFlinger_SetDisplayStateTest.cpp",

        "SurfaceFlinger_SetPowerModeInternalTest.cpp",

        "SurfaceFlinger_SetupNewDisplayDeviceInternalTest.cpp",

        "SchedulerTest.cpp",

        "SchedulerUtilsTest.cpp",

        "SetFrameRateTest.cpp",

services/surfaceflinger/tests/unittests/DisplayDevice_GetBestColorModeTest.cpp

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

 * Copyright 2020 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.

 */



#undef LOG_TAG

#define LOG_TAG "LibSurfaceFlingerUnittests"



#include "DisplayTransactionTestHelpers.h"



#include <gmock/gmock.h>

#include <gtest/gtest.h>



namespace android {

namespace {



using hal::RenderIntent;



using FakeDisplayDeviceInjector = TestableSurfaceFlinger::FakeDisplayDeviceInjector;



class GetBestColorModeTest : public DisplayTransactionTest {

public:

    void setHasWideColorGamut(bool hasWideColorGamut) { mHasWideColorGamut = hasWideColorGamut; }



    void addHwcColorModesMapping(ui::ColorMode colorMode,

                                 std::vector<ui::RenderIntent> renderIntents) {

        mHwcColorModes[colorMode] = renderIntents;

    }



    void setInputDataspace(ui::Dataspace dataspace) { mInputDataspace = dataspace; }



    void setInputRenderIntent(ui::RenderIntent renderIntent) { mInputRenderIntent = renderIntent; }



    void getBestColorMode() {

        auto displayDevice =

                injectDefaultInternalDisplay([this](FakeDisplayDeviceInjector& injector) {

                    injector.setHwcColorModes(mHwcColorModes);

                    injector.setHasWideColorGamut(mHasWideColorGamut);

                    injector.setNativeWindow(mNativeWindow);

                });



        displayDevice->getCompositionDisplay()

                ->getDisplayColorProfile()

                ->getBestColorMode(mInputDataspace, mInputRenderIntent, &mOutDataspace,

                                   &mOutColorMode, &mOutRenderIntent);

    }



    ui::Dataspace mOutDataspace;

    ui::ColorMode mOutColorMode;

    ui::RenderIntent mOutRenderIntent;



private:

    ui::Dataspace mInputDataspace;

    ui::RenderIntent mInputRenderIntent;

    bool mHasWideColorGamut = false;

    std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>> mHwcColorModes;

};



TEST_F(GetBestColorModeTest, DataspaceDisplayP3_ColorModeSRGB) {

    addHwcColorModesMapping(ui::ColorMode::SRGB,

                            std::vector<ui::RenderIntent>(1, RenderIntent::COLORIMETRIC));

    setInputDataspace(ui::Dataspace::DISPLAY_P3);

    setInputRenderIntent(ui::RenderIntent::COLORIMETRIC);

    setHasWideColorGamut(true);



    getBestColorMode();



    ASSERT_EQ(ui::Dataspace::V0_SRGB, mOutDataspace);

    ASSERT_EQ(ui::ColorMode::SRGB, mOutColorMode);

    ASSERT_EQ(ui::RenderIntent::COLORIMETRIC, mOutRenderIntent);

}



TEST_F(GetBestColorModeTest, DataspaceDisplayP3_ColorModeDisplayP3) {

    addHwcColorModesMapping(ui::ColorMode::DISPLAY_P3,

                            std::vector<ui::RenderIntent>(1, RenderIntent::COLORIMETRIC));

    addHwcColorModesMapping(ui::ColorMode::SRGB,

                            std::vector<ui::RenderIntent>(1, RenderIntent::COLORIMETRIC));

    addHwcColorModesMapping(ui::ColorMode::DISPLAY_BT2020,

                            std::vector<ui::RenderIntent>(1, RenderIntent::COLORIMETRIC));

    setInputDataspace(ui::Dataspace::DISPLAY_P3);

    setInputRenderIntent(ui::RenderIntent::COLORIMETRIC);

    setHasWideColorGamut(true);



    getBestColorMode();



    ASSERT_EQ(ui::Dataspace::DISPLAY_P3, mOutDataspace);

    ASSERT_EQ(ui::ColorMode::DISPLAY_P3, mOutColorMode);

    ASSERT_EQ(ui::RenderIntent::COLORIMETRIC, mOutRenderIntent);

}



TEST_F(GetBestColorModeTest, DataspaceDisplayP3_ColorModeDISPLAY_BT2020) {

    addHwcColorModesMapping(ui::ColorMode::DISPLAY_BT2020,

                            std::vector<ui::RenderIntent>(1, RenderIntent::COLORIMETRIC));

    setInputDataspace(ui::Dataspace::DISPLAY_P3);

    setInputRenderIntent(ui::RenderIntent::COLORIMETRIC);

    setHasWideColorGamut(true);



    getBestColorMode();



    ASSERT_EQ(ui::Dataspace::DISPLAY_BT2020, mOutDataspace);

    ASSERT_EQ(ui::ColorMode::DISPLAY_BT2020, mOutColorMode);

    ASSERT_EQ(ui::RenderIntent::COLORIMETRIC, mOutRenderIntent);

}



} // namespace

} // namespace android

services/surfaceflinger/tests/unittests/DisplayDevice_SetProjectionTest.cpp

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

 * Copyright 2020 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.

 */



#undef LOG_TAG

#define LOG_TAG "LibSurfaceFlingerUnittests"



#include "DisplayTransactionTestHelpers.h"



#include <gmock/gmock.h>

#include <gtest/gtest.h>



namespace android {

namespace {



using FakeDisplayDeviceInjector = TestableSurfaceFlinger::FakeDisplayDeviceInjector;



class DisplayDeviceSetProjectionTest : public DisplayTransactionTest {

public:

    static constexpr int32_t DEFAULT_DISPLAY_WIDTH = 1080;  // arbitrary

    static constexpr int32_t DEFAULT_DISPLAY_HEIGHT = 1920; // arbitrary



    static constexpr int32_t TRANSFORM_FLAGS_ROT_0 = 0;

    static constexpr int32_t TRANSFORM_FLAGS_ROT_90 = HAL_TRANSFORM_ROT_90;

    static constexpr int32_t TRANSFORM_FLAGS_ROT_180 = HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_FLIP_V;

    static constexpr int32_t TRANSFORM_FLAGS_ROT_270 =

            HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90;



    DisplayDeviceSetProjectionTest(ui::Size flingerDisplaySize, ui::Size hardwareDisplaySize,

                                   ui::Rotation physicalOrientation)

          : mFlingerDisplaySize(flingerDisplaySize),

            mHardwareDisplaySize(hardwareDisplaySize),

            mPhysicalOrientation(physicalOrientation),

            mDisplayDevice(createDisplayDevice()) {}



    sp<DisplayDevice> createDisplayDevice() {

        return injectDefaultInternalDisplay([this](FakeDisplayDeviceInjector& injector) {

            injector.setPhysicalOrientation(mPhysicalOrientation);

        });

    }



    ui::Size swapWH(const ui::Size size) const { return ui::Size(size.height, size.width); }



    void setProjectionForRotation0() {

        // A logical rotation of 0 uses the SurfaceFlinger display size

        mDisplayDevice->setProjection(ui::ROTATION_0, Rect(mFlingerDisplaySize),

                                      Rect(mFlingerDisplaySize));

    }



    void setProjectionForRotation90() {

        // A logical rotation of 90 uses the SurfaceFlinger display size with

        // the width/height swapped.

        mDisplayDevice->setProjection(ui::ROTATION_90, Rect(swapWH(mFlingerDisplaySize)),

                                      Rect(swapWH(mFlingerDisplaySize)));

    }



    void setProjectionForRotation180() {

        // A logical rotation of 180 uses the SurfaceFlinger display size

        mDisplayDevice->setProjection(ui::ROTATION_180, Rect(mFlingerDisplaySize),

                                      Rect(mFlingerDisplaySize));

    }



    void setProjectionForRotation270() {

        // A logical rotation of 270 uses the SurfaceFlinger display size with

        // the width/height swapped.

        mDisplayDevice->setProjection(ui::ROTATION_270, Rect(swapWH(mFlingerDisplaySize)),

                                      Rect(swapWH(mFlingerDisplaySize)));

    }



    void expectStateForHardwareTransform0() {

        const auto& compositionState = mDisplayDevice->getCompositionDisplay()->getState();

        EXPECT_EQ(ui::Transform(TRANSFORM_FLAGS_ROT_0, mHardwareDisplaySize.width,

                                mHardwareDisplaySize.height),

                  compositionState.transform);

        EXPECT_EQ(ui::ROTATION_0, compositionState.displaySpace.orientation);

        EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.displaySpace.content);

        EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.orientedDisplaySpace.content);

        EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.layerStackSpace.content);

        EXPECT_EQ(false, compositionState.needsFiltering);

    }



    void expectStateForHardwareTransform90() {

        const auto& compositionState = mDisplayDevice->getCompositionDisplay()->getState();

        EXPECT_EQ(ui::Transform(TRANSFORM_FLAGS_ROT_90, mHardwareDisplaySize.width,

                                mHardwareDisplaySize.height),

                  compositionState.transform);

        EXPECT_EQ(ui::ROTATION_90, compositionState.displaySpace.orientation);

        EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.displaySpace.content);

        // For 90, the orientedDisplaySpaceRect and layerStackSpaceRect have the hardware display

        // size width and height swapped

        EXPECT_EQ(Rect(swapWH(mHardwareDisplaySize)),

                  compositionState.orientedDisplaySpace.content);

        EXPECT_EQ(Rect(swapWH(mHardwareDisplaySize)), compositionState.layerStackSpace.content);

        EXPECT_EQ(false, compositionState.needsFiltering);

    }



    void expectStateForHardwareTransform180() {

        const auto& compositionState = mDisplayDevice->getCompositionDisplay()->getState();

        EXPECT_EQ(ui::Transform(TRANSFORM_FLAGS_ROT_180, mHardwareDisplaySize.width,

                                mHardwareDisplaySize.height),

                  compositionState.transform);

        EXPECT_EQ(ui::ROTATION_180, compositionState.displaySpace.orientation);

        EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.orientedDisplaySpace.content);

        EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.layerStackSpace.content);

        EXPECT_EQ(false, compositionState.needsFiltering);

    }



    void expectStateForHardwareTransform270() {

        const auto& compositionState = mDisplayDevice->getCompositionDisplay()->getState();

        EXPECT_EQ(ui::Transform(TRANSFORM_FLAGS_ROT_270, mHardwareDisplaySize.width,

                                mHardwareDisplaySize.height),

                  compositionState.transform);

        EXPECT_EQ(ui::ROTATION_270, compositionState.displaySpace.orientation);

        EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.displaySpace.content);

        // For 270, the orientedDisplaySpaceRect and layerStackSpaceRect have the hardware display

        // size width and height swapped

        EXPECT_EQ(Rect(swapWH(mHardwareDisplaySize)),

                  compositionState.orientedDisplaySpace.content);

        EXPECT_EQ(Rect(swapWH(mHardwareDisplaySize)), compositionState.layerStackSpace.content);

        EXPECT_EQ(false, compositionState.needsFiltering);

    }



    const ui::Size mFlingerDisplaySize;

    const ui::Size mHardwareDisplaySize;

    const ui::Rotation mPhysicalOrientation;

    const sp<DisplayDevice> mDisplayDevice;

};



struct DisplayDeviceSetProjectionTest_Installed0 : public DisplayDeviceSetProjectionTest {

    DisplayDeviceSetProjectionTest_Installed0()

          : DisplayDeviceSetProjectionTest(ui::Size(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),

                                           ui::Size(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),

                                           ui::ROTATION_0) {}

};



TEST_F(DisplayDeviceSetProjectionTest_Installed0, checkWith0OutputRotation) {

    setProjectionForRotation0();

    expectStateForHardwareTransform0();

}



TEST_F(DisplayDeviceSetProjectionTest_Installed0, checkWith90OutputRotation) {

    setProjectionForRotation90();

    expectStateForHardwareTransform90();

}



TEST_F(DisplayDeviceSetProjectionTest_Installed0, checkWith180OutputRotation) {

    setProjectionForRotation180();

    expectStateForHardwareTransform180();

}



TEST_F(DisplayDeviceSetProjectionTest_Installed0, checkWith270OutputRotation) {

    setProjectionForRotation270();

    expectStateForHardwareTransform270();

}



struct DisplayDeviceSetProjectionTest_Installed90 : public DisplayDeviceSetProjectionTest {

    DisplayDeviceSetProjectionTest_Installed90()

          : DisplayDeviceSetProjectionTest(ui::Size(DEFAULT_DISPLAY_HEIGHT, DEFAULT_DISPLAY_WIDTH),

                                           ui::Size(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),

                                           ui::ROTATION_90) {}

};



TEST_F(DisplayDeviceSetProjectionTest_Installed90, checkWith0OutputRotation) {

    setProjectionForRotation0();

    expectStateForHardwareTransform90();

}



TEST_F(DisplayDeviceSetProjectionTest_Installed90, checkWith90OutputRotation) {

    setProjectionForRotation90();

    expectStateForHardwareTransform180();

}



TEST_F(DisplayDeviceSetProjectionTest_Installed90, checkWith180OutputRotation) {

    setProjectionForRotation180();

    expectStateForHardwareTransform270();

}



TEST_F(DisplayDeviceSetProjectionTest_Installed90, checkWith270OutputRotation) {

    setProjectionForRotation270();

    expectStateForHardwareTransform0();

}



struct DisplayDeviceSetProjectionTest_Installed180 : public DisplayDeviceSetProjectionTest {

    DisplayDeviceSetProjectionTest_Installed180()

          : DisplayDeviceSetProjectionTest(ui::Size(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),

                                           ui::Size(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),

                                           ui::ROTATION_180) {}

};



TEST_F(DisplayDeviceSetProjectionTest_Installed180, checkWith0OutputRotation) {

    setProjectionForRotation0();

    expectStateForHardwareTransform180();

}



TEST_F(DisplayDeviceSetProjectionTest_Installed180, checkWith90OutputRotation) {

    setProjectionForRotation90();

    expectStateForHardwareTransform270();

}



TEST_F(DisplayDeviceSetProjectionTest_Installed180, checkWith180OutputRotation) {

    setProjectionForRotation180();

    expectStateForHardwareTransform0();

}



TEST_F(DisplayDeviceSetProjectionTest_Installed180, checkWith270OutputRotation) {

    setProjectionForRotation270();

    expectStateForHardwareTransform90();

}



struct DisplayDeviceSetProjectionTest_Installed270 : public DisplayDeviceSetProjectionTest {

    DisplayDeviceSetProjectionTest_Installed270()

          : DisplayDeviceSetProjectionTest(ui::Size(DEFAULT_DISPLAY_HEIGHT, DEFAULT_DISPLAY_WIDTH),

                                           ui::Size(DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT),

                                           ui::ROTATION_270) {}

};



TEST_F(DisplayDeviceSetProjectionTest_Installed270, checkWith0OutputRotation) {

    setProjectionForRotation0();

    expectStateForHardwareTransform270();

}



TEST_F(DisplayDeviceSetProjectionTest_Installed270, checkWith90OutputRotation) {

    setProjectionForRotation90();

    expectStateForHardwareTransform0();

}



TEST_F(DisplayDeviceSetProjectionTest_Installed270, checkWith180OutputRotation) {

    setProjectionForRotation180();

    expectStateForHardwareTransform90();

}



TEST_F(DisplayDeviceSetProjectionTest_Installed270, checkWith270OutputRotation) {

    setProjectionForRotation270();

    expectStateForHardwareTransform180();

}



} // namespace

} // namespace android