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

// TODO(b/129481165): remove the #pragma below and fix conversion issues
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wconversion"

// #define LOG_NDEBUG 0
#undef LOG_TAG
#define LOG_TAG "FakeHwcTest"

#include "FakeComposerClient.h"
#include "FakeComposerService.h"
#include "FakeComposerUtils.h"
#include "MockComposerHal.h"

#include <gui/DisplayEventReceiver.h>
#include <gui/ISurfaceComposer.h>
#include <gui/LayerDebugInfo.h>
#include <gui/LayerState.h>
#include <gui/Surface.h>
#include <gui/SurfaceComposerClient.h>

#include <android/hidl/manager/1.0/IServiceManager.h>
#include <android/looper.h>
#include <android/native_window.h>
#include <binder/ProcessState.h>
#include <hwbinder/ProcessState.h>
#include <log/log.h>
#include <private/gui/ComposerService.h>
#include <ui/DisplayConfig.h>
#include <utils/Looper.h>

#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include <limits>
#include <thread>

using namespace std::chrono_literals;

using namespace android;
using namespace android::hardware;

using namespace sftest;

namespace {

// Mock test helpers
using ::testing::_;
using ::testing::AtLeast;
using ::testing::DoAll;
using ::testing::Invoke;
using ::testing::Return;
using ::testing::SetArgPointee;

using Transaction = SurfaceComposerClient::Transaction;
using Attribute = V2_4::IComposerClient::Attribute;

///////////////////////////////////////////////

struct TestColor {
public:
    uint8_t r;
    uint8_t g;
    uint8_t b;
    uint8_t a;
};

constexpr static TestColor RED = {195, 63, 63, 255};
constexpr static TestColor LIGHT_RED = {255, 177, 177, 255};
constexpr static TestColor GREEN = {63, 195, 63, 255};
constexpr static TestColor BLUE = {63, 63, 195, 255};
constexpr static TestColor DARK_GRAY = {63, 63, 63, 255};
constexpr static TestColor LIGHT_GRAY = {200, 200, 200, 255};

// Fill an RGBA_8888 formatted surface with a single color.
static void fillSurfaceRGBA8(const sp<SurfaceControl>& sc, const TestColor& color,
                             bool unlock = true) {
    ANativeWindow_Buffer outBuffer;
    sp<Surface> s = sc->getSurface();
    ASSERT_TRUE(s != nullptr);
    ASSERT_EQ(NO_ERROR, s->lock(&outBuffer, nullptr));
    uint8_t* img = reinterpret_cast<uint8_t*>(outBuffer.bits);
    for (int y = 0; y < outBuffer.height; y++) {
        for (int x = 0; x < outBuffer.width; x++) {
            uint8_t* pixel = img + (4 * (y * outBuffer.stride + x));
            pixel[0] = color.r;
            pixel[1] = color.g;
            pixel[2] = color.b;
            pixel[3] = color.a;
        }
    }
    if (unlock) {
        ASSERT_EQ(NO_ERROR, s->unlockAndPost());
    }
}

inline RenderState makeSimpleRect(int left, int top, int right, int bottom) {
    RenderState res;
    res.mDisplayFrame = hwc_rect_t{left, top, right, bottom};
    res.mPlaneAlpha = 1.0f;
    res.mSwapCount = 0;
    res.mSourceCrop = hwc_frect_t{0.f, 0.f, static_cast<float>(right - left),
                                  static_cast<float>(bottom - top)};
    return res;
}

inline RenderState makeSimpleRect(unsigned int left, unsigned int top, unsigned int right,
                                  unsigned int bottom) {
    EXPECT_LE(left, static_cast<unsigned int>(INT_MAX));
    EXPECT_LE(top, static_cast<unsigned int>(INT_MAX));
    EXPECT_LE(right, static_cast<unsigned int>(INT_MAX));
    EXPECT_LE(bottom, static_cast<unsigned int>(INT_MAX));
    return makeSimpleRect(static_cast<int>(left), static_cast<int>(top), static_cast<int>(right),
                          static_cast<int>(bottom));
}

///////////////////////////////////////////////
template <typename FakeComposerService>
class DisplayTest : public ::testing::Test {
protected:
    struct TestConfig {
        int32_t id;
        int32_t w;
        int32_t h;
        int32_t vsyncPeriod;
        int32_t group;
    };

    static int processDisplayEvents(int /*fd*/, int /*events*/, void* data) {
        auto self = static_cast<DisplayTest*>(data);

        ssize_t n;
        DisplayEventReceiver::Event buffer[1];

        while ((n = self->mReceiver->getEvents(buffer, 1)) > 0) {
            for (int i = 0; i < n; i++) {
                self->mReceivedDisplayEvents.push_back(buffer[i]);
            }
        }
        ALOGD_IF(n < 0, "Error reading events (%s)\n", strerror(-n));
        return 1;
    }

    Error getDisplayAttributeNoMock(Display display, Config config,
                                    V2_4::IComposerClient::Attribute attribute, int32_t* outValue) {
        mFakeComposerClient->setMockHal(nullptr);
        auto ret =
                mFakeComposerClient->getDisplayAttribute_2_4(display, config, attribute, outValue);
        mFakeComposerClient->setMockHal(mMockComposer.get());
        return ret;
    }

    void setExpectationsForConfigs(Display display, std::vector<TestConfig> testConfigs,
                                   Config activeConfig, V2_4::VsyncPeriodNanos defaultVsyncPeriod) {
        std::vector<Config> configIds;
        for (int i = 0; i < testConfigs.size(); i++) {
            configIds.push_back(testConfigs[i].id);

            EXPECT_CALL(*mMockComposer,
                        getDisplayAttribute_2_4(display, testConfigs[i].id, Attribute::WIDTH, _))
                    .WillRepeatedly(DoAll(SetArgPointee<3>(testConfigs[i].w), Return(Error::NONE)));
            EXPECT_CALL(*mMockComposer,
                        getDisplayAttribute_2_4(display, testConfigs[i].id, Attribute::HEIGHT, _))
                    .WillRepeatedly(DoAll(SetArgPointee<3>(testConfigs[i].h), Return(Error::NONE)));
            EXPECT_CALL(*mMockComposer,
                        getDisplayAttribute_2_4(display, testConfigs[i].id, Attribute::VSYNC_PERIOD,
                                                _))
                    .WillRepeatedly(DoAll(SetArgPointee<3>(testConfigs[i].vsyncPeriod),
                                          Return(Error::NONE)));
            EXPECT_CALL(*mMockComposer,
                        getDisplayAttribute_2_4(display, testConfigs[i].id, Attribute::CONFIG_GROUP,
                                                _))
                    .WillRepeatedly(
                            DoAll(SetArgPointee<3>(testConfigs[i].group), Return(Error::NONE)));
            EXPECT_CALL(*mMockComposer,
                        getDisplayAttribute_2_4(display, testConfigs[i].id, Attribute::DPI_X, _))
                    .WillRepeatedly(Return(Error::UNSUPPORTED));
            EXPECT_CALL(*mMockComposer,
                        getDisplayAttribute_2_4(display, testConfigs[i].id, Attribute::DPI_Y, _))
                    .WillRepeatedly(Return(Error::UNSUPPORTED));
        }

        EXPECT_CALL(*mMockComposer, getDisplayConfigs(display, _))
                .WillRepeatedly(DoAll(SetArgPointee<1>(hidl_vec<Config>(configIds)),
                                      Return(V2_1::Error::NONE)));

        EXPECT_CALL(*mMockComposer, getActiveConfig(display, _))
                .WillRepeatedly(DoAll(SetArgPointee<1>(activeConfig), Return(V2_1::Error::NONE)));

        EXPECT_CALL(*mMockComposer, getDisplayVsyncPeriod(display, _))
                .WillRepeatedly(
                        DoAll(SetArgPointee<1>(defaultVsyncPeriod), Return(V2_4::Error::NONE)));
    }

    void SetUp() override {
        mMockComposer = std::make_unique<MockComposerHal>();
        mFakeComposerClient = new FakeComposerClient();
        mFakeComposerClient->setMockHal(mMockComposer.get());

        sp<V2_4::hal::ComposerClient> client = new V2_4::hal::ComposerClient(mFakeComposerClient);
        mFakeService = new FakeComposerService(client);
        ASSERT_EQ(android::OK, mFakeService->registerAsService("mock"));

        android::hardware::ProcessState::self()->startThreadPool();
        android::ProcessState::self()->startThreadPool();

        setExpectationsForConfigs(PRIMARY_DISPLAY,
                                  {{
                                          .id = 1,
                                          .w = 1920,
                                          .h = 1024,
                                          .vsyncPeriod = 16'666'666,
                                          .group = 0,
                                  }},
                                  1, 16'666'666);

        startSurfaceFlinger();

        // Fake composer wants to enable VSync injection
        mFakeComposerClient->onSurfaceFlingerStart();

        mComposerClient = new SurfaceComposerClient;
        ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());

        mReceiver.reset(new DisplayEventReceiver(ISurfaceComposer::eVsyncSourceApp,
                                                 ISurfaceComposer::eConfigChangedDispatch));
        mLooper = new Looper(false);
        mLooper->addFd(mReceiver->getFd(), 0, ALOOPER_EVENT_INPUT, processDisplayEvents, this);
    }

    void TearDown() override {
        mLooper = nullptr;
        mReceiver = nullptr;

        mComposerClient->dispose();
        mComposerClient = nullptr;

        // Fake composer needs to release SurfaceComposerClient before the stop.
        mFakeComposerClient->onSurfaceFlingerStop();
        stopSurfaceFlinger();

        mFakeComposerClient->setMockHal(nullptr);

        mFakeService = nullptr;
        // TODO: Currently deleted in FakeComposerClient::removeClient(). Devise better lifetime
        // management.
        mMockComposer = nullptr;
    }

    void waitForDisplayTransaction() {
        // Both a refresh and a vsync event are needed to apply pending display
        // transactions.
        mFakeComposerClient->refreshDisplay(EXTERNAL_DISPLAY);
        mFakeComposerClient->runVSyncAndWait();

        // Extra vsync and wait to avoid a 10% flake due to a race.
        mFakeComposerClient->runVSyncAndWait();
    }

