Migrate LayerTest to LayerSnapshotTests (384ba8aa) · Commits · e / os / android_frameworks_native

services/surfaceflinger/tests/unittests/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -94,7 +94,6 @@ cc_test {
		"LayerHierarchyTest.cpp",
		"LayerLifecycleManagerTest.cpp",
		"LayerSnapshotTest.cpp",
		"LayerTest.cpp",
		"LayerTestUtils.cpp",
		"MessageQueueTest.cpp",
		"PowerAdvisorTest.cpp",

services/surfaceflinger/tests/unittests/LayerSnapshotTest.cpp

+44 −0

Original line number	Diff line number	Diff line
		@@ -1539,4 +1539,48 @@ TEST_F(LayerSnapshotTest, doNotOverrideParentTrustedOverlayState) {
		gui::WindowInfo::InputConfig::TRUSTED_OVERLAY));
		}

		static constexpr const FloatRect LARGE_FLOAT_RECT{std::numeric_limits<float>::min(),
		std::numeric_limits<float>::min(),
		std::numeric_limits<float>::max(),
		std::numeric_limits<float>::max()};
		TEST_F(LayerSnapshotTest, layerVisibleByDefault) {
		DisplayInfo info;
		info.info.logicalHeight = 1000000;
		info.info.logicalWidth = 1000000;
		mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);
		UPDATE_AND_VERIFY(mSnapshotBuilder, STARTING_ZORDER);
		EXPECT_FALSE(getSnapshot(1)->isHiddenByPolicy());
		}

		TEST_F(LayerSnapshotTest, hideLayerWithZeroMatrix) {
		DisplayInfo info;
		info.info.logicalHeight = 1000000;
		info.info.logicalWidth = 1000000;
		mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);
		setMatrix(1, 0.f, 0.f, 0.f, 0.f);
		UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
		EXPECT_TRUE(getSnapshot(1)->isHiddenByPolicy());
		}

		TEST_F(LayerSnapshotTest, hideLayerWithInfMatrix) {
		DisplayInfo info;
		info.info.logicalHeight = 1000000;
		info.info.logicalWidth = 1000000;
		mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);
		setMatrix(1, std::numeric_limits<float>::infinity(), 0.f, 0.f,
		std::numeric_limits<float>::infinity());
		UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
		EXPECT_TRUE(getSnapshot(1)->isHiddenByPolicy());
		}

		TEST_F(LayerSnapshotTest, hideLayerWithNanMatrix) {
		DisplayInfo info;
		info.info.logicalHeight = 1000000;
		info.info.logicalWidth = 1000000;
		mFrontEndDisplayInfos.emplace_or_replace(ui::LayerStack::fromValue(1), info);
		setMatrix(1, std::numeric_limits<float>::quiet_NaN(), 0.f, 0.f,
		std::numeric_limits<float>::quiet_NaN());
		UPDATE_AND_VERIFY(mSnapshotBuilder, {2});
		EXPECT_TRUE(getSnapshot(1)->isHiddenByPolicy());
		}
		} // namespace android::surfaceflinger::frontend

services/surfaceflinger/tests/unittests/LayerTest.cpp

deleted100644 → 0

+0 −86

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