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

Commit 2320289f authored by Garfield Tan's avatar Garfield Tan
Browse files

Add unit tests for invalid transfomations in Layer 

This CL extracts common set up logic for layer related tests to another
file so that it can be shared among tests.

Bug: 210837722
Test: atest libsurfaceflinger_unittest
Change-Id: I9fb08ad164d57369f503a35eca907393b1969547
parent 2c1782c6

services/surfaceflinger/tests/unittests/Android.bp

+2 −0
Original line number Diff line number Diff line
@@ -89,6 +89,8 @@ cc_test { 
        "LayerHistoryTest.cpp",

        "LayerInfoTest.cpp",

        "LayerMetadataTest.cpp",

        "LayerTest.cpp",

        "LayerTestUtils.cpp",

        "MessageQueueTest.cpp",

        "SurfaceFlinger_CreateDisplayTest.cpp",

        "SurfaceFlinger_DestroyDisplayTest.cpp",

services/surfaceflinger/tests/unittests/LayerTest.cpp

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

 * Copyright (C) 2022 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 <EffectLayer.h>

#include <gtest/gtest.h>

#include <ui/FloatRect.h>

#include <ui/Transform.h>

#include <limits>



#include "LayerTestUtils.h"

#include "TestableSurfaceFlinger.h"



namespace android {

namespace {



class LayerTest : public BaseLayerTest {

protected:

    static constexpr const float MIN_FLOAT = std::numeric_limits<float>::min();

    static constexpr const float MAX_FLOAT = std::numeric_limits<float>::max();

    static constexpr const FloatRect LARGE_FLOAT_RECT{MIN_FLOAT, MIN_FLOAT, MAX_FLOAT, MAX_FLOAT};

};



INSTANTIATE_TEST_SUITE_P(PerLayerType, LayerTest,

                         testing::Values(std::make_shared<BufferStateLayerFactory>(),

                                         std::make_shared<EffectLayerFactory>()),

                         PrintToStringParamName);



TEST_P(LayerTest, layerVisibleByDefault) {

    sp<Layer> layer = GetParam()->createLayer(mFlinger);

    layer->updateGeometry();

    layer->computeBounds(LARGE_FLOAT_RECT, ui::Transform(), 0.f);

    ASSERT_FALSE(layer->isHiddenByPolicy());

}



TEST_P(LayerTest, hideLayerWithZeroMatrix) {

    sp<Layer> layer = GetParam()->createLayer(mFlinger);



    layer_state_t::matrix22_t matrix{0, 0, 0, 0};

    layer->setMatrix(matrix);

    layer->updateGeometry();

    layer->computeBounds(LARGE_FLOAT_RECT, ui::Transform(), 0.f);



    ASSERT_TRUE(layer->isHiddenByPolicy());

}



TEST_P(LayerTest, hideLayerWithInfMatrix) {

    sp<Layer> layer = GetParam()->createLayer(mFlinger);



    constexpr const float INF = std::numeric_limits<float>::infinity();

    layer_state_t::matrix22_t matrix{INF, 0, 0, INF};

    layer->setMatrix(matrix);

    layer->updateGeometry();

    layer->computeBounds(LARGE_FLOAT_RECT, ui::Transform(), 0.f);



    ASSERT_TRUE(layer->isHiddenByPolicy());

}



TEST_P(LayerTest, hideLayerWithNanMatrix) {

    sp<Layer> layer = GetParam()->createLayer(mFlinger);



    constexpr const float QUIET_NAN = std::numeric_limits<float>::quiet_NaN();

    layer_state_t::matrix22_t matrix{QUIET_NAN, 0, 0, QUIET_NAN};

    layer->setMatrix(matrix);

    layer->updateGeometry();

    layer->computeBounds(LARGE_FLOAT_RECT, ui::Transform(), 0.f);



    ASSERT_TRUE(layer->isHiddenByPolicy());

}



} // namespace

} // namespace android

services/surfaceflinger/tests/unittests/LayerTestUtils.cpp

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

 * Copyright (C) 2022 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.

 */



#include "LayerTestUtils.h"



#include "mock/MockEventThread.h"



namespace android {



using testing::_;

using testing::Return;



using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;



sp<Layer> BufferStateLayerFactory::createLayer(TestableSurfaceFlinger& flinger) {

    sp<Client> client;

    LayerCreationArgs args(flinger.flinger(), client, "buffer-state-layer", LAYER_FLAGS,

                           LayerMetadata());

    return new BufferStateLayer(args);

}



sp<Layer> EffectLayerFactory::createLayer(TestableSurfaceFlinger& flinger) {

    sp<Client> client;

    LayerCreationArgs args(flinger.flinger(), client, "color-layer", LAYER_FLAGS, LayerMetadata());

    return new EffectLayer(args);

}



std::string PrintToStringParamName(

        const ::testing::TestParamInfo<std::shared_ptr<LayerFactory>>& info) {

    return info.param->name();

}



BaseLayerTest::BaseLayerTest() {

    setupScheduler();

}



void BaseLayerTest::setupScheduler() {

    auto eventThread = std::make_unique<mock::EventThread>();

    auto sfEventThread = std::make_unique<mock::EventThread>();



    EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));

    EXPECT_CALL(*eventThread, createEventConnection(_, _))

            .WillOnce(Return(new EventThreadConnection(eventThread.get(), /*callingUid=*/0,

                                                       ResyncCallback())));



    EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));

    EXPECT_CALL(*sfEventThread, createEventConnection(_, _))

            .WillOnce(Return(new EventThreadConnection(sfEventThread.get(), /*callingUid=*/0,

                                                       ResyncCallback())));



    auto vsyncController = std::make_unique<mock::VsyncController>();

    auto vsyncTracker = std::make_unique<mock::VSyncTracker>();



    EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));

    EXPECT_CALL(*vsyncTracker, currentPeriod())

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

    EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));

    mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),

                            std::move(eventThread), std::move(sfEventThread),

                            TestableSurfaceFlinger::SchedulerCallbackImpl::kNoOp,

                            TestableSurfaceFlinger::kTwoDisplayModes);

}



} // namespace android