    bool waitForHotplugEvent(PhysicalDisplayId displayId, bool connected) {
        int waitCount = 20;
        while (waitCount--) {
            while (!mReceivedDisplayEvents.empty()) {
                auto event = mReceivedDisplayEvents.front();
                mReceivedDisplayEvents.pop_front();

                ALOGV_IF(event.header.type == DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG,
                         "event hotplug: displayId %" ANDROID_PHYSICAL_DISPLAY_ID_FORMAT
                         ", connected %d\t",
                         event.header.displayId, event.hotplug.connected);

                if (event.header.type == DisplayEventReceiver::DISPLAY_EVENT_HOTPLUG &&
                    event.header.displayId == displayId && event.hotplug.connected == connected) {
                    return true;
                }
            }

            mLooper->pollOnce(1);
        }
        return false;
    }

    bool waitForConfigChangedEvent(PhysicalDisplayId displayId, int32_t configId) {
        int waitCount = 20;
        while (waitCount--) {
            while (!mReceivedDisplayEvents.empty()) {
                auto event = mReceivedDisplayEvents.front();
                mReceivedDisplayEvents.pop_front();

                ALOGV_IF(event.header.type == DisplayEventReceiver::DISPLAY_EVENT_CONFIG_CHANGED,
                         "event config: displayId %" ANDROID_PHYSICAL_DISPLAY_ID_FORMAT
                         ", configId %d\t",
                         event.header.displayId, event.config.configId);

                if (event.header.type == DisplayEventReceiver::DISPLAY_EVENT_CONFIG_CHANGED &&
                    event.header.displayId == displayId && event.config.configId == configId) {
                    return true;
                }
            }

            mLooper->pollOnce(1);
        }
        return false;
    }

    void Test_HotplugOneConfig() {
        ALOGD("DisplayTest::Test_Hotplug_oneConfig");

        setExpectationsForConfigs(EXTERNAL_DISPLAY,
                                  {{.id = 1,
                                    .w = 200,
                                    .h = 400,
                                    .vsyncPeriod = 16'666'666,
                                    .group = 0}},
                                  1, 16'666'666);

        mFakeComposerClient->hotplugDisplay(EXTERNAL_DISPLAY,
                                            V2_1::IComposerCallback::Connection::CONNECTED);
        waitForDisplayTransaction();
        EXPECT_TRUE(waitForHotplugEvent(EXTERNAL_DISPLAY, true));

        {
            const auto display = SurfaceComposerClient::getPhysicalDisplayToken(EXTERNAL_DISPLAY);
            EXPECT_FALSE(display == nullptr);

            DisplayConfig config;
            EXPECT_EQ(NO_ERROR, SurfaceComposerClient::getActiveDisplayConfig(display, &config));
            const ui::Size& resolution = config.resolution;
            EXPECT_EQ(ui::Size(200, 400), resolution);
            EXPECT_EQ(1e9f / 16'666'666, config.refreshRate);

            auto surfaceControl =
                    mComposerClient->createSurface(String8("Display Test Surface Foo"),
                                                   resolution.getWidth(), resolution.getHeight(),
                                                   PIXEL_FORMAT_RGBA_8888, 0);
            EXPECT_TRUE(surfaceControl != nullptr);
            EXPECT_TRUE(surfaceControl->isValid());
            fillSurfaceRGBA8(surfaceControl, BLUE);

            {
                TransactionScope ts(*mFakeComposerClient);
                ts.setDisplayLayerStack(display, 0);

                ts.setLayer(surfaceControl, INT32_MAX - 2).show(surfaceControl);
            }
        }

        mFakeComposerClient->hotplugDisplay(EXTERNAL_DISPLAY,
                                            V2_1::IComposerCallback::Connection::DISCONNECTED);
        waitForDisplayTransaction();
        mFakeComposerClient->clearFrames();
        EXPECT_TRUE(waitForHotplugEvent(EXTERNAL_DISPLAY, false));

        {
            const auto display = SurfaceComposerClient::getPhysicalDisplayToken(EXTERNAL_DISPLAY);
            EXPECT_TRUE(display == nullptr);

            DisplayConfig config;
            EXPECT_NE(NO_ERROR, SurfaceComposerClient::getActiveDisplayConfig(display, &config));
        }
    }

    void Test_HotplugTwoSeparateConfigs() {
        ALOGD("DisplayTest::Test_HotplugTwoSeparateConfigs");

        setExpectationsForConfigs(EXTERNAL_DISPLAY,
                                  {{.id = 1,
                                    .w = 200,
                                    .h = 400,
                                    .vsyncPeriod = 16'666'666,
                                    .group = 0},
                                   {.id = 2,
                                    .w = 800,
                                    .h = 1600,
                                    .vsyncPeriod = 11'111'111,
                                    .group = 1}},
                                  1, 16'666'666);

        mFakeComposerClient->hotplugDisplay(EXTERNAL_DISPLAY,
                                            V2_1::IComposerCallback::Connection::CONNECTED);
        waitForDisplayTransaction();
        EXPECT_TRUE(waitForHotplugEvent(EXTERNAL_DISPLAY, true));

        const auto display = SurfaceComposerClient::getPhysicalDisplayToken(EXTERNAL_DISPLAY);
        EXPECT_FALSE(display == nullptr);

        DisplayConfig config;
        EXPECT_EQ(NO_ERROR, SurfaceComposerClient::getActiveDisplayConfig(display, &config));
        EXPECT_EQ(ui::Size(200, 400), config.resolution);
        EXPECT_EQ(1e9f / 16'666'666, config.refreshRate);

        mFakeComposerClient->clearFrames();
        {
            const ui::Size& resolution = config.resolution;
            auto surfaceControl =
                    mComposerClient->createSurface(String8("Display Test Surface Foo"),
                                                   resolution.getWidth(), resolution.getHeight(),
                                                   PIXEL_FORMAT_RGBA_8888, 0);
            EXPECT_TRUE(surfaceControl != nullptr);
            EXPECT_TRUE(surfaceControl->isValid());
            fillSurfaceRGBA8(surfaceControl, BLUE);

            {
                TransactionScope ts(*mFakeComposerClient);
                ts.setDisplayLayerStack(display, 0);

                ts.setLayer(surfaceControl, INT32_MAX - 2).show(surfaceControl);
            }
        }

        Vector<DisplayConfig> configs;
        EXPECT_EQ(NO_ERROR, SurfaceComposerClient::getDisplayConfigs(display, &configs));
        EXPECT_EQ(configs.size(), 2);

        // change active config

        if (mIs2_4Client) {
            EXPECT_CALL(*mMockComposer, setActiveConfigWithConstraints(EXTERNAL_DISPLAY, 2, _, _))
                    .WillOnce(Return(V2_4::Error::NONE));
        } else {
            EXPECT_CALL(*mMockComposer, setActiveConfig(EXTERNAL_DISPLAY, 2))
                    .WillOnce(Return(V2_1::Error::NONE));
        }

        for (int i = 0; i < configs.size(); i++) {
            const auto& config = configs[i];
            if (config.resolution.getWidth() == 800) {
                EXPECT_EQ(NO_ERROR,
                          SurfaceComposerClient::setDesiredDisplayConfigSpecs(display, i,
                                                                              config.refreshRate,
                                                                              config.refreshRate,
                                                                              config.refreshRate,
                                                                              config.refreshRate));
                waitForDisplayTransaction();
                EXPECT_TRUE(waitForConfigChangedEvent(EXTERNAL_DISPLAY, i));
                break;
            }
        }

        EXPECT_EQ(NO_ERROR, SurfaceComposerClient::getActiveDisplayConfig(display, &config));
        EXPECT_EQ(ui::Size(800, 1600), config.resolution);
        EXPECT_EQ(1e9f / 11'111'111, config.refreshRate);

        mFakeComposerClient->clearFrames();
        {
            const ui::Size& resolution = config.resolution;
            auto surfaceControl =
                    mComposerClient->createSurface(String8("Display Test Surface Foo"),
                                                   resolution.getWidth(), resolution.getHeight(),
                                                   PIXEL_FORMAT_RGBA_8888, 0);
            EXPECT_TRUE(surfaceControl != nullptr);
            EXPECT_TRUE(surfaceControl->isValid());
            fillSurfaceRGBA8(surfaceControl, BLUE);

            {
                TransactionScope ts(*mFakeComposerClient);
                ts.setDisplayLayerStack(display, 0);

                ts.setLayer(surfaceControl, INT32_MAX - 2).show(surfaceControl);
            }
        }

        mFakeComposerClient->hotplugDisplay(EXTERNAL_DISPLAY,
                                            V2_1::IComposerCallback::Connection::DISCONNECTED);
        waitForDisplayTransaction();
        mFakeComposerClient->clearFrames();
        EXPECT_TRUE(waitForHotplugEvent(EXTERNAL_DISPLAY, false));
    }

