1/*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "hdi_composer_ut.h"
17#include <chrono>
18#include <cinttypes>
19#include <algorithm>
20#include "v1_2/include/idisplay_composer_interface.h"
21#include "v1_2/display_composer_type.h"
22#include "v1_0/display_buffer_type.h"
23#include "display_test.h"
24#include "display_test_utils.h"
25#include "hdi_composition_check.h"
26#include "hdi_test_device.h"
27#include "hdi_test_device_common.h"
28#include "hdi_test_display.h"
29#include "hdi_test_render_utils.h"
30#include "timer.h"
31#include <sys/time.h>
32#include <thread>
33
34using namespace OHOS::HDI::Display::Buffer::V1_0;
35using namespace OHOS::HDI::Display::Composer::V1_2;
36using namespace OHOS::HDI::Display::TEST;
37using namespace testing::ext;
38
39static sptr<Composer::V1_2::IDisplayComposerInterface> g_composerDevice = nullptr;
40static std::shared_ptr<IDisplayBuffer> g_gralloc = nullptr;
41static std::vector<uint32_t> g_displayIds;
42const int SLEEP_CONT_10 = 10;
43const int SLEEP_CONT_100 = 100;
44const int SLEEP_CONT_2000 = 2000;
45static bool g_isOnSeamlessChangeCalled = false;
46static bool g_isOnModeCalled = false;
47static bool g_threadCtrl = false;
48
49static inline std::shared_ptr<HdiTestDisplay> GetFirstDisplay()
50{
51    return HdiTestDevice::GetInstance().GetFirstDisplay();
52}
53
54static int32_t CheckComposition(std::vector<LayerSettings> &layers, BufferHandle* clientBuffer,
55    uint32_t checkType = HdiCompositionCheck::CHECK_VERTEX)
56{
57    DISPLAY_TEST_CHK_RETURN((clientBuffer == nullptr), DISPLAY_NULL_PTR, DISPLAY_TEST_LOGE("client buffer is nullptr"));
58    return HdiCompositionCheck::GetInstance().Check(layers, *clientBuffer, checkType);
59}
60
61static std::shared_ptr<HdiTestLayer> CreateTestLayer(LayerSettings setting, uint32_t zorder)
62{
63    int ret;
64    HdiTestDevice::GetInstance();
65    DISPLAY_TEST_LOGD("color 0x%x", setting.color);
66    std::shared_ptr<HdiTestDisplay> display = HdiTestDevice::GetInstance().GetFirstDisplay();
67    DISPLAY_TEST_CHK_RETURN((display == nullptr), nullptr, DISPLAY_TEST_LOGE("can not get display"));
68
69    std::shared_ptr<HdiTestLayer> layer = display->CreateHdiTestLayer(setting.bufferSize.w, setting.bufferSize.h);
70    DISPLAY_TEST_CHK_RETURN((layer == nullptr), nullptr, DISPLAY_TEST_LOGE("can not create hdi test layer"));
71
72    layer->SetLayerPosition(setting.displayRect);
73
74    layer->SetCompType(setting.compositionType);
75
76    if ((setting.alpha >= 0) && (setting.alpha <= 0xff)) { // alpha rang 0x00 ~ 0xff
77        LayerAlpha alpha = { 0 };
78        alpha.gAlpha = setting.alpha;
79        alpha.enGlobalAlpha = true;
80        layer->SetAlpha(alpha);
81    }
82    HdiGrallocBuffer* handle = layer->GetFrontBuffer();
83    DISPLAY_TEST_CHK_RETURN((handle == nullptr), nullptr, DISPLAY_TEST_LOGE("can not get front buffer"));
84    ClearColor(*(handle->Get()), setting.color);
85    ret = layer->SwapFrontToBackQ();
86    DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), nullptr, DISPLAY_TEST_LOGE("SwapFrontToBackQ failed"));
87    layer->SetZorder(zorder);
88    layer->SetBlendType(setting.blendType);
89    layer->SetTransform(setting.rotate);
90    return layer;
91}
92
93static int PrepareAndCommit()
94{
95    int ret;
96    DISPLAY_TEST_LOGD();
97    std::shared_ptr<HdiTestDisplay> display = HdiTestDevice::GetInstance().GetFirstDisplay();
98    DISPLAY_TEST_CHK_RETURN((display == nullptr), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("can not get display"));
99
100    ret = display->PrepareDisplayLayers(); // 确定顶压策略(是否走GPU合成)、刷新layer列表
101    DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE,
102        DISPLAY_TEST_LOGE("PrepareDisplayLayers failed"));
103
104    ret = display->Commit(); // 送显
105    DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("Commit failed"));
106    return DISPLAY_SUCCESS;
107}
108
109static void LoopCommit()
110{
111    while (!g_threadCtrl) {
112        PrepareAndCommit();
113        std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_CONT_10));
114    }
115}
116
117static void TestVBlankCallback(unsigned int sequence, uint64_t ns, void* data)
118{
119    static uint64_t lastns;
120    DISPLAY_TEST_LOGD("seq %{public}d  ns %" PRId64 " duration %" PRId64 " ns", sequence, ns, (ns - lastns));
121    lastns = ns;
122    VblankCtr::GetInstance().NotifyVblank(sequence, ns, data);
123}
124
125static void AdjustLayerSettings(std::vector<LayerSettings> &settings, uint32_t w, uint32_t h)
126{
127    DISPLAY_TEST_LOGD();
128    for (uint32_t i = 0; i < settings.size(); i++) {
129        LayerSettings& setting = settings[i];
130        DISPLAY_TEST_LOGD(" ratio w: %f  ratio h: %f", setting.rectRatio.w, setting.rectRatio.h);
131        if ((setting.rectRatio.w > 0.0f) && (setting.rectRatio.h > 0.0f)) {
132            setting.displayRect.h = static_cast<uint32_t>(setting.rectRatio.h * h);
133            setting.displayRect.w = static_cast<uint32_t>(setting.rectRatio.w * w);
134            setting.displayRect.x = static_cast<uint32_t>(setting.rectRatio.x * w);
135            setting.displayRect.y = static_cast<uint32_t>(setting.rectRatio.y * h);
136            DISPLAY_TEST_LOGD("display rect adust form %f %f %f %f to %{public}d %{public}d %{public}d %{public}d ",
137                setting.rectRatio.x, setting.rectRatio.y, setting.rectRatio.w, setting.rectRatio.h,
138                setting.displayRect.x, setting.displayRect.y, setting.displayRect.w, setting.displayRect.h);
139        }
140
141        if ((setting.bufferRatio.h > 0.0f) || (setting.bufferRatio.w > 0.0f)) {
142            setting.bufferSize.h = static_cast<uint32_t>(setting.bufferRatio.h * h);
143            setting.bufferSize.w = static_cast<uint32_t>(setting.bufferRatio.w * w);
144            DISPLAY_TEST_LOGD("buffer size adjust for %f %f to %{public}d %{public}d",
145                setting.bufferRatio.w, setting.bufferRatio.h, setting.bufferSize.w, setting.bufferSize.h);
146        }
147
148        if ((setting.bufferSize.w == 0) || (setting.bufferSize.h == 0)) {
149            DISPLAY_TEST_LOGD("buffer size adjust for %{public}d %{public}d to %{public}d %{public}d",
150                setting.bufferSize.w, setting.bufferSize.h, setting.displayRect.w, setting.displayRect.h);
151
152            setting.bufferSize.w = setting.displayRect.w;
153            setting.bufferSize.h = setting.displayRect.h;
154        }
155    }
156}
157
158static std::vector<std::shared_ptr<HdiTestLayer>> CreateLayers(std::vector<LayerSettings> &settings)
159{
160    DISPLAY_TEST_LOGD("settings %{public}zd", settings.size());
161    std::vector<std::shared_ptr<HdiTestLayer>> layers;
162    DisplayModeInfo mode = GetFirstDisplay()->GetCurrentMode();
163    AdjustLayerSettings(settings, mode.width, mode.height);
164    for (uint32_t i = 0; i < settings.size(); i++) {
165        LayerSettings setting = settings[i];
166
167        auto layer = CreateTestLayer(setting, i);
168        layers.push_back(layer);
169    }
170
171    return layers;
172}
173
174static inline void PresentAndCheck(std::vector<LayerSettings> &layerSettings,
175    uint32_t checkType = HdiCompositionCheck::CHECK_VERTEX)
176{
177    int ret = PrepareAndCommit();
178    ASSERT_TRUE((ret == DISPLAY_SUCCESS));
179    if ((GetFirstDisplay()->SnapShot()) != nullptr) {
180        HdiTestDevice::GetInstance().GetGrallocInterface()->InvalidateCache(*(GetFirstDisplay()->SnapShot()));
181        ret = CheckComposition(layerSettings, GetFirstDisplay()->SnapShot(), checkType);
182        ASSERT_TRUE((ret == DISPLAY_SUCCESS));
183    }
184}
185
186static void DestroyLayer(std::shared_ptr<HdiTestLayer> layer)
187{
188    std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_CONT_100));
189    auto ret = g_composerDevice->DestroyLayer(g_displayIds[0], layer->GetId());
190    if (ret != DISPLAY_SUCCESS && ret != DISPLAY_NOT_SUPPORT) {
191        DISPLAY_TEST_LOGD("DestroyLayer fail or not support, ret: %{public}d", ret);
192        return;
193    }
194    std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_CONT_100));
195}
196
197void DeviceTest::SetUpTestCase()
198{
199    int ret = HdiTestDevice::GetInstance().InitDevice();
200    ASSERT_TRUE(ret == DISPLAY_SUCCESS);
201
202    g_composerDevice = HdiTestDevice::GetInstance().GetDeviceInterface();
203    ASSERT_TRUE(g_composerDevice != nullptr);
204
205    g_gralloc.reset(IDisplayBuffer::Get());
206    ASSERT_TRUE(g_gralloc != nullptr);
207
208    g_displayIds = HdiTestDevice::GetInstance().GetDevIds();
209    ASSERT_TRUE(g_displayIds.size() > 0);
210}
211
212void DeviceTest::TearDownTestCase()
213{
214    HdiTestDevice::GetInstance().Clear();
215    HdiTestDevice::GetInstance().GetFirstDisplay()->ResetClientLayer();
216}
217
218void VblankCtr::NotifyVblank(unsigned int sequence, uint64_t ns, const void* data)
219{
220    DISPLAY_TEST_LOGD();
221    if (data != nullptr) {
222        DISPLAY_TEST_LOGD("sequence = %{public}u, ns = %" PRIu64 "", sequence, ns);
223    }
224    std::unique_lock<std::mutex> lg(vblankMutex_);
225    hasVblank_ = true;
226    vblankCondition_.notify_one();
227    DISPLAY_TEST_LOGD();
228}
229
230VblankCtr::~VblankCtr() {}
231
232int32_t VblankCtr::WaitVblank(uint32_t ms)
233{
234    bool ret = false;
235    DISPLAY_TEST_LOGD();
236    std::unique_lock<std::mutex> lck(vblankMutex_);
237    ret = vblankCondition_.wait_for(lck, std::chrono::milliseconds(ms), [=] { return hasVblank_; });
238    DISPLAY_TEST_LOGD();
239    if (!ret) {
240        return DISPLAY_FAILURE;
241    }
242    return DISPLAY_SUCCESS;
243}
244
245HWTEST_F(DeviceTest, test_SetClientBufferCacheCount, TestSize.Level1)
246{
247    const uint32_t CACHE_COUNT = 5;
248    auto ret = g_composerDevice->SetClientBufferCacheCount(g_displayIds[0], CACHE_COUNT);
249    EXPECT_EQ(DISPLAY_SUCCESS, ret);
250}
251
252HWTEST_F(DeviceTest, test_GetDisplayCapability, TestSize.Level1)
253{
254    DisplayCapability info;
255    auto ret = g_composerDevice->GetDisplayCapability(g_displayIds[0], info);
256    EXPECT_EQ(DISPLAY_SUCCESS, ret);
257}
258
259HWTEST_F(DeviceTest, test_GetDisplaySupportedModes, TestSize.Level1)
260{
261    std::vector<DisplayModeInfo> modes;
262    auto ret = g_composerDevice->GetDisplaySupportedModes(g_displayIds[0], modes);
263    EXPECT_EQ(DISPLAY_SUCCESS, ret);
264}
265
266HWTEST_F(DeviceTest, test_GetDisplayMode, TestSize.Level1)
267{
268    uint32_t MODE = 0;
269    auto ret = g_composerDevice->GetDisplayMode(g_displayIds[0], MODE);
270    EXPECT_EQ(DISPLAY_SUCCESS, ret);
271}
272
273HWTEST_F(DeviceTest, test_SetDisplayMode, TestSize.Level1)
274{
275    const uint32_t MODE = 0;
276    auto ret = g_composerDevice->SetDisplayMode(g_displayIds[0], MODE);
277    EXPECT_EQ(DISPLAY_SUCCESS, ret);
278}
279
280HWTEST_F(DeviceTest, test_GetDisplayPowerStatus, TestSize.Level1)
281{
282    Composer::V1_0::DispPowerStatus powerStatus = Composer::V1_0::DispPowerStatus::POWER_STATUS_OFF;
283    auto ret = g_composerDevice->GetDisplayPowerStatus(g_displayIds[0], powerStatus);
284    EXPECT_EQ(DISPLAY_SUCCESS, ret);
285}
286
287HWTEST_F(DeviceTest, test_SetDisplayPowerStatus, TestSize.Level1)
288{
289    auto ret = g_composerDevice->SetDisplayPowerStatus(g_displayIds[0],
290        Composer::V1_0::DispPowerStatus::POWER_STATUS_STANDBY);
291    EXPECT_EQ(DISPLAY_SUCCESS, ret);
292
293    ret = g_composerDevice->SetDisplayPowerStatus(g_displayIds[0], Composer::V1_0::DispPowerStatus::POWER_STATUS_ON);
294    EXPECT_EQ(DISPLAY_SUCCESS, ret);
295}
296
297#ifdef DISPLAY_COMMUNITY
298HWTEST_F(DeviceTest, test_GetDisplayBacklight, TestSize.Level1)
299{
300    uint32_t level;
301    auto ret = g_composerDevice->GetDisplayBacklight(g_displayIds[0], level);
302    EXPECT_EQ(DISPLAY_SUCCESS, ret);
303}
304#endif
305
306HWTEST_F(DeviceTest, test_SetDisplayBacklight, TestSize.Level1)
307{
308    const uint32_t LEVEL = 10;
309    auto ret = g_composerDevice->SetDisplayBacklight(g_displayIds[0], LEVEL);
310    EXPECT_EQ(DISPLAY_SUCCESS, ret);
311}
312
313HWTEST_F(DeviceTest, test_GetDisplayProperty, TestSize.Level1)
314{
315    const uint32_t PROPERTY_ID = 1;
316    uint64_t propertyValue = 0;
317    auto ret = g_composerDevice->GetDisplayProperty(g_displayIds[0], PROPERTY_ID, propertyValue);
318    int32_t result = DISPLAY_FAILURE;
319    if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) {
320        result = DISPLAY_SUCCESS;
321    }
322    EXPECT_EQ(DISPLAY_SUCCESS, result);
323}
324
325HWTEST_F(DeviceTest, test_SetHardwareCursorPosition, TestSize.Level1)
326{
327    int32_t x = 1;
328    int32_t y = 1;
329    auto ret = g_composerDevice->SetHardwareCursorPosition(g_displayIds[0], x, y);
330    if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) {
331        ret = DISPLAY_SUCCESS;
332    }
333    EXPECT_EQ(DISPLAY_SUCCESS, ret);
334}
335
336HWTEST_F(DeviceTest, test_EnableHardwareCursorStats, TestSize.Level1)
337{
338    bool enable = true;
339    auto ret = g_composerDevice->EnableHardwareCursorStats(g_displayIds[0], enable);
340    if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) {
341        ret = DISPLAY_SUCCESS;
342    }
343    EXPECT_EQ(DISPLAY_SUCCESS, ret);
344}
345
346HWTEST_F(DeviceTest, test_GetHardwareCursorStats, TestSize.Level1)
347{
348    uint32_t frameCount = 0;
349    uint32_t vsyncCount = 0;
350    auto ret = g_composerDevice->GetHardwareCursorStats(g_displayIds[0], frameCount, vsyncCount);
351    if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) {
352        ret = DISPLAY_SUCCESS;
353    }
354    EXPECT_EQ(DISPLAY_SUCCESS, ret);
355}
356
357HWTEST_F(DeviceTest, test_GetDisplayCompChange, TestSize.Level1)
358{
359    std::vector<uint32_t> layers {};
360    std::vector<int32_t> type {};
361    auto ret = g_composerDevice->GetDisplayCompChange(g_displayIds[0], layers, type);
362    EXPECT_EQ(DISPLAY_SUCCESS, ret);
363}
364
365HWTEST_F(DeviceTest, test_SetDisplayClientCrop, TestSize.Level1)
366{
367    const int32_t WIDTH = 1920;
368    const int32_t HEIGHT = 1080;
369    IRect rect = {0, 0, WIDTH, HEIGHT};
370    auto ret = g_composerDevice->SetDisplayClientCrop(g_displayIds[0], rect);
371    // not support
372    EXPECT_EQ(DISPLAY_FAILURE, ret);
373}
374
375HWTEST_F(DeviceTest, test_GetDisplayReleaseFence, TestSize.Level1)
376{
377    std::vector<uint32_t> layers {};
378    std::vector<int32_t> fences {};
379    auto ret = g_composerDevice->GetDisplayReleaseFence(g_displayIds[0], layers, fences);
380    EXPECT_EQ(DISPLAY_SUCCESS, ret);
381}
382
383HWTEST_F(DeviceTest, test_SetDisplayClientBuffer, TestSize.Level1)
384{
385    BufferHandle* buffer = nullptr;
386    const int32_t WIDTH = 800;
387    const int32_t HEIGHT = 600;
388
389    AllocInfo info;
390    info.width  = WIDTH;
391    info.height = HEIGHT;
392    info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
393            OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
394            OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
395    info.format = Composer::V1_0::PIXEL_FMT_RGBA_8888;
396
397    g_gralloc->AllocMem(info, buffer);
398    ASSERT_TRUE(buffer != nullptr);
399
400    uint32_t bufferSeq = 1;
401    auto ret = g_composerDevice->SetDisplayClientBuffer(g_displayIds[0], buffer, bufferSeq, -1);
402    g_gralloc->FreeMem(*buffer);
403    EXPECT_EQ(DISPLAY_SUCCESS, ret);
404}
405
406HWTEST_F(DeviceTest, test_SetDisplayClientDamage, TestSize.Level1)
407{
408    const int32_t WIDTH = 1920;
409    const int32_t HEIGHT = 1080;
410    IRect rect = {0, 0, WIDTH, HEIGHT};
411    std::vector<IRect> vRects;
412    vRects.push_back(rect);
413    auto ret = g_composerDevice->SetDisplayClientDamage(g_displayIds[0], vRects);
414    // not support
415    EXPECT_EQ(DISPLAY_SUCCESS, ret);
416}
417
418HWTEST_F(DeviceTest, test_CreateVirtualDisplay, TestSize.Level1)
419{
420    const uint32_t WIDTH = 1920;
421    const uint32_t HEIGHT = 1080;
422    int32_t format = 0;
423    uint32_t devId = 0;
424    auto ret = g_composerDevice->CreateVirtualDisplay(WIDTH, HEIGHT, format, devId);
425    // not support
426    EXPECT_EQ(DISPLAY_FAILURE, ret);
427}
428
429HWTEST_F(DeviceTest, test_DestroyVirtualDisplay, TestSize.Level1)
430{
431    uint32_t devId = 0;
432    auto ret = g_composerDevice->DestroyVirtualDisplay(devId);
433    // not support
434    EXPECT_EQ(DISPLAY_FAILURE, ret);
435}
436
437HWTEST_F(DeviceTest, test_SetVirtualDisplayBuffer, TestSize.Level1)
438{
439    BufferHandle* buffer = nullptr;
440    int32_t fence = -1;
441    const int32_t WIDTH = 800;
442    const int32_t HEIGHT = 600;
443
444    AllocInfo info;
445    info.width  = WIDTH;
446    info.height = HEIGHT;
447    info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
448            OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
449            OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
450    info.format = Composer::V1_0::PIXEL_FMT_RGBA_8888;
451
452    g_gralloc->AllocMem(info, buffer);
453    ASSERT_TRUE(buffer != nullptr);
454
455    auto ret = g_composerDevice->SetVirtualDisplayBuffer(g_displayIds[0], *buffer, fence);
456    g_gralloc->FreeMem(*buffer);
457    // not support
458    EXPECT_EQ(DISPLAY_FAILURE, ret);
459}
460
461HWTEST_F(DeviceTest, test_SetDisplayProperty, TestSize.Level1)
462{
463    const uint32_t PROPERTY_ID = 1;
464    const uint64_t PROPERTY_VALUE = 0;
465    auto ret = g_composerDevice->SetDisplayProperty(g_displayIds[0], PROPERTY_ID, PROPERTY_VALUE);
466    // not support
467    EXPECT_EQ(DISPLAY_FAILURE, ret);
468}
469
470HWTEST_F(DeviceTest, test_SetLayerCrop, TestSize.Level1)
471{
472    std::vector<LayerSettings> settings = {
473        {
474            .rectRatio = { 0, 0, 1.0f, 1.0f },
475            .color = RED
476        },
477    };
478    std::vector<uint32_t> splitColors = { { RED, GREEN, YELLOW, BLUE, PINK, PURPLE, CYAN, TRANSPARENT } };
479
480    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
481    ASSERT_TRUE((layers.size() > 0));
482    // split the buffer
483    auto layer = layers[0];
484    HdiGrallocBuffer* handle = layer->GetBackBuffer(); // the backbuffer has not present now
485    ASSERT_TRUE((handle != nullptr));
486    auto splitRects = SplitBuffer(*(handle->Get()), splitColors);
487    PrepareAndCommit();
488    for (uint32_t i = 0; i < splitRects.size(); i++) {
489        settings[0].color = splitColors[i];
490        layer->SetLayerCrop(splitRects[i]);
491        PresentAndCheck(settings);
492    }
493
494    DestroyLayer(layer);
495}
496
497HWTEST_F(DeviceTest, test_SetLayerZorder, TestSize.Level1)
498{
499    std::vector<LayerSettings> settings = {
500        {
501            .rectRatio = { 0, 0, 1.0f, 1.0f },
502            .color = RED
503        },
504        {
505            .rectRatio = { 0, 0, 1.0f, 1.0f },
506            .color = GREEN
507        },
508        {
509            .rectRatio = { 0, 0, 1.0f, 1.0f },
510            .color = YELLOW
511        },
512    };
513
514    std::vector<std::vector<int>> zorders = {
515        { 3, 2, 1 }, { 1, 3, 2 }, { 3, 1, 2 }, { 1, 2, 3 }, { 2, 1, 3 }, { 2, 3, 1 },
516    };
517    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
518
519    for (const auto& zorderList : zorders) {
520        // adjust the zorder
521        for (uint32_t i = 0; i < zorderList.size(); i++) {
522            settings[i].zorder = zorderList[i];
523            layers[i]->SetZorder(zorderList[i]);
524        }
525        std::vector<LayerSettings> tempSettings = settings;
526        std::sort(tempSettings.begin(), tempSettings.end(),
527            [=](const auto& l, auto const & r) { return l.zorder < r.zorder; });
528        // present and check
529        PresentAndCheck(tempSettings);
530    }
531    HdiTestDevice::GetInstance().Clear();
532}
533
534HWTEST_F(DeviceTest, test_SetLayerPreMulti, TestSize.Level1)
535{
536    std::vector<LayerSettings> settings = {
537        {
538            .rectRatio = { 0, 0, 1.0f, 1.0f },
539            .color = GREEN
540        },
541    };
542
543    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
544    ASSERT_TRUE((layers.size() > 0));
545    PrepareAndCommit();
546
547    auto layer = layers[0];
548    bool preMul = true;
549    auto ret = g_composerDevice->SetLayerPreMulti(g_displayIds[0], layer->GetId(), preMul);
550
551    PrepareAndCommit();
552    HdiTestDevice::GetInstance().Clear();
553    EXPECT_EQ(DISPLAY_SUCCESS, ret);
554
555    DestroyLayer(layer);
556}
557
558HWTEST_F(DeviceTest, test_SetLayerAlpha, TestSize.Level1)
559{
560    std::vector<LayerSettings> settings = {
561        {
562            .rectRatio = { 0, 0, 1.0f, 1.0f },
563            .color = GREEN
564        },
565        {
566            .rectRatio = { 0, 0, 1.0f, 1.0f },
567            .color = RED
568        },
569    };
570
571    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
572    ASSERT_TRUE((layers.size() > 0));
573
574    auto layer = layers[1];
575    LayerAlpha alpha = { 0 };
576    alpha.enGlobalAlpha = true;
577    alpha.enPixelAlpha = true;
578    alpha.gAlpha = 0;
579    alpha.alpha0 = 0;
580    alpha.alpha1 = 0;
581    layer->SetAlpha(alpha);
582
583    PrepareAndCommit();
584    HdiTestDevice::GetInstance().Clear();
585
586    DestroyLayer(layer);
587}
588
589HWTEST_F(DeviceTest, test_SetLayerRegion, TestSize.Level1)
590{
591    std::vector<LayerSettings> settings = {
592        {.rectRatio = {0, 0, 1.0f, 1.0f}, .color = GREEN, .alpha = 0xFF}
593    };
594
595    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
596    ASSERT_TRUE((layers.size() > 0));
597
598    const int32_t WIDTH = 100;
599    const int32_t HEIGHT = 100;
600    auto layer = layers[0];
601    IRect rect = {0, 0, WIDTH, HEIGHT};
602    auto ret = g_composerDevice->SetLayerRegion(g_displayIds[0], layer->GetId(), rect);
603
604    PrepareAndCommit();
605    EXPECT_EQ(DISPLAY_SUCCESS, ret);
606
607    DestroyLayer(layer);
608}
609
610HWTEST_F(DeviceTest, test_SetLayerDirtyRegion, TestSize.Level1)
611{
612    std::vector<LayerSettings> settings = {
613        {
614            .rectRatio = { 0, 0, 1.0f, 1.0f },
615            .color = BLUE
616        }
617    };
618
619    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
620    ASSERT_TRUE((layers.size() > 0));
621
622    auto layer = layers[0];
623
624    const int32_t WIDTH = 100;
625    const int32_t HEIGHT = 100;
626    IRect rect = {0, 0, WIDTH, HEIGHT};
627    std::vector<IRect> vRects;
628    vRects.push_back(rect);
629    auto ret = g_composerDevice->SetLayerDirtyRegion(g_displayIds[0], layer->GetId(), vRects);
630
631    PrepareAndCommit();
632    HdiTestDevice::GetInstance().Clear();
633
634    EXPECT_EQ(DISPLAY_SUCCESS, ret);
635
636    DestroyLayer(layer);
637}
638
639HWTEST_F(DeviceTest, test_SetLayerTransformMode, TestSize.Level1)
640{
641    std::vector<LayerSettings> settings = {
642        {
643            .rectRatio = { 0, 0, 1.0f, 1.0f },
644            .color = RED
645        }
646    };
647
648    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
649    ASSERT_TRUE((layers.size() > 0));
650
651    PrepareAndCommit();
652
653    auto layer = layers[0];
654
655    TransformType type = TransformType::ROTATE_90;
656    auto ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
657    PrepareAndCommit();
658
659    type = TransformType::ROTATE_180;
660    ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
661    PrepareAndCommit();
662
663    type = TransformType::ROTATE_270;
664    ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
665    PrepareAndCommit();
666
667    EXPECT_EQ(DISPLAY_SUCCESS, ret);
668
669    DestroyLayer(layer);
670}
671
672HWTEST_F(DeviceTest, test_SetLayerVisibleRegion, TestSize.Level1)
673{
674    std::vector<LayerSettings> settings = {
675        {
676            .rectRatio = { 0, 0, 1.0f, 1.0f },
677            .color = BLUE
678        }
679    };
680
681    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
682    ASSERT_TRUE((layers.size() > 0));
683    PrepareAndCommit();
684    auto layer = layers[0];
685
686    const int32_t WIDTH = 500;
687    const int32_t HEIGHT = 500;
688    IRect region = {0, 0, WIDTH, HEIGHT};
689    std::vector<IRect> regions = {};
690    regions.push_back(region);
691    auto ret = g_composerDevice->SetLayerVisibleRegion(g_displayIds[0], layer->GetId(), regions);
692    PrepareAndCommit();
693
694    EXPECT_EQ(DISPLAY_SUCCESS, ret);
695
696    DestroyLayer(layer);
697}
698
699HWTEST_F(DeviceTest, test_SetLayerBuffer, TestSize.Level1)
700{
701    std::vector<LayerSettings> settings = {
702        {
703            .rectRatio = { 0, 0, 1.0f, 1.0f },
704            .color = GREEN
705        }
706    };
707
708    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
709    ASSERT_TRUE((layers.size() > 0));
710
711    auto layer = layers[0];
712
713    auto graphicBuffer = layer->AcquireBackBuffer();
714    int32_t ret = graphicBuffer->SetGraphicBuffer([&](const BufferHandle* buffer, uint32_t seqNo) -> int32_t {
715        std::vector<uint32_t> deletingList;
716        int32_t result = g_composerDevice->SetLayerBuffer(g_displayIds[0], layer->GetId(), buffer, seqNo, -1,
717            deletingList);
718        return result;
719    });
720    PrepareAndCommit();
721
722    EXPECT_EQ(DISPLAY_SUCCESS, ret);
723
724    DestroyLayer(layer);
725}
726
727HWTEST_F(DeviceTest, test_SetLayerCompositionType, TestSize.Level1)
728{
729    std::vector<LayerSettings> settings = {
730        {
731            .rectRatio = { 0, 0, 1.0f, 1.0f },
732            .color = BLUE
733        }
734    };
735
736    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
737    ASSERT_TRUE((layers.size() > 0));
738
739    auto layer = layers[0];
740
741    Composer::V1_0::CompositionType type = Composer::V1_0::CompositionType::COMPOSITION_CLIENT;
742    auto ret = g_composerDevice->SetLayerCompositionType(g_displayIds[0], layer->GetId(), type);
743
744    PrepareAndCommit();
745
746    EXPECT_EQ(DISPLAY_SUCCESS, ret);
747
748    DestroyLayer(layer);
749}
750
751HWTEST_F(DeviceTest, test_SetLayerBlendType, TestSize.Level1)
752{
753    std::vector<LayerSettings> settings = {
754        {
755            .rectRatio = { 0, 0, 1.0f, 1.0f },
756            .color = GREEN
757        }
758    };
759
760    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
761    ASSERT_TRUE((layers.size() > 0));
762
763    auto layer = layers[0];
764
765    BlendType type = BlendType::BLEND_NONE;
766    auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
767
768    PrepareAndCommit();
769
770    EXPECT_EQ(DISPLAY_SUCCESS, ret);
771
772    DestroyLayer(layer);
773}
774
775HWTEST_F(DeviceTest, test_SetLayerMaskInfo, TestSize.Level1)
776{
777    std::vector<LayerSettings> settings = {
778        {
779            .rectRatio = { 0, 0, 1.0f, 1.0f },
780            .color = GREEN
781        }
782    };
783
784    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
785    ASSERT_TRUE((layers.size() > 0));
786
787    auto layer = layers[0];
788
789    MaskInfo maskInfo = MaskInfo::LAYER_HBM_SYNC;
790    auto ret = g_composerDevice->SetLayerMaskInfo(g_displayIds[0], layer->GetId(), maskInfo);
791
792    HdiTestDevice::GetInstance().Clear();
793
794    EXPECT_EQ(DISPLAY_SUCCESS, ret);
795}
796
797HWTEST_F(DeviceTest, test_SetLayerColor, TestSize.Level1)
798{
799    std::vector<LayerSettings> settings = {
800        {
801            .rectRatio = { 0, 0, 1.0f, 1.0f },
802            .color = GREEN
803        }
804    };
805
806    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
807    ASSERT_TRUE((layers.size() > 0));
808
809    auto layer = layers[0];
810    const uint32_t COLOR_R = 155;
811    const uint32_t COLOR_G = 224;
812    const uint32_t COLOR_B = 88;
813    const uint32_t COLOR_A = 128;
814
815    LayerColor layerColor = {
816        .r = COLOR_R,
817        .g = COLOR_G,
818        .b = COLOR_B,
819        .a = COLOR_A
820    };
821
822    auto ret = g_composerDevice->SetLayerColor(g_displayIds[0], layer->GetId(), layerColor);
823
824    PrepareAndCommit();
825
826    EXPECT_EQ(DISPLAY_SUCCESS, ret);
827
828    DestroyLayer(layer);
829}
830
831HWTEST_F(DeviceTest, test_DestroyLayer, TestSize.Level1)
832{
833    std::vector<LayerSettings> settings = {
834        {
835            .rectRatio = { 0, 0, 1.0f, 1.0f },
836            .color = PURPLE
837        }
838    };
839
840    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
841    ASSERT_TRUE((layers.size() > 0));
842    auto layer = layers[0];
843    PrepareAndCommit();
844
845    sleep(1);
846    auto ret = g_composerDevice->DestroyLayer(g_displayIds[0], layer->GetId());
847    EXPECT_EQ(DISPLAY_SUCCESS, ret);
848    std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_CONT_100));
849}
850
851HWTEST_F(DeviceTest, test_RegDisplayVBlankCallback, TestSize.Level1)
852{
853    int ret;
854    DISPLAY_TEST_LOGD();
855    std::shared_ptr<HdiTestDisplay> display = HdiTestDevice::GetInstance().GetFirstDisplay();
856    ASSERT_TRUE(display != nullptr) << "get display failed";
857    ret = display->RegDisplayVBlankCallback(TestVBlankCallback, nullptr);
858    ASSERT_TRUE(ret == DISPLAY_SUCCESS) << "RegDisplayVBlankCallback failed";
859    ret = display->SetDisplayVsyncEnabled(true);
860    ASSERT_TRUE(ret == DISPLAY_SUCCESS) << "SetDisplayVsyncEnabled failed";
861
862    std::vector<LayerSettings> settings = {
863        {
864            .rectRatio = { 0, 0, 1.0f, 1.0f },
865            .color = PINK
866        },
867    };
868    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
869    ASSERT_TRUE((layers.size() > 0));
870    VblankCtr::GetInstance().hasVblank_ = false;
871    PrepareAndCommit();
872    ret = VblankCtr::GetInstance().WaitVblank(SLEEP_CONT_100); // 100ms
873    ASSERT_TRUE(ret == DISPLAY_SUCCESS) << "WaitVblank timeout";
874    ret = display->SetDisplayVsyncEnabled(false);
875    ASSERT_TRUE(ret == DISPLAY_SUCCESS) << "SetDisplayVsyncEnabled failed";
876    usleep(SLEEP_CONT_100 * SLEEP_CONT_2000); // wait for 100ms avoid the last vsync.
877    VblankCtr::GetInstance().hasVblank_ = false;
878    ret = VblankCtr::GetInstance().WaitVblank(SLEEP_CONT_100); // 100ms
879    ASSERT_TRUE(ret != DISPLAY_SUCCESS) << "vblank do not disable";
880
881    DestroyLayer(layers[0]);
882}
883
884void DeviceTest::OnMode(uint32_t modeId, uint64_t vBlankPeriod, void* data)
885{
886    g_isOnModeCalled = true;
887}
888
889void DeviceTest::OnSeamlessChange(uint32_t devId, void* data)
890{
891    g_isOnSeamlessChangeCalled = true;
892}
893
894HWTEST_F(DeviceTest, test_GetDisplaySupportedModesExt, TestSize.Level1)
895{
896    std::vector<DisplayModeInfoExt> modes;
897    auto ret = g_composerDevice->GetDisplaySupportedModesExt(g_displayIds[0], modes);
898    if (ret == DISPLAY_NOT_SUPPORT) {
899        DISPLAY_TEST_LOGD("GetDisplaySupportedModesExt not support");
900        return;
901    }
902    EXPECT_EQ(DISPLAY_SUCCESS, ret);
903}
904
905HWTEST_F(DeviceTest, test_SetDisplayModeAsync, TestSize.Level1)
906{
907    g_isOnModeCalled = false;
908    std::vector<DisplayModeInfo> oldModes;
909    std::vector<LayerSettings> settings = {
910        {
911            .rectRatio = { 0, 0, 1.0f, 1.0f },
912            .color = RED
913        }
914    };
915
916    // 先注册VBlankCallback
917    auto ret = g_composerDevice->RegDisplayVBlankCallback(g_displayIds[0], TestVBlankCallback, nullptr);
918    ASSERT_TRUE(ret == DISPLAY_SUCCESS) << "RegDisplayVBlankCallback failed";
919
920    ret = g_composerDevice->GetDisplaySupportedModes(g_displayIds[0], oldModes);
921    ASSERT_EQ(DISPLAY_SUCCESS, ret);
922    ASSERT_EQ(oldModes.size() > 0, true);
923
924    uint32_t modeid = oldModes[0].id;
925    ret = g_composerDevice->SetDisplayModeAsync(g_displayIds[0], modeid, OnMode);
926    if (ret == DISPLAY_NOT_SUPPORT) {
927        return;
928    }
929    EXPECT_EQ(DISPLAY_SUCCESS, ret);
930    if (ret == DISPLAY_SUCCESS) {
931        std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
932        ASSERT_TRUE((layers.size() > 0));
933        g_threadCtrl = false;
934        std::thread commitThread(LoopCommit);
935        std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_CONT_100));
936        g_threadCtrl = true;
937        commitThread.join();
938        ASSERT_EQ(g_isOnModeCalled, true);
939
940        DestroyLayer(layers[0]);
941    }
942}
943
944HWTEST_F(DeviceTest, test_GetDisplayVBlankPeriod, TestSize.Level1)
945{
946    uint64_t period = 0;
947    auto ret = g_composerDevice->GetDisplayVBlankPeriod(g_displayIds[0], period);
948    if (ret == DISPLAY_NOT_SUPPORT) {
949        DISPLAY_TEST_LOGD("GetDisplayVBlankPeriod not support");
950        return;
951    }
952    EXPECT_EQ(DISPLAY_SUCCESS, ret);
953    EXPECT_EQ(period != 0, true);
954}
955
956HWTEST_F(DeviceTest, test_RegSeamlessChangeCallback, TestSize.Level1)
957{
958    g_isOnSeamlessChangeCalled = false;
959    auto ret = g_composerDevice->RegSeamlessChangeCallback(OnSeamlessChange, nullptr);
960    if (ret == DISPLAY_NOT_SUPPORT) {
961        DISPLAY_TEST_LOGD("RegSeamlessChangeCallback not support");
962        return;
963    }
964    EXPECT_EQ(DISPLAY_SUCCESS, ret);
965    if (ret == DISPLAY_SUCCESS) {
966        std::this_thread::sleep_for(std::chrono::milliseconds(5000));
967        ASSERT_EQ(g_isOnSeamlessChangeCalled, true);
968    }
969}
970
971HWTEST_F(DeviceTest, test_SetLayerPerFrameParameter, TestSize.Level1)
972{
973    std::vector<LayerSettings> settings = {
974        {
975            .rectRatio = { 0, 0, 1.0f, 1.0f },
976            .color = GREEN
977        },
978    };
979
980    std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
981    ASSERT_TRUE((layers.size() > 0));
982    auto layer = layers[0];
983    std::vector<std::string> ValidKeys = { "FilmFilter", "ArsrDoEnhance", "SDRBrightnessRatio", "BrightnessNit",
984        "ViewGroupHasValidAlpha", "SourceCropTuning" };
985    std::string key;
986    std::vector<int8_t> value = { 1 };
987    key = "NotSupportKey";
988    auto ret = g_composerDevice->SetLayerPerFrameParameter(g_displayIds[0], layer->GetId(), key, value);
989    if (ret == DISPLAY_NOT_SUPPORT) {
990        DISPLAY_TEST_LOGD("SetLayerPerFrameParameter not support");
991        return;
992    }
993    ASSERT_EQ(ret, -1) << "key not support, ret:" << ret;
994    key = ValidKeys[0];
995    ret = g_composerDevice->SetLayerPerFrameParameter(g_displayIds[0], layer->GetId(), key, value);
996    ASSERT_EQ(ret, 0) << "key support, ret:" << ret;
997    if (ret == DISPLAY_NOT_SUPPORT) {
998        DISPLAY_TEST_LOGD("SetLayerPerFrameParameter not support");
999        return;
1000    }
1001    EXPECT_EQ(DISPLAY_SUCCESS, ret);
1002}
1003
1004HWTEST_F(DeviceTest, test_GetSupportedLayerPerFrameParameterKey, TestSize.Level1)
1005{
1006    std::vector<std::string> keys;
1007    auto ret = g_composerDevice->GetSupportedLayerPerFrameParameterKey(keys);
1008    if (ret == DISPLAY_NOT_SUPPORT) {
1009        DISPLAY_TEST_LOGD("GetSupportedLayerPerFrameParameterKey not support");
1010        return;
1011    }
1012    EXPECT_EQ(DISPLAY_SUCCESS, ret);
1013}
1014
1015HWTEST_F(DeviceTest, test_SetDisplayOverlayResolution, TestSize.Level1)
1016{
1017    DisplayModeInfo mode = GetFirstDisplay()->GetCurrentMode();
1018    auto ret = g_composerDevice->SetDisplayOverlayResolution(g_displayIds[0], mode.width, mode.height);
1019    if (ret == DISPLAY_NOT_SUPPORT) {
1020        DISPLAY_TEST_LOGD("SetDisplayOverlayResolution not support");
1021        return;
1022    }
1023    EXPECT_EQ(DISPLAY_SUCCESS, ret);
1024}
1025
1026static void TestRefreshCallback(uint32_t devId, void* data)
1027{
1028}
1029
1030HWTEST_F(DeviceTest, test_RegRefreshCallback, TestSize.Level1)
1031{
1032    auto ret = g_composerDevice->RegRefreshCallback(TestRefreshCallback, nullptr);
1033    if (ret == DISPLAY_NOT_SUPPORT) {
1034        DISPLAY_TEST_LOGD("RegRefreshCallback not support");
1035        return;
1036    }
1037    EXPECT_EQ(DISPLAY_SUCCESS, ret);
1038}
1039
1040HWTEST_F(DeviceTest, test_GetDisplaySupportedColorGamuts, TestSize.Level1)
1041{
1042    std::vector<ColorGamut> gamuts;
1043    auto ret = g_composerDevice->GetDisplaySupportedColorGamuts(g_displayIds[0], gamuts);
1044    if (ret == DISPLAY_NOT_SUPPORT) {
1045        DISPLAY_TEST_LOGD("GetDisplaySupportedColorGamuts not support");
1046        return;
1047    }
1048    EXPECT_EQ(DISPLAY_SUCCESS, ret);
1049}
1050
1051HWTEST_F(DeviceTest, test_GetHDRCapabilityInfos, TestSize.Level1)
1052{
1053    HDRCapability info = { 0 };
1054    auto ret = g_composerDevice->GetHDRCapabilityInfos(g_displayIds[0], info);
1055    if (ret == DISPLAY_NOT_SUPPORT) {
1056        DISPLAY_TEST_LOGD("GetHDRCapabilityInfos not support");
1057        return;
1058    }
1059    EXPECT_EQ(DISPLAY_SUCCESS, ret);
1060}
1061