services/surfaceflinger/tests/unittests/LayerTestUtils.h

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

 * Copyright (C) 2022 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.

 */



#pragma once



#include <memory>



#include <gtest/gtest.h>



// TODO(b/129481165): remove the #pragma below and fix conversion issues

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wconversion"

#include "BufferStateLayer.h"

#include "EffectLayer.h"

#include "Layer.h"

// TODO(b/129481165): remove the #pragma below and fix conversion issues

#pragma clang diagnostic pop // ignored "-Wconversion"



#include "TestableSurfaceFlinger.h"



namespace android {



class LayerFactory {

public:

    virtual ~LayerFactory() = default;



    virtual std::string name() = 0;

    virtual sp<Layer> createLayer(TestableSurfaceFlinger& flinger) = 0;



protected:

    static constexpr uint32_t WIDTH = 100;

    static constexpr uint32_t HEIGHT = 100;

    static constexpr uint32_t LAYER_FLAGS = 0;

};



class BufferStateLayerFactory : public LayerFactory {

public:

    std::string name() override { return "BufferStateLayer"; }

    sp<Layer> createLayer(TestableSurfaceFlinger& flinger) override;

};



class EffectLayerFactory : public LayerFactory {

public:

    std::string name() override { return "EffectLayer"; }

    sp<Layer> createLayer(TestableSurfaceFlinger& flinger) override;

};



std::string PrintToStringParamName(

        const ::testing::TestParamInfo<std::shared_ptr<LayerFactory>>& info);



class BaseLayerTest : public ::testing::TestWithParam<std::shared_ptr<LayerFactory>> {

protected:

    BaseLayerTest();



    void setupScheduler();



    TestableSurfaceFlinger mFlinger;

};



} // namespace android

services/surfaceflinger/tests/unittests/SetFrameRateTest.cpp

+2 −79
Original line number Diff line number Diff line
@@ -30,73 +30,29 @@ 
// TODO(b/129481165): remove the #pragma below and fix conversion issues

#pragma clang diagnostic pop // ignored "-Wconversion"

#include "FpsOps.h"

#include "LayerTestUtils.h"

#include "TestableSurfaceFlinger.h"

#include "mock/DisplayHardware/MockComposer.h"

#include "mock/MockEventThread.h"

#include "mock/MockVsyncController.h"