    void Test_HotplugTwoConfigsSameGroup() {
        ALOGD("DisplayTest::Test_HotplugTwoConfigsSameGroup");

        setExpectationsForConfigs(EXTERNAL_DISPLAY,
                                  {{.id = 2,
                                    .w = 800,
                                    .h = 1600,
                                    .vsyncPeriod = 16'666'666,
                                    .group = 31},
                                   {.id = 3,
                                    .w = 800,
                                    .h = 1600,
                                    .vsyncPeriod = 11'111'111,
                                    .group = 31}},
                                  2, 16'666'666);

        mFakeComposerClient->hotplugDisplay(EXTERNAL_DISPLAY,
                                            V2_1::IComposerCallback::Connection::CONNECTED);
        waitForDisplayTransaction();
        EXPECT_TRUE(waitForHotplugEvent(EXTERNAL_DISPLAY, true));

        const auto display = SurfaceComposerClient::getPhysicalDisplayToken(EXTERNAL_DISPLAY);
        EXPECT_FALSE(display == nullptr);

        DisplayConfig config;
        EXPECT_EQ(NO_ERROR, SurfaceComposerClient::getActiveDisplayConfig(display, &config));
        EXPECT_EQ(ui::Size(800, 1600), config.resolution);
        EXPECT_EQ(1e9f / 16'666'666, config.refreshRate);

        mFakeComposerClient->clearFrames();
        {
            const ui::Size& resolution = config.resolution;
            auto surfaceControl =
                    mComposerClient->createSurface(String8("Display Test Surface Foo"),
                                                   resolution.getWidth(), resolution.getHeight(),
                                                   PIXEL_FORMAT_RGBA_8888, 0);
            EXPECT_TRUE(surfaceControl != nullptr);
            EXPECT_TRUE(surfaceControl->isValid());
            fillSurfaceRGBA8(surfaceControl, BLUE);

            {
                TransactionScope ts(*mFakeComposerClient);
                ts.setDisplayLayerStack(display, 0);

                ts.setLayer(surfaceControl, INT32_MAX - 2).show(surfaceControl);
            }
        }

        Vector<DisplayConfig> configs;
        EXPECT_EQ(NO_ERROR, SurfaceComposerClient::getDisplayConfigs(display, &configs));
        EXPECT_EQ(configs.size(), 2);

        // change active config
        if (mIs2_4Client) {
            EXPECT_CALL(*mMockComposer, setActiveConfigWithConstraints(EXTERNAL_DISPLAY, 3, _, _))
                    .WillOnce(Return(V2_4::Error::NONE));
        } else {
            EXPECT_CALL(*mMockComposer, setActiveConfig(EXTERNAL_DISPLAY, 3))
                    .WillOnce(Return(V2_1::Error::NONE));
        }

        for (int i = 0; i < configs.size(); i++) {
            const auto& config = configs[i];
            if (config.refreshRate == 1e9f / 11'111'111) {
                EXPECT_EQ(NO_ERROR,
                          SurfaceComposerClient::setDesiredDisplayConfigSpecs(display, i,
                                                                              config.refreshRate,
                                                                              config.refreshRate,
                                                                              config.refreshRate,
                                                                              config.refreshRate));
                waitForDisplayTransaction();
                EXPECT_TRUE(waitForConfigChangedEvent(EXTERNAL_DISPLAY, i));
                break;
            }
        }

        EXPECT_EQ(NO_ERROR, SurfaceComposerClient::getActiveDisplayConfig(display, &config));
        EXPECT_EQ(ui::Size(800, 1600), config.resolution);
        EXPECT_EQ(1e9f / 11'111'111, config.refreshRate);

        mFakeComposerClient->clearFrames();
        {
            const ui::Size& resolution = config.resolution;
            auto surfaceControl =
                    mComposerClient->createSurface(String8("Display Test Surface Foo"),
                                                   resolution.getWidth(), resolution.getHeight(),
                                                   PIXEL_FORMAT_RGBA_8888, 0);
            EXPECT_TRUE(surfaceControl != nullptr);
            EXPECT_TRUE(surfaceControl->isValid());
            fillSurfaceRGBA8(surfaceControl, BLUE);

            {
                TransactionScope ts(*mFakeComposerClient);
                ts.setDisplayLayerStack(display, 0);

                ts.setLayer(surfaceControl, INT32_MAX - 2).show(surfaceControl);
            }
        }

        mFakeComposerClient->hotplugDisplay(EXTERNAL_DISPLAY,
                                            V2_1::IComposerCallback::Connection::DISCONNECTED);
        waitForDisplayTransaction();
        mFakeComposerClient->clearFrames();
        EXPECT_TRUE(waitForHotplugEvent(EXTERNAL_DISPLAY, false));
    }

    void Test_HotplugThreeConfigsMixedGroups() {
        ALOGD("DisplayTest::Test_HotplugThreeConfigsMixedGroups");

        setExpectationsForConfigs(EXTERNAL_DISPLAY,
                                  {{.id = 2,
                                    .w = 800,
                                    .h = 1600,
                                    .vsyncPeriod = 16'666'666,
                                    .group = 0},
                                   {.id = 3,
                                    .w = 800,
                                    .h = 1600,
                                    .vsyncPeriod = 11'111'111,
                                    .group = 0},
                                   {.id = 4,
                                    .w = 1600,
                                    .h = 3200,
                                    .vsyncPeriod = 8'333'333,
                                    .group = 1},
                                   {.id = 5,
                                    .w = 1600,
                                    .h = 3200,
                                    .vsyncPeriod = 11'111'111,
                                    .group = 1}},
                                  2, 16'666'666);

        mFakeComposerClient->hotplugDisplay(EXTERNAL_DISPLAY,
                                            V2_1::IComposerCallback::Connection::CONNECTED);
        waitForDisplayTransaction();
        EXPECT_TRUE(waitForHotplugEvent(EXTERNAL_DISPLAY, true));

        const auto display = SurfaceComposerClient::getPhysicalDisplayToken(EXTERNAL_DISPLAY);
        EXPECT_FALSE(display == nullptr);

        DisplayConfig config;
        EXPECT_EQ(NO_ERROR, SurfaceComposerClient::getActiveDisplayConfig(display, &config));
        EXPECT_EQ(ui::Size(800, 1600), config.resolution);
        EXPECT_EQ(1e9f / 16'666'666, config.refreshRate);

        mFakeComposerClient->clearFrames();
        {
            const ui::Size& resolution = config.resolution;
            auto surfaceControl =
                    mComposerClient->createSurface(String8("Display Test Surface Foo"),
                                                   resolution.getWidth(), resolution.getHeight(),
                                                   PIXEL_FORMAT_RGBA_8888, 0);
            EXPECT_TRUE(surfaceControl != nullptr);
            EXPECT_TRUE(surfaceControl->isValid());
            fillSurfaceRGBA8(surfaceControl, BLUE);

            {
                TransactionScope ts(*mFakeComposerClient);
                ts.setDisplayLayerStack(display, 0);

                ts.setLayer(surfaceControl, INT32_MAX - 2).show(surfaceControl);
            }
        }

        Vector<DisplayConfig> configs;
        EXPECT_EQ(NO_ERROR, SurfaceComposerClient::getDisplayConfigs(display, &configs));
        EXPECT_EQ(configs.size(), 4);

        // change active config to 800x1600@90Hz
        if (mIs2_4Client) {
            EXPECT_CALL(*mMockComposer, setActiveConfigWithConstraints(EXTERNAL_DISPLAY, 3, _, _))
                    .WillOnce(Return(V2_4::Error::NONE));
        } else {
            EXPECT_CALL(*mMockComposer, setActiveConfig(EXTERNAL_DISPLAY, 3))
                    .WillOnce(Return(V2_1::Error::NONE));
        }

        for (int i = 0; i < configs.size(); i++) {
            const auto& config = configs[i];
            if (config.resolution.getWidth() == 800 && config.refreshRate == 1e9f / 11'111'111) {
                EXPECT_EQ(NO_ERROR,
                          SurfaceComposerClient::
                                  setDesiredDisplayConfigSpecs(display, i, configs[i].refreshRate,
                                                               configs[i].refreshRate,
                                                               configs[i].refreshRate,
                                                               configs[i].refreshRate));
                waitForDisplayTransaction();
                EXPECT_TRUE(waitForConfigChangedEvent(EXTERNAL_DISPLAY, i));
                break;
            }
        }

        EXPECT_EQ(NO_ERROR, SurfaceComposerClient::getActiveDisplayConfig(display, &config));
        EXPECT_EQ(ui::Size(800, 1600), config.resolution);
        EXPECT_EQ(1e9f / 11'111'111, config.refreshRate);

        mFakeComposerClient->clearFrames();
        {
            const ui::Size& resolution = config.resolution;
            auto surfaceControl =
                    mComposerClient->createSurface(String8("Display Test Surface Foo"),
                                                   resolution.getWidth(), resolution.getHeight(),
                                                   PIXEL_FORMAT_RGBA_8888, 0);
            EXPECT_TRUE(surfaceControl != nullptr);
            EXPECT_TRUE(surfaceControl->isValid());
            fillSurfaceRGBA8(surfaceControl, BLUE);

            {
                TransactionScope ts(*mFakeComposerClient);
                ts.setDisplayLayerStack(display, 0);

                ts.setLayer(surfaceControl, INT32_MAX - 2).show(surfaceControl);
            }
        }

        // change active config to 1600x3200@120Hz
        if (mIs2_4Client) {
            EXPECT_CALL(*mMockComposer, setActiveConfigWithConstraints(EXTERNAL_DISPLAY, 4, _, _))
                    .WillOnce(Return(V2_4::Error::NONE));
        } else {
            EXPECT_CALL(*mMockComposer, setActiveConfig(EXTERNAL_DISPLAY, 4))
                    .WillOnce(Return(V2_1::Error::NONE));
        }

        for (int i = 0; i < configs.size(); i++) {
            const auto& config = configs[i];
            if (config.refreshRate == 1e9f / 8'333'333) {
                EXPECT_EQ(NO_ERROR,
                          SurfaceComposerClient::setDesiredDisplayConfigSpecs(display, i,
                                                                              config.refreshRate,
                                                                              config.refreshRate,
                                                                              config.refreshRate,
                                                                              config.refreshRate));
                waitForDisplayTransaction();
                EXPECT_TRUE(waitForConfigChangedEvent(EXTERNAL_DISPLAY, i));
                break;
            }
        }

        EXPECT_EQ(NO_ERROR, SurfaceComposerClient::getActiveDisplayConfig(display, &config));
        EXPECT_EQ(ui::Size(1600, 3200), config.resolution);
        EXPECT_EQ(1e9f / 8'333'333, config.refreshRate);

        mFakeComposerClient->clearFrames();
        {
            const ui::Size& resolution = config.resolution;
            auto surfaceControl =
                    mComposerClient->createSurface(String8("Display Test Surface Foo"),
                                                   resolution.getWidth(), resolution.getHeight(),
                                                   PIXEL_FORMAT_RGBA_8888, 0);
            EXPECT_TRUE(surfaceControl != nullptr);
            EXPECT_TRUE(surfaceControl->isValid());
            fillSurfaceRGBA8(surfaceControl, BLUE);

            {
                TransactionScope ts(*mFakeComposerClient);
                ts.setDisplayLayerStack(display, 0);

                ts.setLayer(surfaceControl, INT32_MAX - 2).show(surfaceControl);
            }
        }

        // change active config to 1600x3200@90Hz
        if (mIs2_4Client) {
            EXPECT_CALL(*mMockComposer, setActiveConfigWithConstraints(EXTERNAL_DISPLAY, 5, _, _))
                    .WillOnce(Return(V2_4::Error::NONE));
        } else {
            EXPECT_CALL(*mMockComposer, setActiveConfig(EXTERNAL_DISPLAY, 5))
                    .WillOnce(Return(V2_1::Error::NONE));
        }

        for (int i = 0; i < configs.size(); i++) {
            const auto& config = configs[i];
            if (config.resolution.getWidth() == 1600 && config.refreshRate == 1e9f / 11'111'111) {
                EXPECT_EQ(NO_ERROR,
                          SurfaceComposerClient::setDesiredDisplayConfigSpecs(display, i,
                                                                              config.refreshRate,
                                                                              config.refreshRate,
                                                                              config.refreshRate,
                                                                              config.refreshRate));
                waitForDisplayTransaction();
                EXPECT_TRUE(waitForConfigChangedEvent(EXTERNAL_DISPLAY, i));
                break;
            }
        }

        EXPECT_EQ(NO_ERROR, SurfaceComposerClient::getActiveDisplayConfig(display, &config));
        EXPECT_EQ(ui::Size(1600, 3200), config.resolution);
        EXPECT_EQ(1e9f / 11'111'111, config.refreshRate);

        mFakeComposerClient->clearFrames();
        {
            const ui::Size& resolution = config.resolution;
            auto surfaceControl =
                    mComposerClient->createSurface(String8("Display Test Surface Foo"),
                                                   resolution.getWidth(), resolution.getHeight(),
                                                   PIXEL_FORMAT_RGBA_8888, 0);
            EXPECT_TRUE(surfaceControl != nullptr);
            EXPECT_TRUE(surfaceControl->isValid());
            fillSurfaceRGBA8(surfaceControl, BLUE);

            {
                TransactionScope ts(*mFakeComposerClient);
                ts.setDisplayLayerStack(display, 0);

                ts.setLayer(surfaceControl, INT32_MAX - 2).show(surfaceControl);
            }
        }

        mFakeComposerClient->hotplugDisplay(EXTERNAL_DISPLAY,
                                            V2_1::IComposerCallback::Connection::DISCONNECTED);
        waitForDisplayTransaction();
        mFakeComposerClient->clearFrames();
        EXPECT_TRUE(waitForHotplugEvent(EXTERNAL_DISPLAY, false));
    }

