Merge "Add unit tests for invalid transfomations in Layer" into tm-dev (fda021c4) · Commits · e / os / android_frameworks_native

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) {