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

Commit 86fa3dbb authored by Lloyd Pique's avatar Lloyd Pique
Browse files

SF: Fixup call expectations in libsurfaceflinger_unittest 

This is done to eliminate a flood of warning messages about unexpected
calls when the test is run directly (not visible when run with atest)

Most of the warnings had to do with changes to the implementation to
query HWC capabilities when a display is connected, and other queries to set
up the framebuffer surface afterwards.

With these warnings gone, it is much easier to see other unexpected
calls that might actually be important.

Test: atest libsurfaceflinger_unittest
Bug: None
Change-Id: Ia386daa9dcbf9cfbcd3e12be3b63f6e05fdcfe5e
parent aa8756d2

services/surfaceflinger/tests/unittests/CompositionTest.cpp

+17 −5
Original line number Diff line number Diff line
@@ -95,6 +95,7 @@ public: 
        EXPECT_CALL(*mPrimaryDispSync, computeNextRefresh(0)).WillRepeatedly(Return(0));

        EXPECT_CALL(*mPrimaryDispSync, getPeriod())

                .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_REFRESH_RATE));

        EXPECT_CALL(*mPrimaryDispSync, expectedPresentTime()).WillRepeatedly(Return(0));

        EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))

                .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));

        EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))
@@ -238,16 +239,23 @@ struct BaseDisplayVariant { 
    static constexpr int INIT_POWER_MODE = HWC_POWER_MODE_NORMAL;



    static void setupPreconditions(CompositionTest* test) {

        EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))

                .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));

        EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))

                .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));

        EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY, _))

                .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::DisplayCapability>({})),

                                Return(Error::NONE)));



        FakeHwcDisplayInjector(DEFAULT_DISPLAY_ID, HWC2::DisplayType::Physical,

                               true /* isPrimary */)

                .setCapabilities(&test->mDefaultCapabilities)

                .inject(&test->mFlinger, test->mComposer);

        Mock::VerifyAndClear(test->mComposer);



        EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))

                .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_WIDTH), Return(0)));

        EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))

                .WillRepeatedly(DoAll(SetArgPointee<1>(DEFAULT_DISPLAY_HEIGHT), Return(0)));

        EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);

        EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);

        EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);

        test->mDisplay = FakeDisplayDeviceInjector(test->mFlinger, DEFAULT_DISPLAY_ID,

                                                   false /* isVirtual */, true /* isPrimary */)

                                 .setDisplaySurface(test->mDisplaySurface)
@@ -255,6 +263,7 @@ struct BaseDisplayVariant { 
                                 .setSecure(Derived::IS_SECURE)

                                 .setPowerMode(Derived::INIT_POWER_MODE)

                                 .inject();

        Mock::VerifyAndClear(test->mNativeWindow);

        test->mDisplay->setLayerStack(DEFAULT_LAYER_STACK);

    }
@@ -405,6 +414,8 @@ struct PoweredOffDisplaySetupVariant : public BaseDisplayVariant<PoweredOffDispl 


    template <typename Case>

    static void setupCommonCompositionCallExpectations(CompositionTest* test) {

        EXPECT_CALL(*test->mRenderEngine, useNativeFenceSync()).WillRepeatedly(Return(true));



        // TODO: This seems like an unnecessary call if display is powered off.

        EXPECT_CALL(*test->mComposer,

                    setColorTransform(HWC_DISPLAY, _, Hwc2::ColorTransform::IDENTITY))
@@ -417,6 +428,8 @@ struct PoweredOffDisplaySetupVariant : public BaseDisplayVariant<PoweredOffDispl 
    static void setupHwcCompositionCallExpectations(CompositionTest*) {}



    static void setupRECompositionCallExpectations(CompositionTest* test) {

        EXPECT_CALL(*test->mRenderEngine, useNativeFenceSync()).WillRepeatedly(Return(true));



        // TODO: This seems like an unnecessary call if display is powered off.

        EXPECT_CALL(*test->mDisplaySurface, getClientTargetAcquireFence())

                .WillRepeatedly(ReturnRef(test->mClientTargetAcquireFence));
@@ -575,7 +588,6 @@ struct BaseLayerProperties { 
                    setLayerColor(HWC_DISPLAY, HWC_LAYER,

                                  IComposerClient::Color({0xff, 0xff, 0xff, 0xff})))

                .Times(1);



    }



    static void setupHwcSetPerFrameBufferCallExpectations(CompositionTest* test) {

services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp

+53 −12
Original line number Diff line number Diff line
@@ -335,11 +335,17 @@ struct DisplayVariant { 
        injector.setNativeWindow(test->mNativeWindow);



        // Creating a DisplayDevice requires getting default dimensions from the

        // native window.

        // native window along with some other initial setup.

        EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_WIDTH, _))

                .WillRepeatedly(DoAll(SetArgPointee<1>(WIDTH), Return(0)));

        EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))

                .WillRepeatedly(DoAll(SetArgPointee<1>(HEIGHT), Return(0)));

        EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT))

                .WillRepeatedly(Return(0));

        EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT))

                .WillRepeatedly(Return(0));

        EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64))

                .WillRepeatedly(Return(0));

        return injector;

    }