    void Test_HotplugPrimaryDisplay() {
        ALOGD("DisplayTest::HotplugPrimaryDisplay");

        mFakeComposerClient->hotplugDisplay(PRIMARY_DISPLAY,
                                            V2_1::IComposerCallback::Connection::DISCONNECTED);

        waitForDisplayTransaction();

        EXPECT_TRUE(waitForHotplugEvent(PRIMARY_DISPLAY, false));
        {
            const auto display = SurfaceComposerClient::getPhysicalDisplayToken(PRIMARY_DISPLAY);
            EXPECT_TRUE(display == nullptr);

            DisplayConfig config;
            auto result = SurfaceComposerClient::getActiveDisplayConfig(display, &config);
            EXPECT_NE(NO_ERROR, result);
        }

        mFakeComposerClient->clearFrames();

        setExpectationsForConfigs(PRIMARY_DISPLAY,
                                  {{.id = 1,
                                    .w = 400,
                                    .h = 200,
                                    .vsyncPeriod = 16'666'666,
                                    .group = 0}},
                                  1, 16'666'666);

        mFakeComposerClient->hotplugDisplay(PRIMARY_DISPLAY,
                                            V2_1::IComposerCallback::Connection::CONNECTED);

        waitForDisplayTransaction();

        EXPECT_TRUE(waitForHotplugEvent(PRIMARY_DISPLAY, true));

        {
            const auto display = SurfaceComposerClient::getPhysicalDisplayToken(PRIMARY_DISPLAY);
            EXPECT_FALSE(display == nullptr);

            DisplayConfig config;
            auto result = SurfaceComposerClient::getActiveDisplayConfig(display, &config);
            EXPECT_EQ(NO_ERROR, result);
            ASSERT_EQ(ui::Size(400, 200), config.resolution);
            EXPECT_EQ(1e9f / 16'666'666, config.refreshRate);
        }
    }

    sp<V2_1::IComposer> mFakeService;
    sp<SurfaceComposerClient> mComposerClient;

    std::unique_ptr<MockComposerHal> mMockComposer;
    FakeComposerClient* mFakeComposerClient;

    std::unique_ptr<DisplayEventReceiver> mReceiver;
    sp<Looper> mLooper;
    std::deque<DisplayEventReceiver::Event> mReceivedDisplayEvents;

    static constexpr bool mIs2_4Client =
            std::is_same<FakeComposerService, FakeComposerService_2_4>::value;
};

using DisplayTest_2_1 = DisplayTest<FakeComposerService_2_1>;

TEST_F(DisplayTest_2_1, HotplugOneConfig) {
    Test_HotplugOneConfig();
}

TEST_F(DisplayTest_2_1, HotplugTwoSeparateConfigs) {
    Test_HotplugTwoSeparateConfigs();
}

TEST_F(DisplayTest_2_1, HotplugTwoConfigsSameGroup) {
    Test_HotplugTwoConfigsSameGroup();
}

TEST_F(DisplayTest_2_1, HotplugThreeConfigsMixedGroups) {
    Test_HotplugThreeConfigsMixedGroups();
}

TEST_F(DisplayTest_2_1, HotplugPrimaryOneConfig) {
    Test_HotplugPrimaryDisplay();
}

using DisplayTest_2_2 = DisplayTest<FakeComposerService_2_2>;

TEST_F(DisplayTest_2_2, HotplugOneConfig) {
    Test_HotplugOneConfig();
}

TEST_F(DisplayTest_2_2, HotplugTwoSeparateConfigs) {
    Test_HotplugTwoSeparateConfigs();
}

TEST_F(DisplayTest_2_2, HotplugTwoConfigsSameGroup) {
    Test_HotplugTwoConfigsSameGroup();
}

TEST_F(DisplayTest_2_2, HotplugThreeConfigsMixedGroups) {
    Test_HotplugThreeConfigsMixedGroups();
}

TEST_F(DisplayTest_2_2, HotplugPrimaryOneConfig) {
    Test_HotplugPrimaryDisplay();
}

using DisplayTest_2_3 = DisplayTest<FakeComposerService_2_3>;

TEST_F(DisplayTest_2_3, HotplugOneConfig) {
    Test_HotplugOneConfig();
}

TEST_F(DisplayTest_2_3, HotplugTwoSeparateConfigs) {
    Test_HotplugTwoSeparateConfigs();
}

TEST_F(DisplayTest_2_3, HotplugTwoConfigsSameGroup) {
    Test_HotplugTwoConfigsSameGroup();
}

TEST_F(DisplayTest_2_3, HotplugThreeConfigsMixedGroups) {
    Test_HotplugThreeConfigsMixedGroups();
}

TEST_F(DisplayTest_2_3, HotplugPrimaryOneConfig) {
    Test_HotplugPrimaryDisplay();
}

using DisplayTest_2_4 = DisplayTest<FakeComposerService_2_4>;

TEST_F(DisplayTest_2_4, HotplugOneConfig) {
    Test_HotplugOneConfig();
}

TEST_F(DisplayTest_2_4, HotplugTwoSeparateConfigs) {
    Test_HotplugTwoSeparateConfigs();
}

TEST_F(DisplayTest_2_4, HotplugTwoConfigsSameGroup) {
    Test_HotplugTwoConfigsSameGroup();
}

TEST_F(DisplayTest_2_4, HotplugThreeConfigsMixedGroups) {
    Test_HotplugThreeConfigsMixedGroups();
}

TEST_F(DisplayTest_2_4, HotplugPrimaryOneConfig) {
    Test_HotplugPrimaryDisplay();
}

////////////////////////////////////////////////

template <typename FakeComposerService>
class TransactionTest : public ::testing::Test {
protected:
    // Layer array indexing constants.
    constexpr static int BG_LAYER = 0;
    constexpr static int FG_LAYER = 1;

    static void SetUpTestCase() {
        // TODO: See TODO comment at DisplayTest::SetUp for background on
        // the lifetime of the FakeComposerClient.
        sFakeComposer = new FakeComposerClient;
        sp<V2_4::hal::ComposerClient> client = new V2_4::hal::ComposerClient(sFakeComposer);
        sp<V2_1::IComposer> fakeService = new FakeComposerService(client);
        (void)fakeService->registerAsService("mock");

        android::hardware::ProcessState::self()->startThreadPool();
        android::ProcessState::self()->startThreadPool();

        startSurfaceFlinger();

        // Fake composer wants to enable VSync injection
        sFakeComposer->onSurfaceFlingerStart();
    }

    static void TearDownTestCase() {
        // Fake composer needs to release SurfaceComposerClient before the stop.
        sFakeComposer->onSurfaceFlingerStop();
        stopSurfaceFlinger();
        // TODO: This is deleted when the ComposerClient calls
        // removeClient. Devise better lifetime control.
        sFakeComposer = nullptr;
    }

    void SetUp() override {
        ALOGI("TransactionTest::SetUp");
        mComposerClient = new SurfaceComposerClient;
        ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());

        ALOGI("TransactionTest::SetUp - display");
        const auto display = SurfaceComposerClient::getPhysicalDisplayToken(PRIMARY_DISPLAY);
        ASSERT_FALSE(display == nullptr);

        DisplayConfig config;
        ASSERT_EQ(NO_ERROR, SurfaceComposerClient::getActiveDisplayConfig(display, &config));

        const ui::Size& resolution = config.resolution;
        mDisplayWidth = resolution.getWidth();
        mDisplayHeight = resolution.getHeight();

