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 <mutex>
17 #include <chrono>
18 #include <cinttypes>
19 #include <algorithm>
20 #include <condition_variable>
21 #include <benchmark/benchmark.h>
22 #include "gtest/gtest.h"
23 #include "v1_2/include/idisplay_composer_interface.h"
24 #include "v1_1/display_composer_type.h"
25 #include "v1_0/display_buffer_type.h"
26 #include "display_test.h"
27 #include "display_test_utils.h"
28 #include "hdi_composition_check.h"
29 #include "hdi_test_device.h"
30 #include "hdi_test_device_common.h"
31 #include "hdi_test_display.h"
32 #include "hdi_test_render_utils.h"
33 
34 using namespace OHOS::HDI::Display::Buffer::V1_0;
35 using namespace OHOS::HDI::Display::Composer::V1_2;
36 using namespace OHOS::HDI::Display::TEST;
37 using namespace testing::ext;
38 
39 static sptr<Composer::V1_2::IDisplayComposerInterface> g_composerDevice = nullptr;
40 static std::shared_ptr<IDisplayBuffer> g_gralloc = nullptr;
41 static std::vector<uint32_t> g_displayIds;
42 
43 namespace {
44 class DisplayBenchmarkTest : public benchmark::Fixture {
45 public:
46     void TearDown(const ::benchmark::State &state);
47     static void OnMode(uint32_t modeId, uint64_t vBlankPeriod, void* data);
48     static void OnseamlessChange(uint32_t devId, void* data);
49     static void TestRefreshCallback(uint32_t devId, void* data);
50 };
51 
TearDown(const::benchmark::State & state)52 void DisplayBenchmarkTest::TearDown(const ::benchmark::State &state)
53 {
54     HdiTestDevice::GetInstance().Clear();
55 }
56 
OnMode(uint32_t modeId,uint64_t vBlankPeriod,void * data)57 void DisplayBenchmarkTest::OnMode(uint32_t modeId, uint64_t vBlankPeriod, void* data)
58 {
59 }
60 
OnseamlessChange(uint32_t devId,void * data)61 void DisplayBenchmarkTest::OnseamlessChange(uint32_t devId, void* data)
62 {
63 }
64 
TestRefreshCallback(uint32_t devId,void * data)65 void DisplayBenchmarkTest::TestRefreshCallback(uint32_t devId, void* data)
66 {
67 }
68 
69 /**
70   * @tc.name: SetClientBufferCacheCountTest
71   * @tc.desc: Benchmarktest for interface SetClientBufferCacheCount.
72   */
BENCHMARK_F(DisplayBenchmarkTest,SetClientBufferCacheCountTest)73 BENCHMARK_F(DisplayBenchmarkTest, SetClientBufferCacheCountTest)(benchmark::State &state)
74 {
75     int32_t ret;
76     const uint32_t CACHE_COUNT = 5;
77     for (auto _ : state) {
78         ret = g_composerDevice->SetClientBufferCacheCount(g_displayIds[0], CACHE_COUNT);
79     }
80     EXPECT_EQ(DISPLAY_SUCCESS, ret);
81 }
82 
83 /**
84   * @tc.name: GetDisplayCapabilityTest
85   * @tc.desc: Benchmarktest for interface GetDisplayCapability.
86   */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayCapabilityTest)87 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayCapabilityTest)(benchmark::State &state)
88 {
89     int32_t ret;
90     DisplayCapability info;
91     for (auto _ : state) {
92         ret = g_composerDevice->GetDisplayCapability(g_displayIds[0], info);
93     }
94     EXPECT_EQ(DISPLAY_SUCCESS, ret);
95 }
96 
97 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayCapabilityTest)->
98     Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
99 
100 /**
101   * @tc.name: GetDisplaySupportedModesTest
102   * @tc.desc: Benchmarktest for interface GetDisplaySupportedModes.
103   */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplaySupportedModesTest)104 BENCHMARK_F(DisplayBenchmarkTest, GetDisplaySupportedModesTest)(benchmark::State &state)
105 {
106     int32_t ret;
107     std::vector<DisplayModeInfo> modes;
108     for (auto _ : state) {
109         ret = g_composerDevice->GetDisplaySupportedModes(g_displayIds[0], modes);
110     }
111     EXPECT_EQ(DISPLAY_SUCCESS, ret);
112 }
113 
114 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedModesTest)->
115     Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
116 
117 /**
118   * @tc.name: GetDisplayModeTest
119   * @tc.desc: Benchmarktest for interface GetDisplayMode.
120   */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayModeTest)121 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayModeTest)(benchmark::State &state)
122 {
123     int32_t ret;
124     uint32_t modeId = 0;
125     for (auto _ : state) {
126         ret = g_composerDevice->GetDisplayMode(modeId, modeId);
127     }
128     EXPECT_EQ(DISPLAY_SUCCESS, ret);
129 }
130 
131 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayModeTest)->
132     Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
133 
134 /**
135   * @tc.name: SetDisplayModeTest
136   * @tc.desc: Benchmarktest for interface SetDisplayMode.
137   */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayModeTest)138 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayModeTest)(benchmark::State &state)
139 {
140     int32_t ret;
141     const uint32_t modeId = 0;
142     for (auto _ : state) {
143         ret = g_composerDevice->SetDisplayMode(g_displayIds[0], modeId);
144     }
145     EXPECT_EQ(DISPLAY_SUCCESS, ret);
146 }
147 
148 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayModeTest)->
149     Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
150 
151 /**
152   * @tc.name: GetDisplayPowerStatusTest
153   * @tc.desc: Benchmarktest for interface GetDisplayPowerStatus.
154   */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayPowerStatusTest)155 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayPowerStatusTest)(benchmark::State &state)
156 {
157     int32_t ret;
158     Composer::V1_0::DispPowerStatus powerStatus = Composer::V1_0::DispPowerStatus::POWER_STATUS_OFF;
159     for (auto _ : state) {
160         ret = g_composerDevice->GetDisplayPowerStatus(g_displayIds[0], powerStatus);
161     }
162     EXPECT_EQ(DISPLAY_SUCCESS, ret);
163 }
164 
165 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayPowerStatusTest)->
166     Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
167 
168 /**
169   * @tc.name: SetDisplayPowerStatusTest
170   * @tc.desc: Benchmarktest for interface SetDisplayPowerStatus.
171   */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayPowerStatusTest)172 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayPowerStatusTest)(benchmark::State &state)
173 {
174     int32_t ret;
175     for (auto _ : state) {
176         ret = g_composerDevice->SetDisplayPowerStatus(g_displayIds[0],
177             Composer::V1_0::DispPowerStatus::POWER_STATUS_ON);
178     }
179     EXPECT_EQ(DISPLAY_SUCCESS, ret);
180 }
181 
182 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayPowerStatusTest)->
183     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
184 
185 /**
186   * @tc.name: GetDisplayBacklightTest
187   * @tc.desc: Benchmarktest for interface GetDisplayBacklight.
188   */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayBacklightTest)189 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayBacklightTest)(benchmark::State &state)
190 {
191     int32_t ret;
192     uint32_t level;
193     for (auto _ : state) {
194         ret = g_composerDevice->GetDisplayBacklight(g_displayIds[0], level);
195     }
196     EXPECT_EQ(DISPLAY_SUCCESS, ret);
197 }
198 
199 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayBacklightTest)->
200     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
201 
202 /**
203   * @tc.name: SetDisplayBacklightTest
204   * @tc.desc: Benchmarktest for interface SetDisplayBacklight.
205   */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayBacklightTest)206 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayBacklightTest)(benchmark::State &state)
207 {
208     int32_t ret;
209     const uint32_t level = 10;
210     for (auto _ : state) {
211         ret = g_composerDevice->SetDisplayBacklight(g_displayIds[0], level);
212     }
213     EXPECT_EQ(DISPLAY_SUCCESS, ret);
214 }
215 
216 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayBacklightTest)->
217     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
218 
219 /**
220   * @tc.name: CreateAndDestroyLayerTest
221   * @tc.desc: Benchmarktest for interface CreateLayer And DestroyLayer.
222   */
BENCHMARK_F(DisplayBenchmarkTest,CreateAndDestroyLayerTest)223 BENCHMARK_F(DisplayBenchmarkTest, CreateAndDestroyLayerTest)(benchmark::State &state)
224 {
225     int32_t ret;
226     LayerInfo layerInfo;
227     uint32_t layerId;
228     for (auto _ : state) {
229         uint32_t bufferCount = 3;
230         ret = g_composerDevice->CreateLayer(g_displayIds[0], layerInfo, bufferCount, layerId);
231         EXPECT_EQ(DISPLAY_SUCCESS, ret);
232         ret = g_composerDevice->DestroyLayer(g_displayIds[0], layerId);
233     }
234     EXPECT_EQ(DISPLAY_SUCCESS, ret);
235 }
236 
237 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, CreateAndDestroyLayerTest)->
238     Iterations(10)->Repetitions(3)->ReportAggregatesOnly();
239 
240 /**
241   * @tc.name: GetDisplayCompChangeTest
242   * @tc.desc: Benchmarktest for interface GetDisplayCompChange.
243   */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayCompChangeTest)244 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayCompChangeTest)(benchmark::State &state)
245 {
246     std::vector<uint32_t> layers {};
247     std::vector<int32_t> type {};
248     int32_t ret;
249     for (auto _ : state) {
250         ret = g_composerDevice->GetDisplayCompChange(g_displayIds[0], layers, type);
251     }
252     EXPECT_EQ(DISPLAY_SUCCESS, ret);
253 }
254 
255 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayCompChangeTest)->
256     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
257 
258 /**
259   * @tc.name: GetDisplayReleaseFenceTest
260   * @tc.desc: Benchmarktest for interface GetDisplayReleaseFence.
261   */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayReleaseFenceTest)262 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayReleaseFenceTest)(benchmark::State &state)
263 {
264     std::vector<uint32_t> layers {};
265     std::vector<int32_t> fences {};
266     int32_t ret;
267     for (auto _ : state) {
268         ret = g_composerDevice->GetDisplayReleaseFence(g_displayIds[0], layers, fences);
269     }
270     EXPECT_EQ(DISPLAY_SUCCESS, ret);
271 }
272 
273 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayReleaseFenceTest)->
274     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
275 
276 /**
277   * @tc.name: CreateAndDestroyVirtualDisplayTest
278   * @tc.desc: Benchmarktest for interface CreateVirtualDisplay and DestroyVirtualDisplay.
279   */
BENCHMARK_F(DisplayBenchmarkTest,CreateAndDestroyVirtualDisplayTest)280 BENCHMARK_F(DisplayBenchmarkTest, CreateAndDestroyVirtualDisplayTest)(benchmark::State &state)
281 {
282     int32_t ret;
283     const uint32_t WIDTH = 100;
284     const uint32_t HEIGHT = 100;
285     int32_t format = 0;
286     for (auto _ : state) {
287         ret = g_composerDevice->CreateVirtualDisplay(WIDTH, HEIGHT, format, g_displayIds[0]);
288         EXPECT_EQ(DISPLAY_FAILURE, ret);
289         ret = g_composerDevice->DestroyVirtualDisplay(g_displayIds[0]);
290     }
291     EXPECT_EQ(DISPLAY_FAILURE, ret);
292 }
293 
294 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, CreateAndDestroyVirtualDisplayTest)->
295     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
296 
297 /**
298   * @tc.name: SetVirtualDisplayBufferTest
299   * @tc.desc: Benchmarktest for interface SetVirtualDisplayBuffer.
300   */
BENCHMARK_F(DisplayBenchmarkTest,SetVirtualDisplayBufferTest)301 BENCHMARK_F(DisplayBenchmarkTest, SetVirtualDisplayBufferTest)(benchmark::State &state)
302 {
303     BufferHandle* buffer = nullptr;
304     int32_t ret;
305     int32_t fence = -1;
306 
307     AllocInfo info;
308     info.width  = 100;
309     info.height = 100;
310     info.usage = OHOS::HDI::Display::Composer::V1_0::HBM_USE_MEM_DMA |
311             OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_READ |
312             OHOS::HDI::Display::Composer::V1_0::HBM_USE_CPU_WRITE;
313     info.format = Composer::V1_0::PIXEL_FMT_RGBA_8888;
314 
315     g_gralloc->AllocMem(info, buffer);
316     ASSERT_TRUE(buffer != nullptr);
317 
318     for (auto _ : state) {
319         ret = g_composerDevice->SetVirtualDisplayBuffer(g_displayIds[0], *buffer, fence);
320     }
321     g_gralloc->FreeMem(*buffer);
322     // not support
323     EXPECT_EQ(DISPLAY_FAILURE, ret);
324 }
325 
326 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetVirtualDisplayBufferTest)->
327     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
328 
329 /**
330   * @tc.name: SetDisplayPropertyTest
331   * @tc.desc: Benchmarktest for interface SetDisplayProperty.
332   */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayPropertyTest)333 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayPropertyTest)(benchmark::State &state)
334 {
335     int32_t ret;
336     uint32_t id = 1;
337     uint64_t value = 0;
338     for (auto _ : state) {
339         ret = g_composerDevice->SetDisplayProperty(g_displayIds[0], id, value);
340     }
341     EXPECT_EQ(DISPLAY_FAILURE, ret);
342 }
343 
344 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayPropertyTest)->
345     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
346 
347 /**
348   * @tc.name: GetDisplayPropertyTest
349   * @tc.desc: Benchmarktest for interface GetDisplayProperty.
350   */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayPropertyTest)351 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayPropertyTest)(benchmark::State &state)
352 {
353     int32_t ret;
354     uint32_t id = 1;
355     uint64_t value = 0;
356     for (auto _ : state) {
357         ret = g_composerDevice->GetDisplayProperty(g_displayIds[0], id, value);
358     }
359     int32_t result = DISPLAY_FAILURE;
360     if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) {
361         result = DISPLAY_SUCCESS;
362     }
363     EXPECT_EQ(DISPLAY_SUCCESS, result);
364 }
365 
366 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayPropertyTest)->
367     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
368 
369 
370 /**
371   * @tc.name: GetDisplaySupportedModesExtTest
372   * @tc.desc: Benchmarktest for interface GetDisplaySupportedModesExtTest.
373   */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplaySupportedModesExtTest)374 BENCHMARK_F(DisplayBenchmarkTest, GetDisplaySupportedModesExtTest)(benchmark::State &state)
375 {
376     int32_t ret;
377     std::vector<DisplayModeInfoExt> modes;
378     for (auto _ : state) {
379         ret = g_composerDevice->GetDisplaySupportedModesExt(g_displayIds[0], modes);
380     }
381     if (ret == DISPLAY_NOT_SUPPORT) {
382         return;
383     }
384     EXPECT_EQ(DISPLAY_SUCCESS, ret);
385 }
386 
387 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedModesExtTest)->
388     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
389 
390 /**
391   * @tc.name: SetDisplayModeAsyncTest
392   * @tc.desc: Benchmarktest for interface SetDisplayModeAsyncTest.
393   */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayModeAsyncTest)394 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayModeAsyncTest)(benchmark::State &state)
395 {
396     int32_t ret;
397     uint32_t modeid = 0;
398     for (auto _ : state) {
399         ret = g_composerDevice->SetDisplayModeAsync(g_displayIds[0], modeid, OnMode);
400     }
401     if (ret == DISPLAY_NOT_SUPPORT) {
402         return;
403     }
404     EXPECT_EQ(DISPLAY_SUCCESS, ret);
405 }
406 
407 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayModeAsyncTest)->
408     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
409 
410 /**
411   * @tc.name: GetDisplayVBlankPeriodTest
412   * @tc.desc: Benchmarktest for interface GetDisplayVBlankPeriodTest.
413   */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplayVBlankPeriodTest)414 BENCHMARK_F(DisplayBenchmarkTest, GetDisplayVBlankPeriodTest)(benchmark::State &state)
415 {
416     int32_t ret;
417     uint64_t period = 0;
418     for (auto _ : state) {
419         ret = g_composerDevice->GetDisplayVBlankPeriod(g_displayIds[0], period);
420     }
421     if (ret == DISPLAY_NOT_SUPPORT) {
422         return;
423     }
424     EXPECT_EQ(DISPLAY_SUCCESS, ret);
425 }
426 
427 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayVBlankPeriodTest)->
428     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
429 
430 /**
431   * @tc.name: RegSeamlessChangeCallbackTest
432   * @tc.desc: Benchmarktest for interface RegSeamlessChangeCallbackTest.
433   */
BENCHMARK_F(DisplayBenchmarkTest,RegSeamlessChangeCallbackTest)434 BENCHMARK_F(DisplayBenchmarkTest, RegSeamlessChangeCallbackTest)(benchmark::State &state)
435 {
436     int32_t ret;
437     for (auto _ : state) {
438         ret = g_composerDevice->RegSeamlessChangeCallback(OnseamlessChange, nullptr);
439     }
440     if (ret == DISPLAY_NOT_SUPPORT) {
441         return;
442     }
443     EXPECT_EQ(DISPLAY_SUCCESS, ret);
444 }
445 
446 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, RegSeamlessChangeCallbackTest)->
447     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
448 
449 /**
450   * @tc.name: SetLayerPerFrameParameterTest
451   * @tc.desc: Benchmarktest for interface SetLayerPerFrameParameter.
452   */
BENCHMARK_F(DisplayBenchmarkTest,SetLayerPerFrameParameterTest)453 BENCHMARK_F(DisplayBenchmarkTest, SetLayerPerFrameParameterTest)(benchmark::State &state)
454 {
455     int32_t ret;
456     LayerInfo layerInfo;
457     uint32_t layerId;
458     std::string key = "FilmFilter";
459     std::vector<int8_t> value = { 1 };
460     uint32_t bufferCount = 3;
461     ret = g_composerDevice->CreateLayer(g_displayIds[0], layerInfo, bufferCount, layerId);
462     EXPECT_EQ(DISPLAY_SUCCESS, ret);
463     for (auto _ : state) {
464         ret = g_composerDevice->SetLayerPerFrameParameter(g_displayIds[0], layerId, key, value);
465     }
466     g_composerDevice->DestroyLayer(g_displayIds[0], layerId);
467     if (ret == DISPLAY_NOT_SUPPORT) {
468         return;
469     }
470     EXPECT_EQ(DISPLAY_SUCCESS, ret);
471 }
472 
473 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerPerFrameParameterTest)->
474     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
475 
476 /**
477   * @tc.name: GetSupportedLayerPerFrameParameterKeyTest
478   * @tc.desc: Benchmarktest for interface GetSupportedLayerPerFrameParameterKey.
479   */
BENCHMARK_F(DisplayBenchmarkTest,GetSupportedLayerPerFrameParameterKeyTest)480 BENCHMARK_F(DisplayBenchmarkTest, GetSupportedLayerPerFrameParameterKeyTest)(benchmark::State &state)
481 {
482     int32_t ret;
483     std::vector<std::string> keys;
484     for (auto _ : state) {
485         ret = g_composerDevice->GetSupportedLayerPerFrameParameterKey(keys);
486     }
487     if (ret == DISPLAY_NOT_SUPPORT) {
488         return;
489     }
490     EXPECT_EQ(DISPLAY_SUCCESS, ret);
491 }
492 
493 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetSupportedLayerPerFrameParameterKeyTest)->
494     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
495 
496 /**
497   * @tc.name: SetDisplayOverlayResolutionTest
498   * @tc.desc: Benchmarktest for interface SetDisplayOverlayResolution.
499   */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayOverlayResolutionTest)500 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayOverlayResolutionTest)(benchmark::State &state)
501 {
502     int32_t ret;
503     DisplayModeInfo mode = HdiTestDevice::GetInstance().GetFirstDisplay()->GetCurrentMode();
504     for (auto _ : state) {
505         ret = g_composerDevice->SetDisplayOverlayResolution(g_displayIds[0], mode.width, mode.height);
506     }
507     if (ret == DISPLAY_NOT_SUPPORT) {
508         return;
509     }
510     EXPECT_EQ(DISPLAY_SUCCESS, ret);
511 }
512 
513 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayOverlayResolutionTest)->
514     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
515 
516 /**
517   * @tc.name: RegRefreshCallbackTest
518   * @tc.desc: Benchmarktest for interface RegRefreshCallback.
519   */
BENCHMARK_F(DisplayBenchmarkTest,RegRefreshCallbackTest)520 BENCHMARK_F(DisplayBenchmarkTest, RegRefreshCallbackTest)(benchmark::State &state)
521 {
522     int32_t ret;
523     for (auto _ : state) {
524         ret = g_composerDevice->RegRefreshCallback(TestRefreshCallback, nullptr);
525     }
526     if (ret == DISPLAY_NOT_SUPPORT) {
527         return;
528     }
529     EXPECT_EQ(DISPLAY_SUCCESS, ret);
530 }
531 
532 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, RegRefreshCallbackTest)->
533     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
534 
535 /**
536   * @tc.name: GetDisplaySupportedColorGamutsTest
537   * @tc.desc: Benchmarktest for interface GetDisplaySupportedColorGamuts.
538   */
BENCHMARK_F(DisplayBenchmarkTest,GetDisplaySupportedColorGamutsTest)539 BENCHMARK_F(DisplayBenchmarkTest, GetDisplaySupportedColorGamutsTest)(benchmark::State &state)
540 {
541     int32_t ret;
542     std::vector<ColorGamut> gamuts;
543     for (auto _ : state) {
544         ret = g_composerDevice->GetDisplaySupportedColorGamuts(g_displayIds[0], gamuts);
545     }
546     if (ret == DISPLAY_NOT_SUPPORT) {
547         return;
548     }
549     EXPECT_EQ(DISPLAY_SUCCESS, ret);
550 }
551 
552 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedColorGamutsTest)->
553     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
554 
555 /**
556   * @tc.name: GetHDRCapabilityInfosTest
557   * @tc.desc: Benchmarktest for interface GetHDRCapabilityInfos.
558   */
BENCHMARK_F(DisplayBenchmarkTest,GetHDRCapabilityInfosTest)559 BENCHMARK_F(DisplayBenchmarkTest, GetHDRCapabilityInfosTest)(benchmark::State &state)
560 {
561     int32_t ret;
562     HDRCapability info = { 0 };
563     for (auto _ : state) {
564         ret = g_composerDevice->GetHDRCapabilityInfos(g_displayIds[0], info);
565     }
566     if (ret == DISPLAY_NOT_SUPPORT) {
567         return;
568     }
569     EXPECT_EQ(DISPLAY_SUCCESS, ret);
570 }
571 
572 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetHDRCapabilityInfosTest)->
573     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
574 
575 /**
576   * @tc.name: SetDisplayClientCropTest
577   * @tc.desc: Benchmarktest for interface SetDisplayClientCrop.
578   */
BENCHMARK_F(DisplayBenchmarkTest,SetDisplayClientCropTest)579 BENCHMARK_F(DisplayBenchmarkTest, SetDisplayClientCropTest)(benchmark::State &state)
580 {
581     int32_t ret;
582     int32_t width = 100;
583     int32_t height = 100;
584     IRect rect = {0, 0, width, height};
585     for (auto _ : state) {
586         ret = g_composerDevice->SetDisplayClientCrop(g_displayIds[0], rect);
587     }
588     EXPECT_EQ(DISPLAY_FAILURE, ret);
589 }
590 
591 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayClientCropTest)->
592     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
593 
594 /**
595   * @tc.name: SetHardwareCursorPositionTest
596   * @tc.desc: Benchmarktest for interface SetHardwareCursorPositionTest.
597   */
BENCHMARK_F(DisplayBenchmarkTest,SetHardwareCursorPositionTest)598 BENCHMARK_F(DisplayBenchmarkTest, SetHardwareCursorPositionTest)(benchmark::State &state)
599 {
600     int32_t ret = 0;
601     int32_t x = 1;
602     int32_t y = 1;
603     for (auto _ : state) {
604         ret = g_composerDevice->SetHardwareCursorPosition(g_displayIds[0], x, y);
605     }
606     if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) {
607         ret = DISPLAY_SUCCESS;
608     }
609     EXPECT_EQ(DISPLAY_SUCCESS, ret);
610 }
611 
612 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetHardwareCursorPositionTest)->
613     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
614 
615 /**
616   * @tc.name: EnableHardwareCursorStatsTest
617   * @tc.desc: Benchmarktest for interface EnableHardwareCursorStatsTest.
618   */
BENCHMARK_F(DisplayBenchmarkTest,EnableHardwareCursorStatsTest)619 BENCHMARK_F(DisplayBenchmarkTest, EnableHardwareCursorStatsTest)(benchmark::State &state)
620 {
621     int32_t ret = 0;
622     bool enable = true;
623     for (auto _ : state) {
624         ret = g_composerDevice->EnableHardwareCursorStats(g_displayIds[0], enable);
625     }
626     if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) {
627         ret = DISPLAY_SUCCESS;
628     }
629     EXPECT_EQ(DISPLAY_SUCCESS, ret);
630 }
631 
632 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, EnableHardwareCursorStatsTest)->
633     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
634 
635 /**
636   * @tc.name: GetHardwareCursorStatsTest
637   * @tc.desc: Benchmarktest for interface GetHardwareCursorStatsTest.
638   */
BENCHMARK_F(DisplayBenchmarkTest,GetHardwareCursorStatsTest)639 BENCHMARK_F(DisplayBenchmarkTest, GetHardwareCursorStatsTest)(benchmark::State &state)
640 {
641     int32_t ret = 0;
642     uint32_t frameCount = 0;
643     uint32_t vsyncCount = 0;
644     for (auto _ : state) {
645         ret = g_composerDevice->GetHardwareCursorStats(g_displayIds[0], frameCount, vsyncCount);
646     }
647     if (ret == DISPLAY_SUCCESS || ret == DISPLAY_NOT_SUPPORT) {
648         ret = DISPLAY_SUCCESS;
649     }
650     EXPECT_EQ(DISPLAY_SUCCESS, ret);
651 }
652 
653 BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetHardwareCursorStatsTest)->
654     Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
655 
656 } // namespace
657 
main(int argc,char ** argv)658 int main(int argc, char** argv)
659 {
660     int ret = HdiTestDevice::GetInstance().InitDevice();
661     DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("Init Device Failed"));
662     ::testing::InitGoogleTest(&argc, argv);
663     ::benchmark::Initialize(&argc, argv);
664     if (::benchmark::ReportUnrecognizedArguments(argc, argv)) {
665         return 1;
666     }
667     g_composerDevice = HdiTestDevice::GetInstance().GetDeviceInterface();
668     DISPLAY_TEST_CHK_RETURN((g_composerDevice == nullptr), DISPLAY_FAILURE,
669         DISPLAY_TEST_LOGE("get composer interface failed"));
670     g_gralloc.reset(IDisplayBuffer::Get());
671     DISPLAY_TEST_CHK_RETURN((g_gralloc == nullptr), DISPLAY_FAILURE,
672         DISPLAY_TEST_LOGE("get buffer interface failed"));
673     auto display = HdiTestDevice::GetInstance().GetFirstDisplay();
674     if (display != nullptr) {
675         g_displayIds = HdiTestDevice::GetInstance().GetDevIds();
676         display->SetDisplayVsyncEnabled(false);
677     }
678     ::benchmark::RunSpecifiedBenchmarks();
679     ::benchmark::Shutdown();
680     HdiTestDevice::GetInstance().GetFirstDisplay()->ResetClientLayer();
681     return ret;
682 }
683