services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp - android_frameworks_native - Gitiles

 /*
  * Copyright 2019 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 <compositionengine/impl/OutputLayer.h>
 #include <compositionengine/mock/CompositionEngine.h>
 #include <compositionengine/mock/Layer.h>
 #include <compositionengine/mock/LayerFE.h>
 #include <compositionengine/mock/Output.h>
 #include <gtest/gtest.h>

 #include "MockHWC2.h"
 #include "MockHWComposer.h"
 #include "RectMatcher.h"

 namespace android::compositionengine {
 namespace {

 using testing::_;
 using testing::Return;
 using testing::ReturnRef;
 using testing::StrictMock;

 constexpr DisplayId DEFAULT_DISPLAY_ID = DisplayId{42};

 constexpr auto TR_IDENT = 0u;
 constexpr auto TR_FLP_H = HAL_TRANSFORM_FLIP_H;
 constexpr auto TR_FLP_V = HAL_TRANSFORM_FLIP_V;
 constexpr auto TR_ROT_90 = HAL_TRANSFORM_ROT_90;
 constexpr auto TR_ROT_180 = TR_FLP_H | TR_FLP_V;
 constexpr auto TR_ROT_270 = TR_ROT_90 | TR_ROT_180;

 const std::string kOutputName{"Test Output"};

 class OutputLayerTest : public testing::Test {
 public:
     OutputLayerTest() {
         EXPECT_CALL(*mLayerFE, getDebugName()).WillRepeatedly(Return("Test LayerFE"));
         EXPECT_CALL(mOutput, getName()).WillRepeatedly(ReturnRef(kOutputName));

         EXPECT_CALL(*mLayer, getState()).WillRepeatedly(ReturnRef(mLayerState));
         EXPECT_CALL(mOutput, getState()).WillRepeatedly(ReturnRef(mOutputState));
     }

     ~OutputLayerTest() override = default;

     compositionengine::mock::Output mOutput;
     std::shared_ptr<compositionengine::mock::Layer> mLayer{
             new StrictMock<compositionengine::mock::Layer>()};
     sp<compositionengine::mock::LayerFE> mLayerFE{
             new StrictMock<compositionengine::mock::LayerFE>()};
     impl::OutputLayer mOutputLayer{mOutput, mLayer, mLayerFE};

     impl::LayerCompositionState mLayerState;
     impl::OutputCompositionState mOutputState;
 };

 /*
  * Basic construction
  */

 TEST_F(OutputLayerTest, canInstantiateOutputLayer) {}

 /*
  * OutputLayer::initialize()
  */

 TEST_F(OutputLayerTest, initializingOutputLayerWithoutHwcDoesNothingInteresting) {
     StrictMock<compositionengine::mock::CompositionEngine> compositionEngine;

     mOutputLayer.initialize(compositionEngine, std::nullopt);

     EXPECT_FALSE(mOutputLayer.getState().hwc);
 }

 TEST_F(OutputLayerTest, initializingOutputLayerWithHwcDisplayCreatesHwcLayer) {
     StrictMock<compositionengine::mock::CompositionEngine> compositionEngine;
     StrictMock<android::mock::HWComposer> hwc;
     StrictMock<HWC2::mock::Layer> hwcLayer;

     EXPECT_CALL(compositionEngine, getHwComposer()).WillOnce(ReturnRef(hwc));
     EXPECT_CALL(hwc, createLayer(DEFAULT_DISPLAY_ID)).WillOnce(Return(&hwcLayer));

     mOutputLayer.initialize(compositionEngine, DEFAULT_DISPLAY_ID);

     const auto& outputLayerState = mOutputLayer.getState();
     ASSERT_TRUE(outputLayerState.hwc);

     const auto& hwcState = *outputLayerState.hwc;
     EXPECT_EQ(&hwcLayer, hwcState.hwcLayer.get());

     EXPECT_CALL(hwc, destroyLayer(DEFAULT_DISPLAY_ID, &hwcLayer));
     mOutputLayer.editState().hwc.reset();
 }

 /*
  * OutputLayer::calculateOutputDisplayFrame()
  */

 struct OutputLayerDisplayFrameTest : public OutputLayerTest {
     OutputLayerDisplayFrameTest() {
         // Set reasonable default values for a simple case. Each test will
         // set one specific value to something different.

         mLayerState.frontEnd.geomActiveTransparentRegion = Region{};
         mLayerState.frontEnd.geomLayerTransform = ui::Transform{TR_IDENT};
         mLayerState.frontEnd.geomBufferSize = Rect{0, 0, 1920, 1080};
         mLayerState.frontEnd.geomBufferUsesDisplayInverseTransform = false;
         mLayerState.frontEnd.geomCrop = Rect{0, 0, 1920, 1080};
         mLayerState.frontEnd.geomLayerBounds = FloatRect{0.f, 0.f, 1920.f, 1080.f};

         mOutputState.viewport = Rect{0, 0, 1920, 1080};
         mOutputState.transform = ui::Transform{TR_IDENT};
     }

     Rect calculateOutputDisplayFrame() {
         mLayerState.frontEnd.geomInverseLayerTransform =
                 mLayerState.frontEnd.geomLayerTransform.inverse();

         return mOutputLayer.calculateOutputDisplayFrame();
     }
 };

 TEST_F(OutputLayerDisplayFrameTest, correctForSimpleDefaultCase) {
     const Rect expected{0, 0, 1920, 1080};
     EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
 }

 TEST_F(OutputLayerDisplayFrameTest, fullActiveTransparentRegionReturnsEmptyFrame) {
     mLayerState.frontEnd.geomActiveTransparentRegion = Region{Rect{0, 0, 1920, 1080}};
     const Rect expected{0, 0, 0, 0};
     EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
 }

 TEST_F(OutputLayerDisplayFrameTest, cropAffectsDisplayFrame) {
     mLayerState.frontEnd.geomCrop = Rect{100, 200, 300, 500};
     const Rect expected{100, 200, 300, 500};
     EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
 }

 TEST_F(OutputLayerDisplayFrameTest, cropAffectsDisplayFrameRotated) {
     mLayerState.frontEnd.geomCrop = Rect{100, 200, 300, 500};
     mLayerState.frontEnd.geomLayerTransform.set(HAL_TRANSFORM_ROT_90, 1920, 1080);
     const Rect expected{1420, 100, 1720, 300};
     EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
 }

 TEST_F(OutputLayerDisplayFrameTest, emptyGeomCropIsNotUsedToComputeFrame) {
     mLayerState.frontEnd.geomCrop = Rect{};
     const Rect expected{0, 0, 1920, 1080};
     EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
 }

 TEST_F(OutputLayerDisplayFrameTest, geomLayerSnapToBoundsAffectsFrame) {
     mLayerState.frontEnd.geomLayerBounds = FloatRect{0.f, 0.f, 960.f, 540.f};
     const Rect expected{0, 0, 960, 540};
     EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
 }

 TEST_F(OutputLayerDisplayFrameTest, viewportAffectsFrame) {
     mOutputState.viewport = Rect{0, 0, 960, 540};
     const Rect expected{0, 0, 960, 540};
     EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
 }

 TEST_F(OutputLayerDisplayFrameTest, outputTransformAffectsDisplayFrame) {
     mOutputState.transform = ui::Transform{HAL_TRANSFORM_ROT_90};
     const Rect expected{-1080, 0, 0, 1920};
     EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
 }

 /*
  * OutputLayer::calculateOutputRelativeBufferTransform()
  */

 TEST_F(OutputLayerTest, calculateOutputRelativeBufferTransformTestsNeeded) {
     mLayerState.frontEnd.geomBufferUsesDisplayInverseTransform = false;

     struct Entry {
         uint32_t layer;
         uint32_t buffer;
         uint32_t display;
         uint32_t expected;
     };
     // Not an exhaustive list of cases, but hopefully enough.
     const std::array<Entry, 24> testData = {
             // clang-format off
             //             layer       buffer      display     expected
             /*  0 */ Entry{TR_IDENT,   TR_IDENT,   TR_IDENT,   TR_IDENT},
             /*  1 */ Entry{TR_IDENT,   TR_IDENT,   TR_ROT_90,  TR_ROT_90},
             /*  2 */ Entry{TR_IDENT,   TR_IDENT,   TR_ROT_180, TR_ROT_180},
             /*  3 */ Entry{TR_IDENT,   TR_IDENT,   TR_ROT_270, TR_ROT_270},

             /*  4 */ Entry{TR_IDENT,   TR_FLP_H,   TR_IDENT,   TR_FLP_H ^ TR_IDENT},
             /*  5 */ Entry{TR_IDENT,   TR_FLP_H,   TR_ROT_90,  TR_FLP_H ^ TR_ROT_90},
             /*  6 */ Entry{TR_IDENT,   TR_FLP_H,   TR_ROT_180, TR_FLP_H ^ TR_ROT_180},
             /*  7 */ Entry{TR_IDENT,   TR_FLP_H,   TR_ROT_270, TR_FLP_H ^ TR_ROT_270},

             /*  8 */ Entry{TR_IDENT,   TR_FLP_V,   TR_IDENT,   TR_FLP_V},
             /*  9 */ Entry{TR_IDENT,   TR_ROT_90,  TR_ROT_90,  TR_ROT_180},
             /* 10 */ Entry{TR_IDENT,   TR_ROT_180, TR_ROT_180, TR_IDENT},
             /* 11 */ Entry{TR_IDENT,   TR_ROT_270, TR_ROT_270, TR_ROT_180},

             /* 12 */ Entry{TR_ROT_90,  TR_IDENT,   TR_IDENT,   TR_IDENT ^ TR_ROT_90},
             /* 13 */ Entry{TR_ROT_90,  TR_FLP_H,   TR_ROT_90,  TR_FLP_H ^ TR_ROT_180},
             /* 14 */ Entry{TR_ROT_90,  TR_IDENT,   TR_ROT_180, TR_IDENT ^ TR_ROT_270},
             /* 15 */ Entry{TR_ROT_90,  TR_FLP_H,   TR_ROT_270, TR_FLP_H ^ TR_IDENT},

             /* 16 */ Entry{TR_ROT_180, TR_FLP_H,   TR_IDENT,   TR_FLP_H ^ TR_ROT_180},
             /* 17 */ Entry{TR_ROT_180, TR_IDENT,   TR_ROT_90,  TR_IDENT ^ TR_ROT_270},
             /* 18 */ Entry{TR_ROT_180, TR_FLP_H,   TR_ROT_180, TR_FLP_H ^ TR_IDENT},
             /* 19 */ Entry{TR_ROT_180, TR_IDENT,   TR_ROT_270, TR_IDENT ^ TR_ROT_90},

             /* 20 */ Entry{TR_ROT_270, TR_IDENT,   TR_IDENT,   TR_IDENT ^ TR_ROT_270},
             /* 21 */ Entry{TR_ROT_270, TR_FLP_H,   TR_ROT_90,  TR_FLP_H ^ TR_IDENT},
             /* 22 */ Entry{TR_ROT_270, TR_FLP_H,   TR_ROT_180, TR_FLP_H ^ TR_ROT_90},
             /* 23 */ Entry{TR_ROT_270, TR_IDENT,   TR_ROT_270, TR_IDENT ^ TR_ROT_180},
             // clang-format on
     };

     for (size_t i = 0; i < testData.size(); i++) {
         const auto& entry = testData[i];

         mLayerState.frontEnd.geomLayerTransform.set(entry.layer, 1920, 1080);
         mLayerState.frontEnd.geomBufferTransform = entry.buffer;
         mOutputState.orientation = entry.display;

         auto actual = mOutputLayer.calculateOutputRelativeBufferTransform();
         EXPECT_EQ(entry.expected, actual) << "entry " << i;
     }
 }

 /*
  * OutputLayer::writeStateToHWC()
  */

 struct OutputLayerWriteStateToHWCTest : public OutputLayerTest {
     static constexpr HWC2::Error kError = HWC2::Error::Unsupported;
     static constexpr FloatRect kSourceCrop{11.f, 12.f, 13.f, 14.f};
     static constexpr uint32_t kZOrder = 21u;
     static constexpr Hwc2::Transform kBufferTransform = static_cast<Hwc2::Transform>(31);
     static constexpr Hwc2::IComposerClient::BlendMode kBlendMode =
             static_cast<Hwc2::IComposerClient::BlendMode>(41);
     static constexpr float kAlpha = 51.f;
     static constexpr uint32_t kType = 61u;
     static constexpr uint32_t kAppId = 62u;

     static const Rect kDisplayFrame;

     OutputLayerWriteStateToHWCTest() {
         auto& outputLayerState = mOutputLayer.editState();
         outputLayerState.hwc = impl::OutputLayerCompositionState::Hwc(mHwcLayer);

         outputLayerState.displayFrame = kDisplayFrame;
         outputLayerState.sourceCrop = kSourceCrop;
         outputLayerState.z = kZOrder;
         outputLayerState.bufferTransform = static_cast<Hwc2::Transform>(kBufferTransform);

         mLayerState.frontEnd.blendMode = kBlendMode;
         mLayerState.frontEnd.alpha = kAlpha;
         mLayerState.frontEnd.type = kType;
         mLayerState.frontEnd.appId = kAppId;
     }

     void expectGeometryCommonCalls() {
         EXPECT_CALL(*mHwcLayer, setDisplayFrame(kDisplayFrame)).WillOnce(Return(kError));
         EXPECT_CALL(*mHwcLayer, setSourceCrop(kSourceCrop)).WillOnce(Return(kError));
         EXPECT_CALL(*mHwcLayer, setZOrder(kZOrder)).WillOnce(Return(kError));
         EXPECT_CALL(*mHwcLayer, setTransform(static_cast<HWC2::Transform>(kBufferTransform)))
                 .WillOnce(Return(kError));

         EXPECT_CALL(*mHwcLayer, setBlendMode(static_cast<HWC2::BlendMode>(kBlendMode)))
                 .WillOnce(Return(kError));
         EXPECT_CALL(*mHwcLayer, setPlaneAlpha(kAlpha)).WillOnce(Return(kError));
         EXPECT_CALL(*mHwcLayer, setInfo(kType, kAppId)).WillOnce(Return(kError));
     }

     std::shared_ptr<HWC2::mock::Layer> mHwcLayer{std::make_shared<StrictMock<HWC2::mock::Layer>>()};
 };

 const Rect OutputLayerWriteStateToHWCTest::kDisplayFrame{1001, 1002, 1003, 10044};

 TEST_F(OutputLayerWriteStateToHWCTest, doesNothingIfNoHWCState) {
     mOutputLayer.editState().hwc.reset();

     mOutputLayer.writeStateToHWC(true);
 }

 TEST_F(OutputLayerWriteStateToHWCTest, doesNothingIfNoHWCLayer) {
     mOutputLayer.editState().hwc = impl::OutputLayerCompositionState::Hwc(nullptr);

     mOutputLayer.writeStateToHWC(true);
 }

 TEST_F(OutputLayerWriteStateToHWCTest, canSetsAllState) {
     expectGeometryCommonCalls();

     mOutputLayer.writeStateToHWC(true);
 }

 } // namespace
 } // namespace android::compositionengine
	/*
	* Copyright 2019 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 <compositionengine/impl/OutputLayer.h>
	#include <compositionengine/mock/CompositionEngine.h>
	#include <compositionengine/mock/Layer.h>
	#include <compositionengine/mock/LayerFE.h>
	#include <compositionengine/mock/Output.h>
	#include <gtest/gtest.h>

	#include "MockHWC2.h"
	#include "MockHWComposer.h"
	#include "RectMatcher.h"

	namespace android::compositionengine {
	namespace {

	using testing::_;
	using testing::Return;
	using testing::ReturnRef;
	using testing::StrictMock;

	constexpr DisplayId DEFAULT_DISPLAY_ID = DisplayId{42};

	constexpr auto TR_IDENT = 0u;
	constexpr auto TR_FLP_H = HAL_TRANSFORM_FLIP_H;
	constexpr auto TR_FLP_V = HAL_TRANSFORM_FLIP_V;
	constexpr auto TR_ROT_90 = HAL_TRANSFORM_ROT_90;
	constexpr auto TR_ROT_180 = TR_FLP_H \| TR_FLP_V;
	constexpr auto TR_ROT_270 = TR_ROT_90 \| TR_ROT_180;

	const std::string kOutputName{"Test Output"};

	class OutputLayerTest : public testing::Test {
	public:
	OutputLayerTest() {
	EXPECT_CALL(*mLayerFE, getDebugName()).WillRepeatedly(Return("Test LayerFE"));
	EXPECT_CALL(mOutput, getName()).WillRepeatedly(ReturnRef(kOutputName));

	EXPECT_CALL(*mLayer, getState()).WillRepeatedly(ReturnRef(mLayerState));
	EXPECT_CALL(mOutput, getState()).WillRepeatedly(ReturnRef(mOutputState));
	}

	~OutputLayerTest() override = default;

	compositionengine::mock::Output mOutput;
	std::shared_ptr<compositionengine::mock::Layer> mLayer{
	new StrictMock<compositionengine::mock::Layer>()};
	sp<compositionengine::mock::LayerFE> mLayerFE{
	new StrictMock<compositionengine::mock::LayerFE>()};
	impl::OutputLayer mOutputLayer{mOutput, mLayer, mLayerFE};

	impl::LayerCompositionState mLayerState;
	impl::OutputCompositionState mOutputState;
	};

	/*
	* Basic construction
	*/

	TEST_F(OutputLayerTest, canInstantiateOutputLayer) {}

	/*
	* OutputLayer::initialize()
	*/

	TEST_F(OutputLayerTest, initializingOutputLayerWithoutHwcDoesNothingInteresting) {
	StrictMock<compositionengine::mock::CompositionEngine> compositionEngine;

	mOutputLayer.initialize(compositionEngine, std::nullopt);

	EXPECT_FALSE(mOutputLayer.getState().hwc);
	}

	TEST_F(OutputLayerTest, initializingOutputLayerWithHwcDisplayCreatesHwcLayer) {
	StrictMock<compositionengine::mock::CompositionEngine> compositionEngine;
	StrictMock<android::mock::HWComposer> hwc;
	StrictMock<HWC2::mock::Layer> hwcLayer;

	EXPECT_CALL(compositionEngine, getHwComposer()).WillOnce(ReturnRef(hwc));
	EXPECT_CALL(hwc, createLayer(DEFAULT_DISPLAY_ID)).WillOnce(Return(&hwcLayer));

	mOutputLayer.initialize(compositionEngine, DEFAULT_DISPLAY_ID);

	const auto& outputLayerState = mOutputLayer.getState();
	ASSERT_TRUE(outputLayerState.hwc);

	const auto& hwcState = *outputLayerState.hwc;
	EXPECT_EQ(&hwcLayer, hwcState.hwcLayer.get());

	EXPECT_CALL(hwc, destroyLayer(DEFAULT_DISPLAY_ID, &hwcLayer));
	mOutputLayer.editState().hwc.reset();
	}

	/*
	* OutputLayer::calculateOutputDisplayFrame()
	*/

	struct OutputLayerDisplayFrameTest : public OutputLayerTest {
	OutputLayerDisplayFrameTest() {
	// Set reasonable default values for a simple case. Each test will
	// set one specific value to something different.

	mLayerState.frontEnd.geomActiveTransparentRegion = Region{};
	mLayerState.frontEnd.geomLayerTransform = ui::Transform{TR_IDENT};
	mLayerState.frontEnd.geomBufferSize = Rect{0, 0, 1920, 1080};
	mLayerState.frontEnd.geomBufferUsesDisplayInverseTransform = false;
	mLayerState.frontEnd.geomCrop = Rect{0, 0, 1920, 1080};
	mLayerState.frontEnd.geomLayerBounds = FloatRect{0.f, 0.f, 1920.f, 1080.f};

	mOutputState.viewport = Rect{0, 0, 1920, 1080};
	mOutputState.transform = ui::Transform{TR_IDENT};
	}

	Rect calculateOutputDisplayFrame() {
	mLayerState.frontEnd.geomInverseLayerTransform =
	mLayerState.frontEnd.geomLayerTransform.inverse();

	return mOutputLayer.calculateOutputDisplayFrame();
	}
	};

	TEST_F(OutputLayerDisplayFrameTest, correctForSimpleDefaultCase) {
	const Rect expected{0, 0, 1920, 1080};
	EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
	}

	TEST_F(OutputLayerDisplayFrameTest, fullActiveTransparentRegionReturnsEmptyFrame) {
	mLayerState.frontEnd.geomActiveTransparentRegion = Region{Rect{0, 0, 1920, 1080}};
	const Rect expected{0, 0, 0, 0};
	EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
	}

	TEST_F(OutputLayerDisplayFrameTest, cropAffectsDisplayFrame) {
	mLayerState.frontEnd.geomCrop = Rect{100, 200, 300, 500};
	const Rect expected{100, 200, 300, 500};
	EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
	}

	TEST_F(OutputLayerDisplayFrameTest, cropAffectsDisplayFrameRotated) {
	mLayerState.frontEnd.geomCrop = Rect{100, 200, 300, 500};
	mLayerState.frontEnd.geomLayerTransform.set(HAL_TRANSFORM_ROT_90, 1920, 1080);
	const Rect expected{1420, 100, 1720, 300};
	EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
	}

	TEST_F(OutputLayerDisplayFrameTest, emptyGeomCropIsNotUsedToComputeFrame) {
	mLayerState.frontEnd.geomCrop = Rect{};
	const Rect expected{0, 0, 1920, 1080};
	EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
	}

	TEST_F(OutputLayerDisplayFrameTest, geomLayerSnapToBoundsAffectsFrame) {
	mLayerState.frontEnd.geomLayerBounds = FloatRect{0.f, 0.f, 960.f, 540.f};
	const Rect expected{0, 0, 960, 540};
	EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
	}

	TEST_F(OutputLayerDisplayFrameTest, viewportAffectsFrame) {
	mOutputState.viewport = Rect{0, 0, 960, 540};
	const Rect expected{0, 0, 960, 540};
	EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
	}

	TEST_F(OutputLayerDisplayFrameTest, outputTransformAffectsDisplayFrame) {
	mOutputState.transform = ui::Transform{HAL_TRANSFORM_ROT_90};
	const Rect expected{-1080, 0, 0, 1920};
	EXPECT_THAT(calculateOutputDisplayFrame(), RectEq(expected));
	}

	/*
	* OutputLayer::calculateOutputRelativeBufferTransform()
	*/

	TEST_F(OutputLayerTest, calculateOutputRelativeBufferTransformTestsNeeded) {
	mLayerState.frontEnd.geomBufferUsesDisplayInverseTransform = false;

	struct Entry {
	uint32_t layer;
	uint32_t buffer;
	uint32_t display;
	uint32_t expected;
	};
	// Not an exhaustive list of cases, but hopefully enough.
	const std::array<Entry, 24> testData = {
	// clang-format off
	// layer buffer display expected
	/* 0 */ Entry{TR_IDENT, TR_IDENT, TR_IDENT, TR_IDENT},
	/* 1 */ Entry{TR_IDENT, TR_IDENT, TR_ROT_90, TR_ROT_90},
	/* 2 */ Entry{TR_IDENT, TR_IDENT, TR_ROT_180, TR_ROT_180},
	/* 3 */ Entry{TR_IDENT, TR_IDENT, TR_ROT_270, TR_ROT_270},

	/* 4 */ Entry{TR_IDENT, TR_FLP_H, TR_IDENT, TR_FLP_H ^ TR_IDENT},
	/* 5 */ Entry{TR_IDENT, TR_FLP_H, TR_ROT_90, TR_FLP_H ^ TR_ROT_90},
	/* 6 */ Entry{TR_IDENT, TR_FLP_H, TR_ROT_180, TR_FLP_H ^ TR_ROT_180},
	/* 7 */ Entry{TR_IDENT, TR_FLP_H, TR_ROT_270, TR_FLP_H ^ TR_ROT_270},

	/* 8 */ Entry{TR_IDENT, TR_FLP_V, TR_IDENT, TR_FLP_V},
	/* 9 */ Entry{TR_IDENT, TR_ROT_90, TR_ROT_90, TR_ROT_180},
	/* 10 */ Entry{TR_IDENT, TR_ROT_180, TR_ROT_180, TR_IDENT},
	/* 11 */ Entry{TR_IDENT, TR_ROT_270, TR_ROT_270, TR_ROT_180},

	/* 12 */ Entry{TR_ROT_90, TR_IDENT, TR_IDENT, TR_IDENT ^ TR_ROT_90},
	/* 13 */ Entry{TR_ROT_90, TR_FLP_H, TR_ROT_90, TR_FLP_H ^ TR_ROT_180},
	/* 14 */ Entry{TR_ROT_90, TR_IDENT, TR_ROT_180, TR_IDENT ^ TR_ROT_270},
	/* 15 */ Entry{TR_ROT_90, TR_FLP_H, TR_ROT_270, TR_FLP_H ^ TR_IDENT},

	/* 16 */ Entry{TR_ROT_180, TR_FLP_H, TR_IDENT, TR_FLP_H ^ TR_ROT_180},
	/* 17 */ Entry{TR_ROT_180, TR_IDENT, TR_ROT_90, TR_IDENT ^ TR_ROT_270},
	/* 18 */ Entry{TR_ROT_180, TR_FLP_H, TR_ROT_180, TR_FLP_H ^ TR_IDENT},
	/* 19 */ Entry{TR_ROT_180, TR_IDENT, TR_ROT_270, TR_IDENT ^ TR_ROT_90},

	/* 20 */ Entry{TR_ROT_270, TR_IDENT, TR_IDENT, TR_IDENT ^ TR_ROT_270},
	/* 21 */ Entry{TR_ROT_270, TR_FLP_H, TR_ROT_90, TR_FLP_H ^ TR_IDENT},
	/* 22 */ Entry{TR_ROT_270, TR_FLP_H, TR_ROT_180, TR_FLP_H ^ TR_ROT_90},
	/* 23 */ Entry{TR_ROT_270, TR_IDENT, TR_ROT_270, TR_IDENT ^ TR_ROT_180},
	// clang-format on
	};

	for (size_t i = 0; i < testData.size(); i++) {
	const auto& entry = testData[i];

	mLayerState.frontEnd.geomLayerTransform.set(entry.layer, 1920, 1080);
	mLayerState.frontEnd.geomBufferTransform = entry.buffer;
	mOutputState.orientation = entry.display;

	auto actual = mOutputLayer.calculateOutputRelativeBufferTransform();
	EXPECT_EQ(entry.expected, actual) << "entry " << i;
	}
	}

	/*
	* OutputLayer::writeStateToHWC()
	*/

	struct OutputLayerWriteStateToHWCTest : public OutputLayerTest {
	static constexpr HWC2::Error kError = HWC2::Error::Unsupported;
	static constexpr FloatRect kSourceCrop{11.f, 12.f, 13.f, 14.f};
	static constexpr uint32_t kZOrder = 21u;
	static constexpr Hwc2::Transform kBufferTransform = static_cast<Hwc2::Transform>(31);
	static constexpr Hwc2::IComposerClient::BlendMode kBlendMode =
	static_cast<Hwc2::IComposerClient::BlendMode>(41);
	static constexpr float kAlpha = 51.f;
	static constexpr uint32_t kType = 61u;
	static constexpr uint32_t kAppId = 62u;

	static const Rect kDisplayFrame;

	OutputLayerWriteStateToHWCTest() {
	auto& outputLayerState = mOutputLayer.editState();
	outputLayerState.hwc = impl::OutputLayerCompositionState::Hwc(mHwcLayer);

	outputLayerState.displayFrame = kDisplayFrame;
	outputLayerState.sourceCrop = kSourceCrop;
	outputLayerState.z = kZOrder;
	outputLayerState.bufferTransform = static_cast<Hwc2::Transform>(kBufferTransform);

	mLayerState.frontEnd.blendMode = kBlendMode;
	mLayerState.frontEnd.alpha = kAlpha;
	mLayerState.frontEnd.type = kType;
	mLayerState.frontEnd.appId = kAppId;
	}

	void expectGeometryCommonCalls() {
	EXPECT_CALL(*mHwcLayer, setDisplayFrame(kDisplayFrame)).WillOnce(Return(kError));
	EXPECT_CALL(*mHwcLayer, setSourceCrop(kSourceCrop)).WillOnce(Return(kError));
	EXPECT_CALL(*mHwcLayer, setZOrder(kZOrder)).WillOnce(Return(kError));
	EXPECT_CALL(*mHwcLayer, setTransform(static_cast<HWC2::Transform>(kBufferTransform)))
	.WillOnce(Return(kError));

	EXPECT_CALL(*mHwcLayer, setBlendMode(static_cast<HWC2::BlendMode>(kBlendMode)))
	.WillOnce(Return(kError));
	EXPECT_CALL(*mHwcLayer, setPlaneAlpha(kAlpha)).WillOnce(Return(kError));
	EXPECT_CALL(*mHwcLayer, setInfo(kType, kAppId)).WillOnce(Return(kError));
	}

	std::shared_ptr<HWC2::mock::Layer> mHwcLayer{std::make_shared<StrictMock<HWC2::mock::Layer>>()};
	};

	const Rect OutputLayerWriteStateToHWCTest::kDisplayFrame{1001, 1002, 1003, 10044};

	TEST_F(OutputLayerWriteStateToHWCTest, doesNothingIfNoHWCState) {
	mOutputLayer.editState().hwc.reset();

	mOutputLayer.writeStateToHWC(true);
	}

	TEST_F(OutputLayerWriteStateToHWCTest, doesNothingIfNoHWCLayer) {
	mOutputLayer.editState().hwc = impl::OutputLayerCompositionState::Hwc(nullptr);

	mOutputLayer.writeStateToHWC(true);
	}

	TEST_F(OutputLayerWriteStateToHWCTest, canSetsAllState) {
	expectGeometryCommonCalls();

	mOutputLayer.writeStateToHWC(true);
	}

	} // namespace
	} // namespace android::compositionengine