        // Background surface
        mBGSurfaceControl =
                mComposerClient->createSurface(String8("BG Test Surface"), mDisplayWidth,
                                               mDisplayHeight, PIXEL_FORMAT_RGBA_8888, 0);
        ASSERT_TRUE(mBGSurfaceControl != nullptr);
        ASSERT_TRUE(mBGSurfaceControl->isValid());
        fillSurfaceRGBA8(mBGSurfaceControl, BLUE);

        // Foreground surface
        mFGSurfaceControl = mComposerClient->createSurface(String8("FG Test Surface"), 64, 64,
                                                           PIXEL_FORMAT_RGBA_8888, 0);
        ASSERT_TRUE(mFGSurfaceControl != nullptr);
        ASSERT_TRUE(mFGSurfaceControl->isValid());

        fillSurfaceRGBA8(mFGSurfaceControl, RED);

        Transaction t;
        t.setDisplayLayerStack(display, 0);

        t.setLayer(mBGSurfaceControl, INT32_MAX - 2);
        t.show(mBGSurfaceControl);

        t.setLayer(mFGSurfaceControl, INT32_MAX - 1);
        t.setPosition(mFGSurfaceControl, 64, 64);
        t.show(mFGSurfaceControl);

        // Synchronous transaction will stop this thread, so we set up a
        // delayed, off-thread vsync request before closing the
        // transaction. In the test code this is usually done with
        // TransactionScope. Leaving here in the 'vanilla' form for
        // reference.
        ASSERT_EQ(0, sFakeComposer->getFrameCount());
        sFakeComposer->runVSyncAfter(1ms);
        t.apply();
        sFakeComposer->waitUntilFrame(1);

        // Reference data. This is what the HWC should see.
        static_assert(BG_LAYER == 0 && FG_LAYER == 1, "Unexpected enum values for array indexing");
        mBaseFrame.push_back(makeSimpleRect(0u, 0u, mDisplayWidth, mDisplayHeight));
        mBaseFrame[BG_LAYER].mSwapCount = 1;
        mBaseFrame.push_back(makeSimpleRect(64, 64, 64 + 64, 64 + 64));
        mBaseFrame[FG_LAYER].mSwapCount = 1;

        auto frame = sFakeComposer->getFrameRects(0);
        ASSERT_TRUE(framesAreSame(mBaseFrame, frame));
    }

    void TearDown() override {
        ALOGD("TransactionTest::TearDown");

        mComposerClient->dispose();
        mBGSurfaceControl = 0;
        mFGSurfaceControl = 0;
        mComposerClient = 0;

        sFakeComposer->runVSyncAndWait();
        mBaseFrame.clear();
        sFakeComposer->clearFrames();
        ASSERT_EQ(0, sFakeComposer->getFrameCount());

        sp<ISurfaceComposer> sf(ComposerService::getComposerService());
        std::vector<LayerDebugInfo> layers;
        status_t result = sf->getLayerDebugInfo(&layers);
        if (result != NO_ERROR) {
            ALOGE("Failed to get layers %s %d", strerror(-result), result);
        } else {
            // If this fails, the test being torn down leaked layers.
            EXPECT_EQ(0u, layers.size());
            if (layers.size() > 0) {
                for (auto layer = layers.begin(); layer != layers.end(); ++layer) {
                    std::cout << to_string(*layer).c_str();
                }
                // To ensure the next test has clean slate, will run the class
                // tear down and setup here.
                TearDownTestCase();
                SetUpTestCase();
            }
        }
        ALOGD("TransactionTest::TearDown - complete");
    }

    void Test_LayerMove() {
        ALOGD("TransactionTest::LayerMove");

        // The scope opens and closes a global transaction and, at the
        // same time, makes sure the SurfaceFlinger progresses one frame
        // after the transaction closes. The results of the transaction
        // should be available in the latest frame stored by the fake
        // composer.
        {
            TransactionScope ts(*sFakeComposer);
            ts.setPosition(mFGSurfaceControl, 128, 128);
            // NOTE: No changes yet, so vsync will do nothing, HWC does not get any calls.
            // (How to verify that? Throw in vsync and wait a 2x frame time? Separate test?)
            //
            // sFakeComposer->runVSyncAndWait();
        }

        fillSurfaceRGBA8(mFGSurfaceControl, GREEN);
        sFakeComposer->runVSyncAndWait();

        ASSERT_EQ(3, sFakeComposer->getFrameCount()); // Make sure the waits didn't time out and
                                                      // there's no extra frames.

        // NOTE: Frame 0 is produced in the SetUp.
        auto frame1Ref = mBaseFrame;
        frame1Ref[FG_LAYER].mDisplayFrame =
                hwc_rect_t{128, 128, 128 + 64, 128 + 64}; // Top-most layer moves.
        EXPECT_TRUE(framesAreSame(frame1Ref, sFakeComposer->getFrameRects(1)));

        auto frame2Ref = frame1Ref;
        frame2Ref[FG_LAYER].mSwapCount++;
        EXPECT_TRUE(framesAreSame(frame2Ref, sFakeComposer->getFrameRects(2)));
    }

    void Test_LayerResize() {
        ALOGD("TransactionTest::LayerResize");
        {
            TransactionScope ts(*sFakeComposer);
            ts.setSize(mFGSurfaceControl, 128, 128);
        }

        fillSurfaceRGBA8(mFGSurfaceControl, GREEN);
        sFakeComposer->runVSyncAndWait();

        ASSERT_EQ(3, sFakeComposer->getFrameCount()); // Make sure the waits didn't time out and
                                                      // there's no extra frames.

        auto frame1Ref = mBaseFrame;
        // NOTE: The resize should not be visible for frame 1 as there's no buffer with new size
        // posted.
        EXPECT_TRUE(framesAreSame(frame1Ref, sFakeComposer->getFrameRects(1)));

        auto frame2Ref = frame1Ref;
        frame2Ref[FG_LAYER].mSwapCount++;
        frame2Ref[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 128, 64 + 128};
        frame2Ref[FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 128.f, 128.f};
        EXPECT_TRUE(framesAreSame(frame2Ref, sFakeComposer->getFrameRects(2)));
    }

    void Test_LayerCrop() {
        // TODO: Add scaling to confirm that crop happens in buffer space?
        {
            TransactionScope ts(*sFakeComposer);
            Rect cropRect(16, 16, 32, 32);
            ts.setCrop_legacy(mFGSurfaceControl, cropRect);
        }
        ASSERT_EQ(2, sFakeComposer->getFrameCount());

        auto referenceFrame = mBaseFrame;
        referenceFrame[FG_LAYER].mSourceCrop = hwc_frect_t{16.f, 16.f, 32.f, 32.f};
        referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{64 + 16, 64 + 16, 64 + 32, 64 + 32};
        EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));
    }

    void Test_LayerSetLayer() {
        {
            TransactionScope ts(*sFakeComposer);
            ts.setLayer(mFGSurfaceControl, INT_MAX - 3);
        }
        ASSERT_EQ(2, sFakeComposer->getFrameCount());

        // The layers will switch order, but both are rendered because the background layer is
        // transparent (RGBA8888).
        std::vector<RenderState> referenceFrame(2);
        referenceFrame[0] = mBaseFrame[FG_LAYER];
        referenceFrame[1] = mBaseFrame[BG_LAYER];
        EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));
    }

    void Test_LayerSetLayerOpaque() {
        {
            TransactionScope ts(*sFakeComposer);
            ts.setLayer(mFGSurfaceControl, INT_MAX - 3);
            ts.setFlags(mBGSurfaceControl, layer_state_t::eLayerOpaque,
                        layer_state_t::eLayerOpaque);
        }
        ASSERT_EQ(2, sFakeComposer->getFrameCount());

        // The former foreground layer is now covered with opaque layer - it should have disappeared
        std::vector<RenderState> referenceFrame(1);
        referenceFrame[BG_LAYER] = mBaseFrame[BG_LAYER];
        EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));
    }

    void Test_SetLayerStack() {
        ALOGD("TransactionTest::SetLayerStack");
        {
            TransactionScope ts(*sFakeComposer);
            ts.setLayerStack(mFGSurfaceControl, 1);
        }

        // Foreground layer should have disappeared.
        ASSERT_EQ(2, sFakeComposer->getFrameCount());
        std::vector<RenderState> refFrame(1);
        refFrame[BG_LAYER] = mBaseFrame[BG_LAYER];
        EXPECT_TRUE(framesAreSame(refFrame, sFakeComposer->getLatestFrame()));
    }

    void Test_LayerShowHide() {
        ALOGD("TransactionTest::LayerShowHide");
        {
            TransactionScope ts(*sFakeComposer);
            ts.hide(mFGSurfaceControl);
        }

        // Foreground layer should have disappeared.
        ASSERT_EQ(2, sFakeComposer->getFrameCount());
        std::vector<RenderState> refFrame(1);
        refFrame[BG_LAYER] = mBaseFrame[BG_LAYER];
        EXPECT_TRUE(framesAreSame(refFrame, sFakeComposer->getLatestFrame()));

        {
            TransactionScope ts(*sFakeComposer);
            ts.show(mFGSurfaceControl);
        }

        // Foreground layer should be back
        ASSERT_EQ(3, sFakeComposer->getFrameCount());
        EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame()));
    }

    void Test_LayerSetAlpha() {
        {
            TransactionScope ts(*sFakeComposer);
            ts.setAlpha(mFGSurfaceControl, 0.75f);
        }

        ASSERT_EQ(2, sFakeComposer->getFrameCount());
        auto referenceFrame = mBaseFrame;
        referenceFrame[FG_LAYER].mPlaneAlpha = 0.75f;
        EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));
    }

    void Test_LayerSetFlags() {
        {
            TransactionScope ts(*sFakeComposer);
            ts.setFlags(mFGSurfaceControl, layer_state_t::eLayerHidden,
                        layer_state_t::eLayerHidden);
        }

        // Foreground layer should have disappeared.
        ASSERT_EQ(2, sFakeComposer->getFrameCount());
        std::vector<RenderState> refFrame(1);
        refFrame[BG_LAYER] = mBaseFrame[BG_LAYER];
        EXPECT_TRUE(framesAreSame(refFrame, sFakeComposer->getLatestFrame()));
    }

    void Test_LayerSetMatrix() {
        struct matrixTestData {
            float matrix[4];
            hwc_transform_t expectedTransform;
            hwc_rect_t expectedDisplayFrame;
        };

        // The matrix operates on the display frame and is applied before
        // the position is added. So, the foreground layer rect is (0, 0,
        // 64, 64) is first transformed, potentially yielding negative
        // coordinates and then the position (64, 64) is added yielding
        // the final on-screen rectangles given.

        const matrixTestData MATRIX_TESTS[7] = // clang-format off
                {{{-1.f, 0.f, 0.f, 1.f},    HWC_TRANSFORM_FLIP_H,           {0, 64, 64, 128}},
                 {{1.f, 0.f, 0.f, -1.f},    HWC_TRANSFORM_FLIP_V,           {64, 0, 128, 64}},
                 {{0.f, 1.f, -1.f, 0.f},    HWC_TRANSFORM_ROT_90,           {0, 64, 64, 128}},
                 {{-1.f, 0.f, 0.f, -1.f},   HWC_TRANSFORM_ROT_180,          {0, 0, 64, 64}},
                 {{0.f, -1.f, 1.f, 0.f},    HWC_TRANSFORM_ROT_270,          {64, 0, 128, 64}},
                 {{0.f, 1.f, 1.f, 0.f},     HWC_TRANSFORM_FLIP_H_ROT_90,    {64, 64, 128, 128}},
                 {{0.f, 1.f, 1.f, 0.f},     HWC_TRANSFORM_FLIP_V_ROT_90,    {64, 64, 128, 128}}};
        // clang-format on
        constexpr int TEST_COUNT = sizeof(MATRIX_TESTS) / sizeof(matrixTestData);

        for (int i = 0; i < TEST_COUNT; i++) {
            // TODO: How to leverage the HWC2 stringifiers?
            const matrixTestData& xform = MATRIX_TESTS[i];
            SCOPED_TRACE(i);
            {
                TransactionScope ts(*sFakeComposer);
                ts.setMatrix(mFGSurfaceControl, xform.matrix[0], xform.matrix[1], xform.matrix[2],
                             xform.matrix[3]);
            }

            auto referenceFrame = mBaseFrame;
            referenceFrame[FG_LAYER].mTransform = xform.expectedTransform;
            referenceFrame[FG_LAYER].mDisplayFrame = xform.expectedDisplayFrame;

            EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));
        }
    }

    void Test_DeferredTransaction() {
        // Synchronization surface
        constexpr static int SYNC_LAYER = 2;
        auto syncSurfaceControl = mComposerClient->createSurface(String8("Sync Test Surface"), 1, 1,
                                                                 PIXEL_FORMAT_RGBA_8888, 0);
        ASSERT_TRUE(syncSurfaceControl != nullptr);
        ASSERT_TRUE(syncSurfaceControl->isValid());

        fillSurfaceRGBA8(syncSurfaceControl, DARK_GRAY);

        {
            TransactionScope ts(*sFakeComposer);
            ts.setLayer(syncSurfaceControl, INT32_MAX - 1);
            ts.setPosition(syncSurfaceControl, mDisplayWidth - 2, mDisplayHeight - 2);
            ts.show(syncSurfaceControl);
        }
        auto referenceFrame = mBaseFrame;
        referenceFrame.push_back(makeSimpleRect(mDisplayWidth - 2, mDisplayHeight - 2,
                                                mDisplayWidth - 1, mDisplayHeight - 1));
        referenceFrame[SYNC_LAYER].mSwapCount = 1;
        EXPECT_EQ(2, sFakeComposer->getFrameCount());
        EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));

        // set up two deferred transactions on different frames - these should not yield composited
        // frames
        {
            TransactionScope ts(*sFakeComposer);
            ts.setAlpha(mFGSurfaceControl, 0.75);
            ts.deferTransactionUntil_legacy(mFGSurfaceControl, syncSurfaceControl->getHandle(),
                                            syncSurfaceControl->getSurface()->getNextFrameNumber());
        }
        EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));

        {
            TransactionScope ts(*sFakeComposer);
            ts.setPosition(mFGSurfaceControl, 128, 128);
            ts.deferTransactionUntil_legacy(mFGSurfaceControl, syncSurfaceControl->getHandle(),
                                            syncSurfaceControl->getSurface()->getNextFrameNumber() +
                                                    1);
        }
        EXPECT_EQ(4, sFakeComposer->getFrameCount());
        EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));

        // should trigger the first deferred transaction, but not the second one
        fillSurfaceRGBA8(syncSurfaceControl, DARK_GRAY);
        sFakeComposer->runVSyncAndWait();
        EXPECT_EQ(5, sFakeComposer->getFrameCount());

        referenceFrame[FG_LAYER].mPlaneAlpha = 0.75f;
        referenceFrame[SYNC_LAYER].mSwapCount++;
        EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));

        // should show up immediately since it's not deferred
        {
            TransactionScope ts(*sFakeComposer);
            ts.setAlpha(mFGSurfaceControl, 1.0);
        }
        referenceFrame[FG_LAYER].mPlaneAlpha = 1.f;
        EXPECT_EQ(6, sFakeComposer->getFrameCount());
        EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));

        // trigger the second deferred transaction
        fillSurfaceRGBA8(syncSurfaceControl, DARK_GRAY);
        sFakeComposer->runVSyncAndWait();
        // TODO: Compute from layer size?
        referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{128, 128, 128 + 64, 128 + 64};
        referenceFrame[SYNC_LAYER].mSwapCount++;
        EXPECT_EQ(7, sFakeComposer->getFrameCount());
        EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));
    }

    void Test_SetRelativeLayer() {
        constexpr int RELATIVE_LAYER = 2;
        auto relativeSurfaceControl = mComposerClient->createSurface(String8("Test Surface"), 64,
                                                                     64, PIXEL_FORMAT_RGBA_8888, 0);
        fillSurfaceRGBA8(relativeSurfaceControl, LIGHT_RED);

        // Now we stack the surface above the foreground surface and make sure it is visible.
        {
            TransactionScope ts(*sFakeComposer);
            ts.setPosition(relativeSurfaceControl, 64, 64);
            ts.show(relativeSurfaceControl);
            ts.setRelativeLayer(relativeSurfaceControl, mFGSurfaceControl->getHandle(), 1);
        }
        auto referenceFrame = mBaseFrame;
        // NOTE: All three layers will be visible as the surfaces are
        // transparent because of the RGBA format.
        referenceFrame.push_back(makeSimpleRect(64, 64, 64 + 64, 64 + 64));
        referenceFrame[RELATIVE_LAYER].mSwapCount = 1;
        EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));

        // A call to setLayer will override a call to setRelativeLayer
        {
            TransactionScope ts(*sFakeComposer);
            ts.setLayer(relativeSurfaceControl, 0);
        }

        // Previous top layer will now appear at the bottom.
        auto referenceFrame2 = mBaseFrame;
        referenceFrame2.insert(referenceFrame2.begin(), referenceFrame[RELATIVE_LAYER]);
        EXPECT_EQ(3, sFakeComposer->getFrameCount());
        EXPECT_TRUE(framesAreSame(referenceFrame2, sFakeComposer->getLatestFrame()));
    }

    sp<SurfaceComposerClient> mComposerClient;
    sp<SurfaceControl> mBGSurfaceControl;
    sp<SurfaceControl> mFGSurfaceControl;
    std::vector<RenderState> mBaseFrame;
    uint32_t mDisplayWidth;
    uint32_t mDisplayHeight;

    static inline FakeComposerClient* sFakeComposer;
};