namespace android {



using testing::_;

using testing::DoAll;

using testing::Mock;

using testing::Return;

using testing::SetArgPointee;



using android::Hwc2::IComposer;

using android::Hwc2::IComposerClient;



using FakeHwcDisplayInjector = TestableSurfaceFlinger::FakeHwcDisplayInjector;



using scheduler::LayerHistory;



using FrameRate = Layer::FrameRate;

using FrameRateCompatibility = Layer::FrameRateCompatibility;



class LayerFactory {

public:

    virtual ~LayerFactory() = default;



    virtual std::string name() = 0;

    virtual sp<Layer> createLayer(TestableSurfaceFlinger& flinger) = 0;



protected:

    static constexpr uint32_t WIDTH = 100;

    static constexpr uint32_t HEIGHT = 100;

    static constexpr uint32_t LAYER_FLAGS = 0;

};



class BufferStateLayerFactory : public LayerFactory {

public:

    std::string name() override { return "BufferStateLayer"; }

    sp<Layer> createLayer(TestableSurfaceFlinger& flinger) override {

        sp<Client> client;

        LayerCreationArgs args(flinger.flinger(), client, "buffer-state-layer", LAYER_FLAGS,

                               LayerMetadata());

        return new BufferStateLayer(args);

    }

};



class EffectLayerFactory : public LayerFactory {

public:

    std::string name() override { return "EffectLayer"; }

    sp<Layer> createLayer(TestableSurfaceFlinger& flinger) override {

        sp<Client> client;

        LayerCreationArgs args(flinger.flinger(), client, "color-layer", LAYER_FLAGS,

                               LayerMetadata());

        return new EffectLayer(args);

    }

};



std::string PrintToStringParamName(

        const ::testing::TestParamInfo<std::shared_ptr<LayerFactory>>& info) {

    return info.param->name();

}



/**

 * This class tests the behaviour of Layer::SetFrameRate and Layer::GetFrameRate

 */

class SetFrameRateTest : public ::testing::TestWithParam<std::shared_ptr<LayerFactory>> {

class SetFrameRateTest : public BaseLayerTest {

protected:

    const FrameRate FRAME_RATE_VOTE1 = FrameRate(67_Hz, FrameRateCompatibility::Default);

    const FrameRate FRAME_RATE_VOTE2 = FrameRate(14_Hz, FrameRateCompatibility::ExactOrMultiple);
@@ -106,14 +62,10 @@ protected: 


    SetFrameRateTest();



    void setupScheduler();



    void addChild(sp<Layer> layer, sp<Layer> child);

    void removeChild(sp<Layer> layer, sp<Layer> child);

    void commitTransaction();



    TestableSurfaceFlinger mFlinger;



    std::vector<sp<Layer>> mLayers;

};
@@ -122,8 +74,6 @@ SetFrameRateTest::SetFrameRateTest() { 
            ::testing::UnitTest::GetInstance()->current_test_info();

    ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());



    setupScheduler();



    mFlinger.setupComposer(std::make_unique<Hwc2::mock::Composer>());

}
@@ -142,33 +92,6 @@ void SetFrameRateTest::commitTransaction() { 
    }

}



void SetFrameRateTest::setupScheduler() {

    auto eventThread = std::make_unique<mock::EventThread>();

    auto sfEventThread = std::make_unique<mock::EventThread>();



    EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));

    EXPECT_CALL(*eventThread, createEventConnection(_, _))

            .WillOnce(Return(new EventThreadConnection(eventThread.get(), /*callingUid=*/0,

                                                       ResyncCallback())));



    EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));

    EXPECT_CALL(*sfEventThread, createEventConnection(_, _))

            .WillOnce(Return(new EventThreadConnection(sfEventThread.get(), /*callingUid=*/0,

                                                       ResyncCallback())));



    auto vsyncController = std::make_unique<mock::VsyncController>();

    auto vsyncTracker = std::make_unique<mock::VSyncTracker>();



    EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));

    EXPECT_CALL(*vsyncTracker, currentPeriod())

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

    EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillRepeatedly(Return(0));

    mFlinger.setupScheduler(std::move(vsyncController), std::move(vsyncTracker),

                            std::move(eventThread), std::move(sfEventThread),

                            TestableSurfaceFlinger::SchedulerCallbackImpl::kNoOp,

                            TestableSurfaceFlinger::kTwoDisplayModes);

}



namespace {



TEST_P(SetFrameRateTest, SetAndGet) {