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_0/include/idisplay_composer_interface.h"
21 #include "v1_0/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
31 using namespace OHOS::HDI::Display::Buffer::V1_0;
32 using namespace OHOS::HDI::Display::Composer::V1_0;
33 using namespace OHOS::HDI::Display::TEST;
34 using namespace testing::ext;
35
36 static sptr<IDisplayComposerInterface> g_composerDevice = nullptr;
37 static std::shared_ptr<IDisplayBuffer> g_gralloc = nullptr;
38 static std::vector<uint32_t> g_displayIds;
39 const int SLEEP_CONT_100 = 100;
40 const int SLEEP_CONT_2000 = 2000;
41
GetFirstDisplay()42 static inline std::shared_ptr<HdiTestDisplay> GetFirstDisplay()
43 {
44 return HdiTestDevice::GetInstance().GetFirstDisplay();
45 }
46
CheckComposition(std::vector<LayerSettings> & layers,BufferHandle * clientBuffer,uint32_t checkType=HdiCompositionCheck::CHECK_VERTEX)47 static int32_t CheckComposition(std::vector<LayerSettings> &layers, BufferHandle* clientBuffer,
48 uint32_t checkType = HdiCompositionCheck::CHECK_VERTEX)
49 {
50 DISPLAY_TEST_CHK_RETURN((clientBuffer == nullptr), DISPLAY_NULL_PTR, DISPLAY_TEST_LOGE("client buffer is nullptr"));
51 return HdiCompositionCheck::GetInstance().Check(layers, *clientBuffer, checkType);
52 }
53
CreateTestLayer(LayerSettings setting,uint32_t zorder)54 static std::shared_ptr<HdiTestLayer> CreateTestLayer(LayerSettings setting, uint32_t zorder)
55 {
56 int ret;
57 HdiTestDevice::GetInstance();
58 DISPLAY_TEST_LOGE("color 0x%x", setting.color);
59 std::shared_ptr<HdiTestDisplay> display = HdiTestDevice::GetInstance().GetFirstDisplay();
60 DISPLAY_TEST_CHK_RETURN((display == nullptr), nullptr, DISPLAY_TEST_LOGE("can not get display"));
61
62 std::shared_ptr<HdiTestLayer> layer = display->CreateHdiTestLayer(setting.bufferSize.w, setting.bufferSize.h);
63 DISPLAY_TEST_CHK_RETURN((layer == nullptr), nullptr, DISPLAY_TEST_LOGE("can not create hdi test layer"));
64
65 layer->SetLayerPosition(setting.displayRect);
66
67 layer->SetCompType(setting.compositionType);
68
69 if ((setting.alpha >= 0) && (setting.alpha <= 0xff)) { // alpha rang 0x00 ~ 0xff
70 LayerAlpha alpha = { 0 };
71 alpha.gAlpha = setting.alpha;
72 alpha.enGlobalAlpha = true;
73 layer->SetAlpha(alpha);
74 }
75 HdiGrallocBuffer* handle = layer->GetFrontBuffer();
76 DISPLAY_TEST_CHK_RETURN((handle == nullptr), nullptr, DISPLAY_TEST_LOGE("can not get front buffer"));
77 ClearColor(*(handle->Get()), setting.color);
78 ret = layer->SwapFrontToBackQ();
79 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), nullptr, DISPLAY_TEST_LOGE("SwapFrontToBackQ failed"));
80 layer->SetZorder(zorder);
81 layer->SetBlendType(setting.blendType);
82 layer->SetTransform(setting.rotate);
83 return layer;
84 }
85
PrepareAndPrensent()86 static int PrepareAndPrensent()
87 {
88 int ret;
89 DISPLAY_TEST_LOGE();
90 std::shared_ptr<HdiTestDisplay> display = HdiTestDevice::GetInstance().GetFirstDisplay();
91 DISPLAY_TEST_CHK_RETURN((display == nullptr), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("can not get display"));
92
93 ret = display->PrepareDisplayLayers();
94 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE,
95 DISPLAY_TEST_LOGE("PrepareDisplayLayers failed"));
96
97 ret = display->Commit();
98 DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("Commit failed"));
99 return DISPLAY_SUCCESS;
100 }
101
TestVBlankCallback(unsigned int sequence,uint64_t ns,void * data)102 static void TestVBlankCallback(unsigned int sequence, uint64_t ns, void* data)
103 {
104 static uint64_t lastns;
105 DISPLAY_TEST_LOGE("seq %{public}d ns %" PRId64 " duration %" PRId64 " ns", sequence, ns, (ns - lastns));
106 lastns = ns;
107 VblankCtr::GetInstance().NotifyVblank(sequence, ns, data);
108 }
109
AdjustLayerSettings(std::vector<LayerSettings> & settings,uint32_t w,uint32_t h)110 static void AdjustLayerSettings(std::vector<LayerSettings> &settings, uint32_t w, uint32_t h)
111 {
112 DISPLAY_TEST_LOGE();
113 for (uint32_t i = 0; i < settings.size(); i++) {
114 LayerSettings& setting = settings[i];
115 DISPLAY_TEST_LOGE(" ratio w: %f ratio h: %f", setting.rectRatio.w, setting.rectRatio.h);
116 if ((setting.rectRatio.w > 0.0f) && (setting.rectRatio.h > 0.0f)) {
117 setting.displayRect.h = static_cast<uint32_t>(setting.rectRatio.h * h);
118 setting.displayRect.w = static_cast<uint32_t>(setting.rectRatio.w * w);
119 setting.displayRect.x = static_cast<uint32_t>(setting.rectRatio.x * w);
120 setting.displayRect.y = static_cast<uint32_t>(setting.rectRatio.y * h);
121 DISPLAY_TEST_LOGE("display rect adust form %f %f %f %f to %{public}d %{public}d %{public}d %{public}d ",
122 setting.rectRatio.x, setting.rectRatio.y, setting.rectRatio.w, setting.rectRatio.h, setting.displayRect.x,
123 setting.displayRect.y, setting.displayRect.w, setting.displayRect.h);
124 }
125
126 if ((setting.bufferRatio.h > 0.0f) || (setting.bufferRatio.w > 0.0f)) {
127 setting.bufferSize.h = static_cast<uint32_t>(setting.bufferRatio.h * h);
128 setting.bufferSize.w = static_cast<uint32_t>(setting.bufferRatio.w * w);
129 DISPLAY_TEST_LOGE("buffer size adjust for %f %f to %{public}d %{public}d",
130 setting.bufferRatio.w, setting.bufferRatio.h, setting.bufferSize.w, setting.bufferSize.h);
131 }
132
133 if ((setting.bufferSize.w == 0) || (setting.bufferSize.h == 0)) {
134 DISPLAY_TEST_LOGE("buffer size adjust for %{public}d %{public}d to %{public}d %{public}d",
135 setting.bufferSize.w, setting.bufferSize.h, setting.displayRect.w, setting.displayRect.h);
136
137 setting.bufferSize.w = setting.displayRect.w;
138 setting.bufferSize.h = setting.displayRect.h;
139 }
140 }
141 }
142
CreateLayers(std::vector<LayerSettings> & settings)143 static std::vector<std::shared_ptr<HdiTestLayer>> CreateLayers(std::vector<LayerSettings> &settings)
144 {
145 DISPLAY_TEST_LOGE("settings %{public}zd", settings.size());
146 std::vector<std::shared_ptr<HdiTestLayer>> layers;
147 DisplayModeInfo mode = GetFirstDisplay()->GetCurrentMode();
148 AdjustLayerSettings(settings, mode.width, mode.height);
149 for (uint32_t i = 0; i < settings.size(); i++) {
150 LayerSettings setting = settings[i];
151
152 auto layer = CreateTestLayer(setting, i);
153 layers.push_back(layer);
154 }
155
156 return layers;
157 }
158
PresentAndCheck(std::vector<LayerSettings> & layerSettings,uint32_t checkType=HdiCompositionCheck::CHECK_VERTEX)159 static inline void PresentAndCheck(std::vector<LayerSettings> &layerSettings,
160 uint32_t checkType = HdiCompositionCheck::CHECK_VERTEX)
161 {
162 int ret = PrepareAndPrensent();
163 ASSERT_TRUE((ret == DISPLAY_SUCCESS));
164 if ((GetFirstDisplay()->SnapShot()) != nullptr) {
165 HdiTestDevice::GetInstance().GetGrallocInterface()->InvalidateCache(*(GetFirstDisplay()->SnapShot()));
166 ret = CheckComposition(layerSettings, GetFirstDisplay()->SnapShot(), checkType);
167 ASSERT_TRUE((ret == DISPLAY_SUCCESS));
168 }
169 }
170
SetUpTestCase()171 void DeviceTest::SetUpTestCase()
172 {
173 int ret = HdiTestDevice::GetInstance().InitDevice();
174 ASSERT_TRUE(ret == DISPLAY_SUCCESS);
175
176 g_composerDevice = HdiTestDevice::GetInstance().GetDeviceInterface();
177 ASSERT_TRUE(g_composerDevice != nullptr);
178
179 g_gralloc.reset(IDisplayBuffer::Get());
180 ASSERT_TRUE(g_gralloc != nullptr);
181
182 g_displayIds = HdiTestDevice::GetInstance().GetDevIds();
183 ASSERT_TRUE(g_displayIds.size() > 0);
184 }
185
TearDownTestCase()186 void DeviceTest::TearDownTestCase()
187 {
188 HdiTestDevice::GetInstance().Clear();
189 HdiTestDevice::GetInstance().GetFirstDisplay()->ResetClientLayer();
190 }
191
NotifyVblank(unsigned int sequence,uint64_t ns,const void * data)192 void VblankCtr::NotifyVblank(unsigned int sequence, uint64_t ns, const void* data)
193 {
194 DISPLAY_TEST_LOGE();
195 if (data != nullptr) {
196 DISPLAY_TEST_LOGE("sequence = %{public}u, ns = %" PRIu64 "", sequence, ns);
197 }
198 std::unique_lock<std::mutex> lg(vblankMutex_);
199 hasVblank_ = true;
200 vblankCondition_.notify_one();
201 DISPLAY_TEST_LOGE();
202 }
203
~VblankCtr()204 VblankCtr::~VblankCtr() {}
205
WaitVblank(uint32_t ms)206 int32_t VblankCtr::WaitVblank(uint32_t ms)
207 {
208 bool ret = false;
209 DISPLAY_TEST_LOGE();
210 std::unique_lock<std::mutex> lck(vblankMutex_);
211 hasVblank_ = false; // must wait next vblank
212 ret = vblankCondition_.wait_for(lck, std::chrono::milliseconds(ms), [=] { return hasVblank_; });
213 DISPLAY_TEST_LOGE();
214 if (!ret) {
215 return DISPLAY_FAILURE;
216 }
217 return DISPLAY_SUCCESS;
218 }
219
220 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0000, TestSize.Level1)
221 {
222 const uint32_t CACHE_COUNT = 5;
223 auto ret = g_composerDevice->SetClientBufferCacheCount(g_displayIds[0], CACHE_COUNT);
224 EXPECT_EQ(DISPLAY_SUCCESS, ret);
225 }
226 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0010, TestSize.Level1)
227 {
228 DisplayCapability info;
229 auto ret = g_composerDevice->GetDisplayCapability(g_displayIds[0], info);
230 EXPECT_EQ(DISPLAY_SUCCESS, ret);
231 }
232
233 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0020, TestSize.Level1)
234 {
235 std::vector<DisplayModeInfo> modes;
236 auto ret = g_composerDevice->GetDisplaySupportedModes(g_displayIds[0], modes);
237 EXPECT_EQ(DISPLAY_SUCCESS, ret);
238 }
239
240 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0030, TestSize.Level1)
241 {
242 uint32_t MODE = 0;
243 auto ret = g_composerDevice->GetDisplayMode(g_displayIds[0], MODE);
244 EXPECT_EQ(DISPLAY_SUCCESS, ret);
245 }
246
247 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0040, TestSize.Level1)
248 {
249 const uint32_t MODE = 0;
250 auto ret = g_composerDevice->SetDisplayMode(g_displayIds[0], MODE);
251 EXPECT_EQ(DISPLAY_SUCCESS, ret);
252 }
253
254 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0050, TestSize.Level1)
255 {
256 DispPowerStatus powerStatus = DispPowerStatus::POWER_STATUS_OFF;
257 auto ret = g_composerDevice->GetDisplayPowerStatus(g_displayIds[0], powerStatus);
258 EXPECT_EQ(DISPLAY_SUCCESS, ret);
259 }
260
261 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0060, TestSize.Level1)
262 {
263 auto ret = g_composerDevice->SetDisplayPowerStatus(g_displayIds[0], DispPowerStatus::POWER_STATUS_STANDBY);
264 EXPECT_EQ(DISPLAY_SUCCESS, ret);
265
266 ret = g_composerDevice->SetDisplayPowerStatus(g_displayIds[0], DispPowerStatus::POWER_STATUS_ON);
267 EXPECT_EQ(DISPLAY_SUCCESS, ret);
268 }
269
270 #ifdef DISPLAY_COMMUNITY
271 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0070, TestSize.Level1)
272 {
273 uint32_t level;
274 auto ret = g_composerDevice->GetDisplayBacklight(g_displayIds[0], level);
275 EXPECT_EQ(DISPLAY_SUCCESS, ret);
276 }
277 #endif
278
279 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0080, TestSize.Level1)
280 {
281 const uint32_t LEVEL = 10;
282 auto ret = g_composerDevice->SetDisplayBacklight(g_displayIds[0], LEVEL);
283 EXPECT_EQ(DISPLAY_SUCCESS, ret);
284 }
285
286 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0090, TestSize.Level1)
287 {
288 const uint32_t PROPERTY_ID = 1;
289 uint64_t propertyValue = 0;
290 auto ret = g_composerDevice->GetDisplayProperty(g_displayIds[0], PROPERTY_ID, propertyValue);
291 // not support
292 EXPECT_EQ(DISPLAY_FAILURE, ret);
293 }
294
295 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0100, TestSize.Level1)
296 {
297 std::vector<uint32_t> layers {};
298 std::vector<int32_t> type {};
299 auto ret = g_composerDevice->GetDisplayCompChange(g_displayIds[0], layers, type);
300 EXPECT_EQ(DISPLAY_SUCCESS, ret);
301 }
302
303 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0110, TestSize.Level1)
304 {
305 const int32_t WIDTH = 1920;
306 const int32_t HEIGHT = 1080;
307 IRect rect = {0, 0, WIDTH, HEIGHT};
308 auto ret = g_composerDevice->SetDisplayClientCrop(g_displayIds[0], rect);
309 // not support
310 EXPECT_EQ(DISPLAY_FAILURE, ret);
311 }
312
313 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0120, TestSize.Level1)
314 {
315 std::vector<uint32_t> layers {};
316 std::vector<int32_t> fences {};
317 auto ret = g_composerDevice->GetDisplayReleaseFence(g_displayIds[0], layers, fences);
318 EXPECT_EQ(DISPLAY_SUCCESS, ret);
319 }
320
321 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0130, TestSize.Level1)
322 {
323 BufferHandle* buffer = nullptr;
324 const int32_t WIDTH = 800;
325 const int32_t HEIGHT = 600;
326
327 AllocInfo info;
328 info.width = WIDTH;
329 info.height = HEIGHT;
330 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
331 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
332 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
333 info.format = PIXEL_FMT_RGBA_8888;
334
335 g_gralloc->AllocMem(info, buffer);
336 ASSERT_TRUE(buffer != nullptr);
337
338 uint32_t bufferSeq = 1;
339 auto ret = g_composerDevice->SetDisplayClientBuffer(g_displayIds[0], buffer, bufferSeq, -1);
340 g_gralloc->FreeMem(*buffer);
341 EXPECT_EQ(DISPLAY_SUCCESS, ret);
342 }
343
344 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0140, TestSize.Level1)
345 {
346 const int32_t WIDTH = 1920;
347 const int32_t HEIGHT = 1080;
348 IRect rect = {0, 0, WIDTH, HEIGHT};
349 std::vector<IRect> vRects;
350 vRects.push_back(rect);
351 auto ret = g_composerDevice->SetDisplayClientDamage(g_displayIds[0], vRects);
352 // not support
353 EXPECT_EQ(DISPLAY_SUCCESS, ret);
354 }
355
356 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0150, TestSize.Level1)
357 {
358 const uint32_t WIDTH = 1920;
359 const uint32_t HEIGHT = 1080;
360 int32_t format = 0;
361 uint32_t devId = 0;
362 auto ret = g_composerDevice->CreateVirtualDisplay(WIDTH, HEIGHT, format, devId);
363 // not support
364 EXPECT_EQ(DISPLAY_FAILURE, ret);
365 }
366
367 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0160, TestSize.Level1)
368 {
369 uint32_t devId = 0;
370 auto ret = g_composerDevice->DestroyVirtualDisplay(devId);
371 // not support
372 EXPECT_EQ(DISPLAY_FAILURE, ret);
373 }
374
375 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0170, TestSize.Level1)
376 {
377 BufferHandle* buffer = nullptr;
378 int32_t fence = -1;
379 const int32_t WIDTH = 800;
380 const int32_t HEIGHT = 600;
381
382 AllocInfo info;
383 info.width = WIDTH;
384 info.height = HEIGHT;
385 info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
386 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
387 OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
388 info.format = PIXEL_FMT_RGBA_8888;
389
390 g_gralloc->AllocMem(info, buffer);
391 ASSERT_TRUE(buffer != nullptr);
392
393 auto ret = g_composerDevice->SetVirtualDisplayBuffer(g_displayIds[0], *buffer, fence);
394 g_gralloc->FreeMem(*buffer);
395 // not support
396 EXPECT_EQ(DISPLAY_FAILURE, ret);
397 }
398
399 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0180, TestSize.Level1)
400 {
401 const uint32_t PROPERTY_ID = 1;
402 const uint64_t PROPERTY_VALUE = 0;
403 auto ret = g_composerDevice->SetDisplayProperty(g_displayIds[0], PROPERTY_ID, PROPERTY_VALUE);
404 // not support
405 EXPECT_EQ(DISPLAY_FAILURE, ret);
406 }
407
408 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0190, TestSize.Level1)
409 {
410 std::vector<LayerSettings> settings = {
411 {
412 .rectRatio = { 0, 0, 1.0f, 1.0f },
413 .color = RED
414 },
415 };
416 std::vector<uint32_t> splitColors = { { RED, GREEN, YELLOW, BLUE, PINK, PURPLE, CYAN, TRANSPARENT } };
417
418 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
419 ASSERT_TRUE((layers.size() > 0));
420 // split the buffer
421 auto layer = layers[0];
422 HdiGrallocBuffer* handle = layer->GetBackBuffer(); // the backbuffer has not present now
423 ASSERT_TRUE((handle != nullptr));
424 auto splitRects = SplitBuffer(*(handle->Get()), splitColors);
425 PrepareAndPrensent();
426 for (uint32_t i = 0; i < splitRects.size(); i++) {
427 settings[0].color = splitColors[i];
428 layer->SetLayerCrop(splitRects[i]);
429 PresentAndCheck(settings);
430 }
431 }
432
433 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0200, TestSize.Level1)
434 {
435 std::vector<LayerSettings> settings = {
436 {
437 .rectRatio = { 0, 0, 1.0f, 1.0f },
438 .color = RED
439 },
440 {
441 .rectRatio = { 0, 0, 1.0f, 1.0f },
442 .color = GREEN
443 },
444 {
445 .rectRatio = { 0, 0, 1.0f, 1.0f },
446 .color = YELLOW
447 },
448 };
449
450 std::vector<std::vector<int>> zorders = {
451 { 3, 2, 1 }, { 1, 3, 2 }, { 3, 1, 2 }, { 1, 2, 3 }, { 2, 1, 3 }, { 2, 3, 1 },
452 };
453 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
454
455 for (const auto& zorderList : zorders) {
456 // adjust the zorder
457 for (uint32_t i = 0; i < zorderList.size(); i++) {
458 settings[i].zorder = zorderList[i];
459 layers[i]->SetZorder(zorderList[i]);
460 }
461 std::vector<LayerSettings> tempSettings = settings;
462 std::sort(tempSettings.begin(), tempSettings.end(),
__anon6605dd050202(const auto& l, auto const & r) 463 [=](const auto& l, auto const & r) { return l.zorder < r.zorder; });
464 // present and check
465 PresentAndCheck(tempSettings);
466 }
467 HdiTestDevice::GetInstance().Clear();
468 }
469
470 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0210, TestSize.Level1)
471 {
472 std::vector<LayerSettings> settings = {
473 {
474 .rectRatio = { 0, 0, 1.0f, 1.0f },
475 .color = GREEN
476 },
477 };
478
479 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
480 ASSERT_TRUE((layers.size() > 0));
481 PrepareAndPrensent();
482
483 auto layer = layers[0];
484 bool preMul = true;
485 auto ret = g_composerDevice->SetLayerPreMulti(g_displayIds[0], layer->GetId(), preMul);
486
487 PrepareAndPrensent();
488 HdiTestDevice::GetInstance().Clear();
489 EXPECT_EQ(DISPLAY_SUCCESS, ret);
490 }
491
492 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0220, TestSize.Level1)
493 {
494 std::vector<LayerSettings> settings = {
495 {
496 .rectRatio = { 0, 0, 1.0f, 1.0f },
497 .color = GREEN
498 },
499 {
500 .rectRatio = { 0, 0, 1.0f, 1.0f },
501 .color = RED
502 },
503 };
504
505 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
506 ASSERT_TRUE((layers.size() > 0));
507
508 auto layer = layers[1];
509 LayerAlpha alpha = { 0 };
510 alpha.enGlobalAlpha = true;
511 alpha.enPixelAlpha = true;
512 alpha.gAlpha = 0;
513 alpha.alpha0 = 0;
514 alpha.alpha1 = 0;
515 layer->SetAlpha(alpha);
516
517 PrepareAndPrensent();
518 HdiTestDevice::GetInstance().Clear();
519 }
520
521 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0230, TestSize.Level1)
522 {
523 std::vector<LayerSettings> settings = {
524 {.rectRatio = {0, 0, 1.0f, 1.0f}, .color = GREEN, .alpha = 0xFF}
525 };
526
527 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
528 ASSERT_TRUE((layers.size() > 0));
529
530 const int32_t WIDTH = 100;
531 const int32_t HEIGHT = 100;
532 auto layer = layers[0];
533 IRect rect = {0, 0, WIDTH, HEIGHT};
534 auto ret = g_composerDevice->SetLayerRegion(g_displayIds[0], layer->GetId(), rect);
535
536 PrepareAndPrensent();
537 EXPECT_EQ(DISPLAY_SUCCESS, ret);
538 }
539
540 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0240, TestSize.Level1)
541 {
542 std::vector<LayerSettings> settings = {
543 {
544 .rectRatio = { 0, 0, 1.0f, 1.0f },
545 .color = BLUE
546 }
547 };
548
549 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
550 ASSERT_TRUE((layers.size() > 0));
551
552 auto layer = layers[0];
553
554 const int32_t WIDTH = 100;
555 const int32_t HEIGHT = 100;
556 IRect rect = {0, 0, WIDTH, HEIGHT};
557 std::vector<IRect> vRects;
558 vRects.push_back(rect);
559 auto ret = g_composerDevice->SetLayerDirtyRegion(g_displayIds[0], layer->GetId(), vRects);
560
561 PrepareAndPrensent();
562 HdiTestDevice::GetInstance().Clear();
563
564 EXPECT_EQ(DISPLAY_SUCCESS, ret);
565 }
566
567 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0250, TestSize.Level1)
568 {
569 std::vector<LayerSettings> settings = {
570 {
571 .rectRatio = { 0, 0, 1.0f, 1.0f },
572 .color = RED
573 }
574 };
575
576 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
577 ASSERT_TRUE((layers.size() > 0));
578
579 PrepareAndPrensent();
580
581 auto layer = layers[0];
582
583 TransformType type = TransformType::ROTATE_90;
584 auto ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
585 PrepareAndPrensent();
586
587 type = TransformType::ROTATE_180;
588 ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
589 PrepareAndPrensent();
590
591 type = TransformType::ROTATE_270;
592 ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
593 PrepareAndPrensent();
594
595 EXPECT_EQ(DISPLAY_SUCCESS, ret);
596 }
597
598 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0260, TestSize.Level1)
599 {
600 std::vector<LayerSettings> settings = {
601 {
602 .rectRatio = { 0, 0, 1.0f, 1.0f },
603 .color = BLUE
604 }
605 };
606
607 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
608 ASSERT_TRUE((layers.size() > 0));
609 PrepareAndPrensent();
610 auto layer = layers[0];
611
612 const int32_t WIDTH = 500;
613 const int32_t HEIGHT = 500;
614 IRect region = {0, 0, WIDTH, HEIGHT};
615 std::vector<IRect> regions = {};
616 regions.push_back(region);
617 auto ret = g_composerDevice->SetLayerVisibleRegion(g_displayIds[0], layer->GetId(), regions);
618 PrepareAndPrensent();
619
620 EXPECT_EQ(DISPLAY_SUCCESS, ret);
621 }
622
623 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0270, TestSize.Level1)
624 {
625 std::vector<LayerSettings> settings = {
626 {
627 .rectRatio = { 0, 0, 1.0f, 1.0f },
628 .color = GREEN
629 }
630 };
631
632 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
633 ASSERT_TRUE((layers.size() > 0));
634
635 auto layer = layers[0];
636 auto graphicBuffer = layer->AcquireBackBuffer();
__anon6605dd050302(const BufferHandle* buffer, uint32_t seqNo) 637 int32_t ret = graphicBuffer->SetGraphicBuffer([&](const BufferHandle* buffer, uint32_t seqNo) -> int32_t {
638 std::vector<uint32_t> deletingList;
639 int32_t result = g_composerDevice->SetLayerBuffer(g_displayIds[0], layer->GetId(), buffer, seqNo, -1,
640 deletingList);
641 return result;
642 });
643 PrepareAndPrensent();
644
645 EXPECT_EQ(DISPLAY_SUCCESS, ret);
646 }
647
648 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0280, TestSize.Level1)
649 {
650 std::vector<LayerSettings> settings = {
651 {
652 .rectRatio = { 0, 0, 1.0f, 1.0f },
653 .color = BLUE
654 }
655 };
656
657 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
658 ASSERT_TRUE((layers.size() > 0));
659
660 auto layer = layers[0];
661
662 CompositionType type = CompositionType::COMPOSITION_CLIENT;
663 auto ret = g_composerDevice->SetLayerCompositionType(g_displayIds[0], layer->GetId(), type);
664
665 PrepareAndPrensent();
666
667 EXPECT_EQ(DISPLAY_SUCCESS, ret);
668 }
669
670 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0290, TestSize.Level1)
671 {
672 std::vector<LayerSettings> settings = {
673 {
674 .rectRatio = { 0, 0, 1.0f, 1.0f },
675 .color = GREEN
676 }
677 };
678
679 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
680 ASSERT_TRUE((layers.size() > 0));
681
682 auto layer = layers[0];
683
684 BlendType type = BlendType::BLEND_NONE;
685 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
686
687 PrepareAndPrensent();
688
689 EXPECT_EQ(DISPLAY_SUCCESS, ret);
690 }
691
692 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0300, TestSize.Level1)
693 {
694 std::vector<LayerSettings> settings = {
695 {
696 .rectRatio = { 0, 0, 1.0f, 1.0f },
697 .color = GREEN
698 }
699 };
700
701 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
702 ASSERT_TRUE((layers.size() > 0));
703
704 auto layer = layers[0];
705
706 MaskInfo maskInfo = MaskInfo::LAYER_HBM_SYNC;
707 auto ret = g_composerDevice->SetLayerMaskInfo(g_displayIds[0], layer->GetId(), maskInfo);
708
709 PrepareAndPrensent();
710
711 EXPECT_EQ(DISPLAY_SUCCESS, ret);
712 }
713
714 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0310, TestSize.Level1)
715 {
716 std::vector<LayerSettings> settings = {
717 {
718 .rectRatio = { 0, 0, 1.0f, 1.0f },
719 .color = GREEN
720 }
721 };
722
723 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
724 ASSERT_TRUE((layers.size() > 0));
725
726 auto layer = layers[0];
727 const uint32_t COLOR_R = 155;
728 const uint32_t COLOR_G = 224;
729 const uint32_t COLOR_B = 88;
730 const uint32_t COLOR_A = 128;
731
732 LayerColor layerColor = {
733 .r = COLOR_R,
734 .g = COLOR_G,
735 .b = COLOR_B,
736 .a = COLOR_A
737 };
738
739 auto ret = g_composerDevice->SetLayerColor(g_displayIds[0], layer->GetId(), layerColor);
740
741 PrepareAndPrensent();
742
743 EXPECT_EQ(DISPLAY_SUCCESS, ret);
744 }
745
746 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0320, TestSize.Level1)
747 {
748 std::vector<LayerSettings> settings = {
749 {
750 .rectRatio = { 0, 0, 1.0f, 1.0f },
751 .color = PURPLE
752 }
753 };
754
755 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
756 ASSERT_TRUE((layers.size() > 0));
757
758 auto layer = layers[0];
759
760 PrepareAndPrensent();
761 sleep(1);
762 auto ret = g_composerDevice->DestroyLayer(g_displayIds[0], layer->GetId());
763 PrepareAndPrensent();
764
765 EXPECT_EQ(DISPLAY_SUCCESS, ret);
766 }
767
768 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0330, TestSize.Level1)
769 {
770 int ret;
771 DISPLAY_TEST_LOGE();
772 std::shared_ptr<HdiTestDisplay> display = HdiTestDevice::GetInstance().GetFirstDisplay();
773 ASSERT_TRUE(display != nullptr) << "get display failed";
774 ret = display->RegDisplayVBlankCallback(TestVBlankCallback, nullptr);
775 ASSERT_TRUE(ret == DISPLAY_SUCCESS) << "RegDisplayVBlankCallback failed";
776 ret = display->SetDisplayVsyncEnabled(true);
777 ASSERT_TRUE(ret == DISPLAY_SUCCESS) << "SetDisplayVsyncEnabled failed";
778 ret = VblankCtr::GetInstance().WaitVblank(SLEEP_CONT_2000); // 2000ms
779 ASSERT_TRUE(ret == DISPLAY_SUCCESS) << "WaitVblank timeout";
780 ret = display->SetDisplayVsyncEnabled(false);
781 ASSERT_TRUE(ret == DISPLAY_SUCCESS) << "SetDisplayVsyncEnabled failed";
782 usleep(SLEEP_CONT_100 * SLEEP_CONT_2000); // wait for 100ms avoid the last vsync.
783 ret = VblankCtr::GetInstance().WaitVblank(SLEEP_CONT_2000); // 2000ms
784 ASSERT_TRUE(ret != DISPLAY_SUCCESS) << "vblank do not disable";
785 }
786
787 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0340, TestSize.Level1)
788 {
789 std::vector<LayerSettings> settings = {
790 {
791 .rectRatio = { 0, 0, 1.0f, 1.0f },
792 .color = RED
793 }
794 };
795
796 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
797 ASSERT_TRUE((layers.size() > 0));
798
799 PrepareAndPrensent();
800
801 auto layer = layers[0];
802
803 TransformType type = TransformType::MIRROR_H;
804 auto ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
805 PrepareAndPrensent();
806
807 type = TransformType::MIRROR_V;
808 ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
809 PrepareAndPrensent();
810
811 EXPECT_EQ(DISPLAY_SUCCESS, ret);
812 }
813
814 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0350, TestSize.Level1)
815 {
816 std::vector<LayerSettings> settings = {
817 {
818 .rectRatio = { 0, 0, 1.0f, 1.0f },
819 .color = RED
820 }
821 };
822
823 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
824 ASSERT_TRUE((layers.size() > 0));
825
826 PrepareAndPrensent();
827
828 auto layer = layers[0];
829
830 TransformType type = TransformType::MIRROR_H_ROTATE_90;
831 auto ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
832 PrepareAndPrensent();
833
834 type = TransformType::MIRROR_V_ROTATE_90;
835 ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
836 PrepareAndPrensent();
837
838 EXPECT_EQ(DISPLAY_SUCCESS, ret);
839 }
840
841 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0360, TestSize.Level1)
842 {
843 std::vector<LayerSettings> settings = {
844 {
845 .rectRatio = { 0, 0, 1.0f, 1.0f },
846 .color = RED
847 }
848 };
849
850 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
851 ASSERT_TRUE((layers.size() > 0));
852
853 PrepareAndPrensent();
854
855 auto layer = layers[0];
856
857 TransformType type = TransformType::ROTATE_BUTT;
858 auto ret = g_composerDevice->SetLayerTransformMode(g_displayIds[0], layer->GetId(), type);
859 PrepareAndPrensent();
860 EXPECT_EQ(DISPLAY_SUCCESS, ret);
861 }
862
863 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0370, TestSize.Level1)
864 {
865 auto ret = g_composerDevice->SetDisplayPowerStatus(g_displayIds[0], DispPowerStatus::POWER_STATUS_SUSPEND);
866 EXPECT_EQ(DISPLAY_SUCCESS, ret);
867
868 ret = g_composerDevice->SetDisplayPowerStatus(g_displayIds[0], DispPowerStatus::POWER_STATUS_BUTT);
869 EXPECT_EQ(DISPLAY_FAILURE, ret);
870 }
871
872 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0380, TestSize.Level1)
873 {
874 std::vector<LayerSettings> settings = {
875 {
876 .rectRatio = { 0, 0, 1.0f, 1.0f },
877 .color = GREEN
878 }
879 };
880
881 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
882 ASSERT_TRUE((layers.size() > 0));
883
884 auto layer = layers[0];
885
886 BlendType type = BlendType::BLEND_CLEAR;
887 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
888
889 PrepareAndPrensent();
890
891 EXPECT_EQ(DISPLAY_SUCCESS, ret);
892 }
893
894 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0390, TestSize.Level1)
895 {
896 std::vector<LayerSettings> settings = {
897 {
898 .rectRatio = { 0, 0, 1.0f, 1.0f },
899 .color = GREEN
900 }
901 };
902
903 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
904 ASSERT_TRUE((layers.size() > 0));
905
906 auto layer = layers[0];
907
908 BlendType type = BlendType::BLEND_SRC;
909 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
910
911 PrepareAndPrensent();
912
913 EXPECT_EQ(DISPLAY_SUCCESS, ret);
914 }
915
916 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0400, TestSize.Level1)
917 {
918 std::vector<LayerSettings> settings = {
919 {
920 .rectRatio = { 0, 0, 1.0f, 1.0f },
921 .color = GREEN
922 }
923 };
924
925 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
926 ASSERT_TRUE((layers.size() > 0));
927
928 auto layer = layers[0];
929
930 BlendType type = BlendType::BLEND_SRCOVER;
931 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
932
933 PrepareAndPrensent();
934
935 EXPECT_EQ(DISPLAY_SUCCESS, ret);
936 }
937
938 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0410, TestSize.Level1)
939 {
940 std::vector<LayerSettings> settings = {
941 {
942 .rectRatio = { 0, 0, 1.0f, 1.0f },
943 .color = GREEN
944 }
945 };
946
947 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
948 ASSERT_TRUE((layers.size() > 0));
949
950 auto layer = layers[0];
951
952 BlendType type = BlendType::BLEND_DSTOVER;
953 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
954
955 PrepareAndPrensent();
956
957 EXPECT_EQ(DISPLAY_SUCCESS, ret);
958 }
959
960 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0420, TestSize.Level1)
961 {
962 std::vector<LayerSettings> settings = {
963 {
964 .rectRatio = { 0, 0, 1.0f, 1.0f },
965 .color = GREEN
966 }
967 };
968
969 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
970 ASSERT_TRUE((layers.size() > 0));
971
972 auto layer = layers[0];
973
974 BlendType type = BlendType::BLEND_SRCIN;
975 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
976
977 PrepareAndPrensent();
978
979 EXPECT_EQ(DISPLAY_SUCCESS, ret);
980 }
981
982 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0430, TestSize.Level1)
983 {
984 std::vector<LayerSettings> settings = {
985 {
986 .rectRatio = { 0, 0, 1.0f, 1.0f },
987 .color = GREEN
988 }
989 };
990
991 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
992 ASSERT_TRUE((layers.size() > 0));
993
994 auto layer = layers[0];
995
996 BlendType type = BlendType::BLEND_DSTIN;
997 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
998
999 PrepareAndPrensent();
1000
1001 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1002 }
1003
1004 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0440, TestSize.Level1)
1005 {
1006 std::vector<LayerSettings> settings = {
1007 {
1008 .rectRatio = { 0, 0, 1.0f, 1.0f },
1009 .color = GREEN
1010 }
1011 };
1012
1013 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1014 ASSERT_TRUE((layers.size() > 0));
1015
1016 auto layer = layers[0];
1017
1018 BlendType type = BlendType::BLEND_SRCOUT;
1019 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
1020
1021 PrepareAndPrensent();
1022
1023 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1024 }
1025
1026 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0450, TestSize.Level1)
1027 {
1028 std::vector<LayerSettings> settings = {
1029 {
1030 .rectRatio = { 0, 0, 1.0f, 1.0f },
1031 .color = GREEN
1032 }
1033 };
1034
1035 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1036 ASSERT_TRUE((layers.size() > 0));
1037
1038 auto layer = layers[0];
1039
1040 BlendType type = BlendType::BLEND_DSTOUT;
1041 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
1042
1043 PrepareAndPrensent();
1044
1045 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1046 }
1047
1048 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0460, TestSize.Level1)
1049 {
1050 std::vector<LayerSettings> settings = {
1051 {
1052 .rectRatio = { 0, 0, 1.0f, 1.0f },
1053 .color = GREEN
1054 }
1055 };
1056
1057 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1058 ASSERT_TRUE((layers.size() > 0));
1059
1060 auto layer = layers[0];
1061
1062 BlendType type = BlendType::BLEND_SRCATOP;
1063 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
1064
1065 PrepareAndPrensent();
1066
1067 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1068 }
1069
1070 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0470, TestSize.Level1)
1071 {
1072 std::vector<LayerSettings> settings = {
1073 {
1074 .rectRatio = { 0, 0, 1.0f, 1.0f },
1075 .color = GREEN
1076 }
1077 };
1078
1079 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1080 ASSERT_TRUE((layers.size() > 0));
1081
1082 auto layer = layers[0];
1083
1084 BlendType type = BlendType::BLEND_DSTATOP;
1085 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
1086
1087 PrepareAndPrensent();
1088
1089 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1090 }
1091
1092 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0480, TestSize.Level1)
1093 {
1094 std::vector<LayerSettings> settings = {
1095 {
1096 .rectRatio = { 0, 0, 1.0f, 1.0f },
1097 .color = GREEN
1098 }
1099 };
1100
1101 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1102 ASSERT_TRUE((layers.size() > 0));
1103
1104 auto layer = layers[0];
1105
1106 BlendType type = BlendType::BLEND_ADD;
1107 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
1108
1109 PrepareAndPrensent();
1110
1111 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1112 }
1113
1114 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0490, TestSize.Level1)
1115 {
1116 std::vector<LayerSettings> settings = {
1117 {
1118 .rectRatio = { 0, 0, 1.0f, 1.0f },
1119 .color = GREEN
1120 }
1121 };
1122
1123 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1124 ASSERT_TRUE((layers.size() > 0));
1125
1126 auto layer = layers[0];
1127
1128 BlendType type = BlendType::BLEND_XOR;
1129 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
1130
1131 PrepareAndPrensent();
1132
1133 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1134 }
1135
1136 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0500, TestSize.Level1)
1137 {
1138 std::vector<LayerSettings> settings = {
1139 {
1140 .rectRatio = { 0, 0, 1.0f, 1.0f },
1141 .color = GREEN
1142 }
1143 };
1144
1145 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1146 ASSERT_TRUE((layers.size() > 0));
1147
1148 auto layer = layers[0];
1149
1150 BlendType type = BlendType::BLEND_DST;
1151 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
1152
1153 PrepareAndPrensent();
1154
1155 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1156 }
1157
1158 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0510, TestSize.Level1)
1159 {
1160 std::vector<LayerSettings> settings = {
1161 {
1162 .rectRatio = { 0, 0, 1.0f, 1.0f },
1163 .color = GREEN
1164 }
1165 };
1166
1167 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1168 ASSERT_TRUE((layers.size() > 0));
1169
1170 auto layer = layers[0];
1171
1172 BlendType type = BlendType::BLEND_AKS;
1173 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
1174
1175 PrepareAndPrensent();
1176
1177 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1178 }
1179
1180 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0520, TestSize.Level1)
1181 {
1182 std::vector<LayerSettings> settings = {
1183 {
1184 .rectRatio = { 0, 0, 1.0f, 1.0f },
1185 .color = GREEN
1186 }
1187 };
1188
1189 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1190 ASSERT_TRUE((layers.size() > 0));
1191
1192 auto layer = layers[0];
1193
1194 BlendType type = BlendType::BLEND_AKD;
1195 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
1196
1197 PrepareAndPrensent();
1198
1199 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1200 }
1201
1202 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0530, TestSize.Level1)
1203 {
1204 std::vector<LayerSettings> settings = {
1205 {
1206 .rectRatio = { 0, 0, 1.0f, 1.0f },
1207 .color = GREEN
1208 }
1209 };
1210
1211 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1212 ASSERT_TRUE((layers.size() > 0));
1213
1214 auto layer = layers[0];
1215
1216 BlendType type = BlendType::BLEND_BUTT;
1217 auto ret = g_composerDevice->SetLayerBlendType(g_displayIds[0], layer->GetId(), type);
1218
1219 PrepareAndPrensent();
1220
1221 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1222 }
1223
1224 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0540, TestSize.Level1)
1225 {
1226 std::vector<LayerSettings> settings = {
1227 {
1228 .rectRatio = { 0, 0, 1.0f, 1.0f },
1229 .color = GREEN
1230 }
1231 };
1232
1233 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1234 ASSERT_TRUE((layers.size() > 0));
1235
1236 auto layer = layers[0];
1237
1238 MaskInfo maskInfo = MaskInfo::LAYER_NORAML;
1239 auto ret = g_composerDevice->SetLayerMaskInfo(g_displayIds[0], layer->GetId(), maskInfo);
1240
1241 PrepareAndPrensent();
1242
1243 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1244 }
1245
1246 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0550, TestSize.Level1)
1247 {
1248 std::vector<LayerSettings> settings = {
1249 {
1250 .rectRatio = { 0, 0, 1.0f, 1.0f },
1251 .color = BLUE
1252 }
1253 };
1254
1255 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1256 ASSERT_TRUE((layers.size() > 0));
1257
1258 auto layer = layers[0];
1259
1260 CompositionType type = CompositionType::COMPOSITION_DEVICE;
1261 auto ret = g_composerDevice->SetLayerCompositionType(g_displayIds[0], layer->GetId(), type);
1262
1263 PrepareAndPrensent();
1264
1265 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1266 }
1267
1268 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0560, TestSize.Level1)
1269 {
1270 std::vector<LayerSettings> settings = {
1271 {
1272 .rectRatio = { 0, 0, 1.0f, 1.0f },
1273 .color = BLUE
1274 }
1275 };
1276
1277 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1278 ASSERT_TRUE((layers.size() > 0));
1279
1280 auto layer = layers[0];
1281
1282 CompositionType type = CompositionType::COMPOSITION_CURSOR;
1283 auto ret = g_composerDevice->SetLayerCompositionType(g_displayIds[0], layer->GetId(), type);
1284
1285 PrepareAndPrensent();
1286
1287 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1288 }
1289
1290 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0570, TestSize.Level1)
1291 {
1292 std::vector<LayerSettings> settings = {
1293 {
1294 .rectRatio = { 0, 0, 1.0f, 1.0f },
1295 .color = BLUE
1296 }
1297 };
1298
1299 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1300 ASSERT_TRUE((layers.size() > 0));
1301
1302 auto layer = layers[0];
1303
1304 CompositionType type = CompositionType::COMPOSITION_VIDEO;
1305 auto ret = g_composerDevice->SetLayerCompositionType(g_displayIds[0], layer->GetId(), type);
1306
1307 PrepareAndPrensent();
1308
1309 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1310 }
1311
1312 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0580, TestSize.Level1)
1313 {
1314 std::vector<LayerSettings> settings = {
1315 {
1316 .rectRatio = { 0, 0, 1.0f, 1.0f },
1317 .color = BLUE
1318 }
1319 };
1320
1321 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1322 ASSERT_TRUE((layers.size() > 0));
1323
1324 auto layer = layers[0];
1325
1326 CompositionType type = CompositionType::COMPOSITION_DEVICE_CLEAR;
1327 auto ret = g_composerDevice->SetLayerCompositionType(g_displayIds[0], layer->GetId(), type);
1328
1329 PrepareAndPrensent();
1330
1331 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1332 }
1333
1334 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0590, TestSize.Level1)
1335 {
1336 std::vector<LayerSettings> settings = {
1337 {
1338 .rectRatio = { 0, 0, 1.0f, 1.0f },
1339 .color = BLUE
1340 }
1341 };
1342
1343 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1344 ASSERT_TRUE((layers.size() > 0));
1345
1346 auto layer = layers[0];
1347
1348 CompositionType type = CompositionType::COMPOSITION_CLIENT_CLEAR;
1349 auto ret = g_composerDevice->SetLayerCompositionType(g_displayIds[0], layer->GetId(), type);
1350
1351 PrepareAndPrensent();
1352
1353 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1354 }
1355
1356 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0600, TestSize.Level1)
1357 {
1358 std::vector<LayerSettings> settings = {
1359 {
1360 .rectRatio = { 0, 0, 1.0f, 1.0f },
1361 .color = BLUE
1362 }
1363 };
1364
1365 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1366 ASSERT_TRUE((layers.size() > 0));
1367
1368 auto layer = layers[0];
1369
1370 CompositionType type = CompositionType::COMPOSITION_TUNNEL;
1371 auto ret = g_composerDevice->SetLayerCompositionType(g_displayIds[0], layer->GetId(), type);
1372
1373 PrepareAndPrensent();
1374
1375 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1376 }
1377
1378 HWTEST_F(DeviceTest, SUB_DriverSystem_DisplayComposer_0610, TestSize.Level1)
1379 {
1380 std::vector<LayerSettings> settings = {
1381 {
1382 .rectRatio = { 0, 0, 1.0f, 1.0f },
1383 .color = BLUE
1384 }
1385 };
1386
1387 std::vector<std::shared_ptr<HdiTestLayer>> layers = CreateLayers(settings);
1388 ASSERT_TRUE((layers.size() > 0));
1389
1390 auto layer = layers[0];
1391
1392 CompositionType type = CompositionType::COMPOSITION_BUTT;
1393 auto ret = g_composerDevice->SetLayerCompositionType(g_displayIds[0], layer->GetId(), type);
1394
1395 PrepareAndPrensent();
1396
1397 EXPECT_EQ(DISPLAY_SUCCESS, ret);
1398 }
1399