using TransactionTest_2_1 = TransactionTest<FakeComposerService_2_1>;

TEST_F(TransactionTest_2_1, DISABLED_LayerMove) {
    Test_LayerMove();
}

TEST_F(TransactionTest_2_1, DISABLED_LayerResize) {
    Test_LayerResize();
}

TEST_F(TransactionTest_2_1, DISABLED_LayerCrop) {
    Test_LayerCrop();
}

TEST_F(TransactionTest_2_1, DISABLED_LayerSetLayer) {
    Test_LayerSetLayer();
}

TEST_F(TransactionTest_2_1, DISABLED_LayerSetLayerOpaque) {
    Test_LayerSetLayerOpaque();
}

TEST_F(TransactionTest_2_1, DISABLED_SetLayerStack) {
    Test_SetLayerStack();
}

TEST_F(TransactionTest_2_1, DISABLED_LayerShowHide) {
    Test_LayerShowHide();
}

TEST_F(TransactionTest_2_1, DISABLED_LayerSetAlpha) {
    Test_LayerSetAlpha();
}

TEST_F(TransactionTest_2_1, DISABLED_LayerSetFlags) {
    Test_LayerSetFlags();
}

TEST_F(TransactionTest_2_1, DISABLED_LayerSetMatrix) {
    Test_LayerSetMatrix();
}

TEST_F(TransactionTest_2_1, DISABLED_DeferredTransaction) {
    Test_DeferredTransaction();
}

TEST_F(TransactionTest_2_1, DISABLED_SetRelativeLayer) {
    Test_SetRelativeLayer();
}

template <typename FakeComposerService>
class ChildLayerTest : public TransactionTest<FakeComposerService> {
    using Base = TransactionTest<FakeComposerService>;

protected:
    constexpr static int CHILD_LAYER = 2;

    void SetUp() override {
        Base::SetUp();
        mChild = Base::mComposerClient->createSurface(String8("Child surface"), 10, 10,
                                                      PIXEL_FORMAT_RGBA_8888, 0,
                                                      Base::mFGSurfaceControl.get());
        fillSurfaceRGBA8(mChild, LIGHT_GRAY);

        Base::sFakeComposer->runVSyncAndWait();
        Base::mBaseFrame.push_back(makeSimpleRect(64, 64, 64 + 10, 64 + 10));
        Base::mBaseFrame[CHILD_LAYER].mSwapCount = 1;
        ASSERT_EQ(2, Base::sFakeComposer->getFrameCount());
        ASSERT_TRUE(framesAreSame(Base::mBaseFrame, Base::sFakeComposer->getLatestFrame()));
    }