@@ -352,6 +358,12 @@ struct DisplayVariant { 
                .WillRepeatedly(DoAll(SetArgPointee<1>(WIDTH), Return(0)));

        EXPECT_CALL(*test->mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))

                .WillRepeatedly(DoAll(SetArgPointee<1>(HEIGHT), Return(0)));

        EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT))

                .WillRepeatedly(Return(0));

        EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT))

                .WillRepeatedly(Return(0));

        EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64))

                .WillRepeatedly(Return(0));

    }



    static void setupFramebufferConsumerBufferQueueCallExpectations(DisplayTransactionTest* test) {
@@ -389,7 +401,7 @@ struct HwcDisplayVariant { 
    }



    // Called by tests to inject a HWC display setup

    static void injectHwcDisplay(DisplayTransactionTest* test) {

    static void injectHwcDisplayWithNoDefaultCapabilities(DisplayTransactionTest* test) {

        const auto displayId = DisplayVariant::DISPLAY_ID::get();

        ASSERT_TRUE(displayId);

        FakeHwcDisplayInjector(*displayId, HWC_DISPLAY_TYPE,
@@ -401,6 +413,14 @@ struct HwcDisplayVariant { 
                .inject(&test->mFlinger, test->mComposer);

    }



    // Called by tests to inject a HWC display setup

    static void injectHwcDisplay(DisplayTransactionTest* test) {

        EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY_ID, _))

                .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::DisplayCapability>({})),

                                Return(Error::NONE)));

        injectHwcDisplayWithNoDefaultCapabilities(test);

    }



    static void setupHwcHotplugCallExpectations(DisplayTransactionTest* test) {

        EXPECT_CALL(*test->mComposer, getDisplayType(HWC_DISPLAY_ID, _))

                .WillOnce(DoAll(SetArgPointee<1>(static_cast<IComposerClient::DisplayType>(
@@ -430,6 +450,9 @@ struct HwcDisplayVariant { 
                    getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID,

                                        IComposerClient::Attribute::DPI_Y, _))

                .WillOnce(DoAll(SetArgPointee<3>(DEFAULT_DPI), Return(Error::NONE)));

        EXPECT_CALL(*test->mComposer, getDisplayCapabilities(HWC_DISPLAY_ID, _))

                .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::DisplayCapability>({})),

                                Return(Error::NONE)));



        if (PhysicalDisplay::HAS_IDENTIFICATION_DATA) {

            EXPECT_CALL(*test->mComposer, getDisplayIdentificationData(HWC_DISPLAY_ID, _, _))
@@ -482,6 +505,8 @@ struct ExternalDisplay { 


struct TertiaryDisplay {

    static constexpr Primary PRIMARY = Primary::FALSE;

    static constexpr uint8_t PORT = 253;

    static constexpr auto GET_IDENTIFICATION_DATA = getExternalEdid;

};



// A primary display is a physical display that is critical
@@ -577,6 +602,8 @@ struct WideColorP3ColorimetricSupportedVariant { 
    }



    static void setupComposerCallExpectations(DisplayTransactionTest* test) {

        EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_DATASPACE)).Times(1);



        EXPECT_CALL(*test->mComposer, getColorModes(Display::HWC_DISPLAY_ID, _))

                .WillOnce(DoAll(SetArgPointee<1>(std::vector<ColorMode>({ColorMode::DISPLAY_P3})),

                                Return(Error::NONE)));
@@ -1156,9 +1183,9 @@ public: 
                .WillRepeatedly(DoAll(SetArgPointee<1>(1080 /* arbitrary */), Return(0)));

        EXPECT_CALL(*mNativeWindow, query(NATIVE_WINDOW_HEIGHT, _))

                .WillRepeatedly(DoAll(SetArgPointee<1>(1920 /* arbitrary */), Return(0)));

        EXPECT_CALL(*mNativeWindow, perform(9)).Times(1);

        EXPECT_CALL(*mNativeWindow, perform(13)).Times(1);

        EXPECT_CALL(*mNativeWindow, perform(30)).Times(1);

        EXPECT_CALL(*mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);

        EXPECT_CALL(*mNativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);

        EXPECT_CALL(*mNativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);

        auto displayDevice = mInjector.inject();



        displayDevice->getCompositionDisplay()
@@ -1705,6 +1732,13 @@ TEST_F(HandleTransactionLockedTest, ignoresHotplugConnectIfPrimaryAndExternalAlr 
    PrimaryDisplayVariant::injectHwcDisplay(this);

    ExternalDisplayVariant::injectHwcDisplay(this);



    // TODO: This is an unnecessary call.

    EXPECT_CALL(*mComposer,

                getDisplayIdentificationData(TertiaryDisplayVariant::HWC_DISPLAY_ID, _, _))

            .WillOnce(DoAll(SetArgPointee<1>(TertiaryDisplay::PORT),

                            SetArgPointee<2>(TertiaryDisplay::GET_IDENTIFICATION_DATA()),

                            Return(Error::NONE)));



    EXPECT_CALL(*mComposer, isUsingVrComposer()).WillRepeatedly(Return(false));



    ignoresHotplugConnectCommon<SimpleTertiaryDisplayCase>();
@@ -1852,6 +1886,10 @@ TEST_F(HandleTransactionLockedTest, processesVirtualDisplayAdded) { 
    Case::Display::setupFramebufferConsumerBufferQueueCallExpectations(this);

    Case::Display::setupNativeWindowSurfaceCreationCallExpectations(this);



    EXPECT_CALL(*mComposer, getDisplayCapabilities(Case::Display::HWC_DISPLAY_ID, _))

            .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hwc2::DisplayCapability>({})),

                            Return(Error::NONE)));



    EXPECT_CALL(*surface, query(NATIVE_WINDOW_WIDTH, _))

            .WillRepeatedly(DoAll(SetArgPointee<1>(Case::Display::WIDTH), Return(NO_ERROR)));

    EXPECT_CALL(*surface, query(NATIVE_WINDOW_HEIGHT, _))
@@ -1864,6 +1902,7 @@ TEST_F(HandleTransactionLockedTest, processesVirtualDisplayAdded) { 


    EXPECT_CALL(*surface, setAsyncMode(true)).Times(1);



    EXPECT_CALL(*mProducer, connect(_, NATIVE_WINDOW_API_EGL, false, _)).Times(1);

    EXPECT_CALL(*mProducer, disconnect(_, _)).Times(1);



    Case::Display::setupHwcVirtualDisplayCreationCallExpectations(this);
@@ -2096,9 +2135,9 @@ TEST_F(HandleTransactionLockedTest, processesDisplayWidthChanges) { 
            .WillOnce(DoAll(SetArgPointee<1>(oldWidth), Return(0)));

    EXPECT_CALL(*nativeWindow, query(NATIVE_WINDOW_HEIGHT, _))

            .WillOnce(DoAll(SetArgPointee<1>(oldHeight), Return(0)));

    EXPECT_CALL(*nativeWindow, perform(9)).Times(1);

    EXPECT_CALL(*nativeWindow, perform(13)).Times(1);

    EXPECT_CALL(*nativeWindow, perform(30)).Times(1);

    EXPECT_CALL(*nativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);

    EXPECT_CALL(*nativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);

    EXPECT_CALL(*nativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);

    display.inject();



    // There is a change to the viewport state
@@ -2140,9 +2179,9 @@ TEST_F(HandleTransactionLockedTest, processesDisplayHeightChanges) { 
            .WillOnce(DoAll(SetArgPointee<1>(oldWidth), Return(0)));

    EXPECT_CALL(*nativeWindow, query(NATIVE_WINDOW_HEIGHT, _))

            .WillOnce(DoAll(SetArgPointee<1>(oldHeight), Return(0)));

    EXPECT_CALL(*nativeWindow, perform(9)).Times(1);

    EXPECT_CALL(*nativeWindow, perform(13)).Times(1);

    EXPECT_CALL(*nativeWindow, perform(30)).Times(1);

    EXPECT_CALL(*nativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_FORMAT)).Times(1);

    EXPECT_CALL(*nativeWindow, perform(NATIVE_WINDOW_API_CONNECT)).Times(1);

    EXPECT_CALL(*nativeWindow, perform(NATIVE_WINDOW_SET_USAGE64)).Times(1);

    display.inject();



    // There is a change to the viewport state
@@ -2656,6 +2695,8 @@ TEST_F(DisplayTransactionTest, onInitializeDisplaysSetsUpPrimaryDisplay) { 
    // processing.

    EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);



    EXPECT_CALL(*mPrimaryDispSync, expectedPresentTime()).WillRepeatedly(Return(0));



    // --------------------------------------------------------------------

    // Invocation
@@ -2950,7 +2991,7 @@ struct DisplayPowerCase { 
    using Transition = TransitionVariant;



    static auto injectDisplayWithInitialPowerMode(DisplayTransactionTest* test, int mode) {

        Display::injectHwcDisplay(test);

        Display::injectHwcDisplayWithNoDefaultCapabilities(test);

        auto display = Display::makeFakeExistingDisplayInjector(test);

        display.inject();

        display.mutableDisplayDevice()->setPowerMode(mode);