    void TearDown() override {
        mChild = 0;
        Base::TearDown();
    }

    void Test_Positioning() {
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.show(mChild);
            ts.setPosition(mChild, 10, 10);
            // Move to the same position as in the original setup.
            ts.setPosition(Base::mFGSurfaceControl, 64, 64);
        }

        auto referenceFrame = Base::mBaseFrame;
        referenceFrame[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 64, 64 + 64};
        referenceFrame[CHILD_LAYER].mDisplayFrame =
                hwc_rect_t{64 + 10, 64 + 10, 64 + 10 + 10, 64 + 10 + 10};
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));

        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setPosition(Base::mFGSurfaceControl, 0, 0);
        }

        auto referenceFrame2 = Base::mBaseFrame;
        referenceFrame2[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 0 + 64, 0 + 64};
        referenceFrame2[CHILD_LAYER].mDisplayFrame =
                hwc_rect_t{0 + 10, 0 + 10, 0 + 10 + 10, 0 + 10 + 10};
        EXPECT_TRUE(framesAreSame(referenceFrame2, Base::sFakeComposer->getLatestFrame()));
    }

    void Test_Cropping() {
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.show(mChild);
            ts.setPosition(mChild, 0, 0);
            ts.setPosition(Base::mFGSurfaceControl, 0, 0);
            ts.setCrop_legacy(Base::mFGSurfaceControl, Rect(0, 0, 5, 5));
        }
        // NOTE: The foreground surface would be occluded by the child
        // now, but is included in the stack because the child is
        // transparent.
        auto referenceFrame = Base::mBaseFrame;
        referenceFrame[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 0 + 5, 0 + 5};
        referenceFrame[Base::FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 5.f, 5.f};
        referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 0 + 5, 0 + 5};
        referenceFrame[CHILD_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 5.f, 5.f};
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));
    }

    void Test_Constraints() {
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.show(mChild);
            ts.setPosition(Base::mFGSurfaceControl, 0, 0);
            ts.setPosition(mChild, 63, 63);
        }
        auto referenceFrame = Base::mBaseFrame;
        referenceFrame[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 64, 64};
        referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{63, 63, 64, 64};
        referenceFrame[CHILD_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 1.f, 1.f};
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));
    }

    void Test_Scaling() {
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setPosition(Base::mFGSurfaceControl, 0, 0);
        }
        auto referenceFrame = Base::mBaseFrame;
        referenceFrame[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 64, 64};
        referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 10, 10};
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));

        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setMatrix(Base::mFGSurfaceControl, 2.0, 0, 0, 2.0);
        }

        auto referenceFrame2 = Base::mBaseFrame;
        referenceFrame2[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 128, 128};
        referenceFrame2[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 20, 20};
        EXPECT_TRUE(framesAreSame(referenceFrame2, Base::sFakeComposer->getLatestFrame()));
    }

    void Test_LayerAlpha() {
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.show(mChild);
            ts.setPosition(mChild, 0, 0);
            ts.setPosition(Base::mFGSurfaceControl, 0, 0);
            ts.setAlpha(mChild, 0.5);
        }

        auto referenceFrame = Base::mBaseFrame;
        referenceFrame[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 64, 64};
        referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 10, 10};
        referenceFrame[CHILD_LAYER].mPlaneAlpha = 0.5f;
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));

        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setAlpha(Base::mFGSurfaceControl, 0.5);
        }

        auto referenceFrame2 = referenceFrame;
        referenceFrame2[Base::FG_LAYER].mPlaneAlpha = 0.5f;
        referenceFrame2[CHILD_LAYER].mPlaneAlpha = 0.25f;
        EXPECT_TRUE(framesAreSame(referenceFrame2, Base::sFakeComposer->getLatestFrame()));
    }

    void Test_ReparentChildren() {
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.show(mChild);
            ts.setPosition(mChild, 10, 10);
            ts.setPosition(Base::mFGSurfaceControl, 64, 64);
        }
        auto referenceFrame = Base::mBaseFrame;
        referenceFrame[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 64, 64 + 64};
        referenceFrame[CHILD_LAYER].mDisplayFrame =
                hwc_rect_t{64 + 10, 64 + 10, 64 + 10 + 10, 64 + 10 + 10};
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));

        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.reparentChildren(Base::mFGSurfaceControl, Base::mBGSurfaceControl->getHandle());
        }

        auto referenceFrame2 = referenceFrame;
        referenceFrame2[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 64, 64 + 64};
        referenceFrame2[CHILD_LAYER].mDisplayFrame = hwc_rect_t{10, 10, 10 + 10, 10 + 10};
        EXPECT_TRUE(framesAreSame(referenceFrame2, Base::sFakeComposer->getLatestFrame()));
    }

    void Test_DetachChildrenSameClient() {
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.show(mChild);
            ts.setPosition(mChild, 10, 10);
            ts.setPosition(Base::mFGSurfaceControl, 64, 64);
        }

        auto referenceFrame = Base::mBaseFrame;
        referenceFrame[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 64, 64 + 64};
        referenceFrame[CHILD_LAYER].mDisplayFrame =
                hwc_rect_t{64 + 10, 64 + 10, 64 + 10 + 10, 64 + 10 + 10};
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));

        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setPosition(Base::mFGSurfaceControl, 0, 0);
            ts.detachChildren(Base::mFGSurfaceControl);
        }

        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setPosition(Base::mFGSurfaceControl, 64, 64);
            ts.hide(mChild);
        }

        std::vector<RenderState> refFrame(2);
        refFrame[Base::BG_LAYER] = Base::mBaseFrame[Base::BG_LAYER];
        refFrame[Base::FG_LAYER] = Base::mBaseFrame[Base::FG_LAYER];

        EXPECT_TRUE(framesAreSame(refFrame, Base::sFakeComposer->getLatestFrame()));
    }

    void Test_DetachChildrenDifferentClient() {
        sp<SurfaceComposerClient> newComposerClient = new SurfaceComposerClient;
        sp<SurfaceControl> childNewClient =
                newComposerClient->createSurface(String8("New Child Test Surface"), 10, 10,
                                                 PIXEL_FORMAT_RGBA_8888, 0,
                                                 Base::mFGSurfaceControl.get());
        ASSERT_TRUE(childNewClient != nullptr);
        ASSERT_TRUE(childNewClient->isValid());
        fillSurfaceRGBA8(childNewClient, LIGHT_GRAY);

        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.hide(mChild);
            ts.show(childNewClient);
            ts.setPosition(childNewClient, 10, 10);
            ts.setPosition(Base::mFGSurfaceControl, 64, 64);
        }

        auto referenceFrame = Base::mBaseFrame;
        referenceFrame[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 64, 64 + 64};
        referenceFrame[CHILD_LAYER].mDisplayFrame =
                hwc_rect_t{64 + 10, 64 + 10, 64 + 10 + 10, 64 + 10 + 10};
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));

        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.detachChildren(Base::mFGSurfaceControl);
            ts.setPosition(Base::mFGSurfaceControl, 0, 0);
        }

        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setPosition(Base::mFGSurfaceControl, 64, 64);
            ts.setPosition(childNewClient, 0, 0);
            ts.hide(childNewClient);
        }

        // Nothing should have changed. The child control becomes a no-op
        // zombie on detach. See comments for detachChildren in the
        // SurfaceControl.h file.
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));
    }

    void Test_InheritNonTransformScalingFromParent() {
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.show(mChild);
            ts.setPosition(mChild, 0, 0);
            ts.setPosition(Base::mFGSurfaceControl, 0, 0);
        }

        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setOverrideScalingMode(Base::mFGSurfaceControl,
                                      NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
            // We cause scaling by 2.
            ts.setSize(Base::mFGSurfaceControl, 128, 128);
        }

        auto referenceFrame = Base::mBaseFrame;
        referenceFrame[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 128, 128};
        referenceFrame[Base::FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 64.f, 64.f};
        referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 20, 20};
        referenceFrame[CHILD_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 10.f, 10.f};
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));
    }

    // Regression test for b/37673612
    void Test_ChildrenWithParentBufferTransform() {
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.show(mChild);
            ts.setPosition(mChild, 0, 0);
            ts.setPosition(Base::mFGSurfaceControl, 0, 0);
        }

        // We set things up as in b/37673612 so that there is a mismatch between the buffer size and
        // the WM specified state size.
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setSize(Base::mFGSurfaceControl, 128, 64);
        }

        sp<Surface> s = Base::mFGSurfaceControl->getSurface();
        auto anw = static_cast<ANativeWindow*>(s.get());
        native_window_set_buffers_transform(anw, NATIVE_WINDOW_TRANSFORM_ROT_90);
        native_window_set_buffers_dimensions(anw, 64, 128);
        fillSurfaceRGBA8(Base::mFGSurfaceControl, RED);
        Base::sFakeComposer->runVSyncAndWait();

        // The child should still be in the same place and not have any strange scaling as in
        // b/37673612.
        auto referenceFrame = Base::mBaseFrame;
        referenceFrame[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 128, 64};
        referenceFrame[Base::FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 64.f, 128.f};
        referenceFrame[Base::FG_LAYER].mSwapCount++;
        referenceFrame[CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 10, 10};
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));
    }

    void Test_Bug36858924() {
        // Destroy the child layer
        mChild.clear();

        // Now recreate it as hidden
        mChild = Base::mComposerClient->createSurface(String8("Child surface"), 10, 10,
                                                      PIXEL_FORMAT_RGBA_8888,
                                                      ISurfaceComposerClient::eHidden,
                                                      Base::mFGSurfaceControl.get());

        // Show the child layer in a deferred transaction
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.deferTransactionUntil_legacy(mChild, Base::mFGSurfaceControl->getHandle(),
                                            Base::mFGSurfaceControl->getSurface()
                                                    ->getNextFrameNumber());
            ts.show(mChild);
        }

        // Render the foreground surface a few times
        //
        // Prior to the bugfix for b/36858924, this would usually hang while trying to fill the
        // third frame because SurfaceFlinger would never process the deferred transaction and would
        // therefore never acquire/release the first buffer
        ALOGI("Filling 1");
        fillSurfaceRGBA8(Base::mFGSurfaceControl, GREEN);
        Base::sFakeComposer->runVSyncAndWait();
        ALOGI("Filling 2");
        fillSurfaceRGBA8(Base::mFGSurfaceControl, BLUE);
        Base::sFakeComposer->runVSyncAndWait();
        ALOGI("Filling 3");
        fillSurfaceRGBA8(Base::mFGSurfaceControl, RED);
        Base::sFakeComposer->runVSyncAndWait();
        ALOGI("Filling 4");
        fillSurfaceRGBA8(Base::mFGSurfaceControl, GREEN);
        Base::sFakeComposer->runVSyncAndWait();
    }

    sp<SurfaceControl> mChild;
};

using ChildLayerTest_2_1 = ChildLayerTest<FakeComposerService_2_1>;

TEST_F(ChildLayerTest_2_1, DISABLED_Positioning) {
    Test_Positioning();
}

TEST_F(ChildLayerTest_2_1, DISABLED_Cropping) {
    Test_Cropping();
}

TEST_F(ChildLayerTest_2_1, DISABLED_Constraints) {
    Test_Constraints();
}

TEST_F(ChildLayerTest_2_1, DISABLED_Scaling) {
    Test_Scaling();
}

TEST_F(ChildLayerTest_2_1, DISABLED_LayerAlpha) {
    Test_LayerAlpha();
}

TEST_F(ChildLayerTest_2_1, DISABLED_ReparentChildren) {
    Test_ReparentChildren();
}

TEST_F(ChildLayerTest_2_1, DISABLED_DetachChildrenSameClient) {
    Test_DetachChildrenSameClient();
}

TEST_F(ChildLayerTest_2_1, DISABLED_DetachChildrenDifferentClient) {
    Test_DetachChildrenDifferentClient();
}

TEST_F(ChildLayerTest_2_1, DISABLED_InheritNonTransformScalingFromParent) {
    Test_InheritNonTransformScalingFromParent();
}

// Regression test for b/37673612
TEST_F(ChildLayerTest_2_1, DISABLED_ChildrenWithParentBufferTransform) {
    Test_ChildrenWithParentBufferTransform();
}

TEST_F(ChildLayerTest_2_1, DISABLED_Bug36858924) {
    Test_Bug36858924();
}

template <typename FakeComposerService>
class ChildColorLayerTest : public ChildLayerTest<FakeComposerService> {
    using Base = ChildLayerTest<FakeComposerService>;

protected:
    void SetUp() override {
        Base::SetUp();
        Base::mChild =
                Base::mComposerClient->createSurface(String8("Child surface"), 0, 0,
                                                     PIXEL_FORMAT_RGBA_8888,
                                                     ISurfaceComposerClient::eFXSurfaceEffect,
                                                     Base::mFGSurfaceControl.get());
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setColor(Base::mChild,
                        {LIGHT_GRAY.r / 255.0f, LIGHT_GRAY.g / 255.0f, LIGHT_GRAY.b / 255.0f});
            ts.setCrop_legacy(Base::mChild, Rect(0, 0, 10, 10));
        }

        Base::sFakeComposer->runVSyncAndWait();
        Base::mBaseFrame.push_back(makeSimpleRect(64, 64, 64 + 10, 64 + 10));
        Base::mBaseFrame[Base::CHILD_LAYER].mSourceCrop = hwc_frect_t{0.0f, 0.0f, 0.0f, 0.0f};
        Base::mBaseFrame[Base::CHILD_LAYER].mSwapCount = 0;
        ASSERT_EQ(2, Base::sFakeComposer->getFrameCount());
        ASSERT_TRUE(framesAreSame(Base::mBaseFrame, Base::sFakeComposer->getLatestFrame()));
    }

    void Test_LayerAlpha() {
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.show(Base::mChild);
            ts.setPosition(Base::mChild, 0, 0);
            ts.setPosition(Base::mFGSurfaceControl, 0, 0);
            ts.setAlpha(Base::mChild, 0.5);
        }

        auto referenceFrame = Base::mBaseFrame;
        referenceFrame[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 64, 64};
        referenceFrame[Base::CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 10, 10};
        referenceFrame[Base::CHILD_LAYER].mPlaneAlpha = 0.5f;
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));

        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setAlpha(Base::mFGSurfaceControl, 0.5);
        }

        auto referenceFrame2 = referenceFrame;
        referenceFrame2[Base::FG_LAYER].mPlaneAlpha = 0.5f;
        referenceFrame2[Base::CHILD_LAYER].mPlaneAlpha = 0.25f;
        EXPECT_TRUE(framesAreSame(referenceFrame2, Base::sFakeComposer->getLatestFrame()));
    }

    void Test_LayerZeroAlpha() {
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.show(Base::mChild);
            ts.setPosition(Base::mChild, 0, 0);
            ts.setPosition(Base::mFGSurfaceControl, 0, 0);
            ts.setAlpha(Base::mChild, 0.5);
        }

        auto referenceFrame = Base::mBaseFrame;
        referenceFrame[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 64, 64};
        referenceFrame[Base::CHILD_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 10, 10};
        referenceFrame[Base::CHILD_LAYER].mPlaneAlpha = 0.5f;
        EXPECT_TRUE(framesAreSame(referenceFrame, Base::sFakeComposer->getLatestFrame()));

        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setAlpha(Base::mFGSurfaceControl, 0.0f);
        }

        std::vector<RenderState> refFrame(1);
        refFrame[Base::BG_LAYER] = Base::mBaseFrame[Base::BG_LAYER];

        EXPECT_TRUE(framesAreSame(refFrame, Base::sFakeComposer->getLatestFrame()));
    }
};

using ChildColorLayerTest_2_1 = ChildColorLayerTest<FakeComposerService_2_1>;

TEST_F(ChildColorLayerTest_2_1, DISABLED_LayerAlpha) {
    Test_LayerAlpha();
}

TEST_F(ChildColorLayerTest_2_1, DISABLED_LayerZeroAlpha) {
    Test_LayerZeroAlpha();
}

template <typename FakeComposerService>
class LatchingTest : public TransactionTest<FakeComposerService> {
    using Base = TransactionTest<FakeComposerService>;

protected:
    void lockAndFillFGBuffer() { fillSurfaceRGBA8(Base::mFGSurfaceControl, RED, false); }

    void unlockFGBuffer() {
        sp<Surface> s = Base::mFGSurfaceControl->getSurface();
        ASSERT_EQ(NO_ERROR, s->unlockAndPost());
        Base::sFakeComposer->runVSyncAndWait();
    }

    void completeFGResize() {
        fillSurfaceRGBA8(Base::mFGSurfaceControl, RED);
        Base::sFakeComposer->runVSyncAndWait();
    }
    void restoreInitialState() {
        TransactionScope ts(*Base::sFakeComposer);
        ts.setSize(Base::mFGSurfaceControl, 64, 64);
        ts.setPosition(Base::mFGSurfaceControl, 64, 64);
        ts.setCrop_legacy(Base::mFGSurfaceControl, Rect(0, 0, 64, 64));
    }

    void Test_SurfacePositionLatching() {
        // By default position can be updated even while
        // a resize is pending.
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setSize(Base::mFGSurfaceControl, 32, 32);
            ts.setPosition(Base::mFGSurfaceControl, 100, 100);
        }

        // The size should not have updated as we have not provided a new buffer.
        auto referenceFrame1 = Base::mBaseFrame;
        referenceFrame1[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{100, 100, 100 + 64, 100 + 64};
        EXPECT_TRUE(framesAreSame(referenceFrame1, Base::sFakeComposer->getLatestFrame()));

        restoreInitialState();

        completeFGResize();

        auto referenceFrame2 = Base::mBaseFrame;
        referenceFrame2[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{100, 100, 100 + 32, 100 + 32};
        referenceFrame2[Base::FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 32.f, 32.f};
        referenceFrame2[Base::FG_LAYER].mSwapCount++;
        EXPECT_TRUE(framesAreSame(referenceFrame2, Base::sFakeComposer->getLatestFrame()));
    }

    void Test_CropLatching() {
        // Normally the crop applies immediately even while a resize is pending.
        {
            TransactionScope ts(*Base::sFakeComposer);
            ts.setSize(Base::mFGSurfaceControl, 128, 128);
            ts.setCrop_legacy(Base::mFGSurfaceControl, Rect(0, 0, 63, 63));
        }

        auto referenceFrame1 = Base::mBaseFrame;
        referenceFrame1[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 63, 64 + 63};
        referenceFrame1[Base::FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 63.f, 63.f};
        EXPECT_TRUE(framesAreSame(referenceFrame1, Base::sFakeComposer->getLatestFrame()));

        restoreInitialState();

        completeFGResize();

        auto referenceFrame2 = Base::mBaseFrame;
        referenceFrame2[Base::FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 63, 64 + 63};
        referenceFrame2[Base::FG_LAYER].mSourceCrop = hwc_frect_t{0.f, 0.f, 63.f, 63.f};
        referenceFrame2[Base::FG_LAYER].mSwapCount++;
        EXPECT_TRUE(framesAreSame(referenceFrame2, Base::sFakeComposer->getLatestFrame()));
    }
};

using LatchingTest_2_1 = LatchingTest<FakeComposerService_2_1>;

TEST_F(LatchingTest_2_1, DISABLED_SurfacePositionLatching) {
    Test_SurfacePositionLatching();
}

TEST_F(LatchingTest_2_1, DISABLED_CropLatching) {
    Test_CropLatching();
}

} // namespace

int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);

    auto* fakeEnvironment = new sftest::FakeHwcEnvironment;
    ::testing::AddGlobalTestEnvironment(fakeEnvironment);
    ::testing::InitGoogleMock(&argc, argv);
    return RUN_ALL_TESTS();
}

// TODO(b/129481165): remove the #pragma below and fix conversion issues
#pragma clang diagnostic pop // ignored "-Wconversion"