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
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;
42
43namespace {
44class DisplayBenchmarkTest : public benchmark::Fixture {
45public:
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
52void DisplayBenchmarkTest::TearDown(const ::benchmark::State &state)
53{
54    HdiTestDevice::GetInstance().Clear();
55}
56
57void DisplayBenchmarkTest::OnMode(uint32_t modeId, uint64_t vBlankPeriod, void* data)
58{
59}
60
61void DisplayBenchmarkTest::OnseamlessChange(uint32_t devId, void* data)
62{
63}
64
65void DisplayBenchmarkTest::TestRefreshCallback(uint32_t devId, void* data)
66{
67}
68
69/**
70  * @tc.name: SetClientBufferCacheCountTest
71  * @tc.desc: Benchmarktest for interface SetClientBufferCacheCount.
72  */
73BENCHMARK_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  */
87BENCHMARK_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
97BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayCapabilityTest)->
98    Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
99
100/**
101  * @tc.name: GetDisplaySupportedModesTest
102  * @tc.desc: Benchmarktest for interface GetDisplaySupportedModes.
103  */
104BENCHMARK_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
114BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedModesTest)->
115    Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
116
117/**
118  * @tc.name: GetDisplayModeTest
119  * @tc.desc: Benchmarktest for interface GetDisplayMode.
120  */
121BENCHMARK_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
131BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayModeTest)->
132    Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
133
134/**
135  * @tc.name: SetDisplayModeTest
136  * @tc.desc: Benchmarktest for interface SetDisplayMode.
137  */
138BENCHMARK_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
148BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayModeTest)->
149    Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
150
151/**
152  * @tc.name: GetDisplayPowerStatusTest
153  * @tc.desc: Benchmarktest for interface GetDisplayPowerStatus.
154  */
155BENCHMARK_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
165BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayPowerStatusTest)->
166    Iterations(100)->Repetitions(3)->ReportAggregatesOnly();
167
168/**
169  * @tc.name: SetDisplayPowerStatusTest
170  * @tc.desc: Benchmarktest for interface SetDisplayPowerStatus.
171  */
172BENCHMARK_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
182BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayPowerStatusTest)->
183    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
184
185/**
186  * @tc.name: GetDisplayBacklightTest
187  * @tc.desc: Benchmarktest for interface GetDisplayBacklight.
188  */
189BENCHMARK_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
199BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayBacklightTest)->
200    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
201
202/**
203  * @tc.name: SetDisplayBacklightTest
204  * @tc.desc: Benchmarktest for interface SetDisplayBacklight.
205  */
206BENCHMARK_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
216BENCHMARK_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  */
223BENCHMARK_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
237BENCHMARK_REGISTER_F(DisplayBenchmarkTest, CreateAndDestroyLayerTest)->
238    Iterations(10)->Repetitions(3)->ReportAggregatesOnly();
239
240/**
241  * @tc.name: GetDisplayCompChangeTest
242  * @tc.desc: Benchmarktest for interface GetDisplayCompChange.
243  */
244BENCHMARK_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
255BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayCompChangeTest)->
256    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
257
258/**
259  * @tc.name: GetDisplayReleaseFenceTest
260  * @tc.desc: Benchmarktest for interface GetDisplayReleaseFence.
261  */
262BENCHMARK_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
273BENCHMARK_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  */
280BENCHMARK_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
294BENCHMARK_REGISTER_F(DisplayBenchmarkTest, CreateAndDestroyVirtualDisplayTest)->
295    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
296
297/**
298  * @tc.name: SetVirtualDisplayBufferTest
299  * @tc.desc: Benchmarktest for interface SetVirtualDisplayBuffer.
300  */
301BENCHMARK_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
326BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetVirtualDisplayBufferTest)->
327    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
328
329/**
330  * @tc.name: SetDisplayPropertyTest
331  * @tc.desc: Benchmarktest for interface SetDisplayProperty.
332  */
333BENCHMARK_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
344BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayPropertyTest)->
345    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
346
347/**
348  * @tc.name: GetDisplayPropertyTest
349  * @tc.desc: Benchmarktest for interface GetDisplayProperty.
350  */
351BENCHMARK_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
366BENCHMARK_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  */
374BENCHMARK_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
387BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedModesExtTest)->
388    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
389
390/**
391  * @tc.name: SetDisplayModeAsyncTest
392  * @tc.desc: Benchmarktest for interface SetDisplayModeAsyncTest.
393  */
394BENCHMARK_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
407BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayModeAsyncTest)->
408    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
409
410/**
411  * @tc.name: GetDisplayVBlankPeriodTest
412  * @tc.desc: Benchmarktest for interface GetDisplayVBlankPeriodTest.
413  */
414BENCHMARK_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
427BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplayVBlankPeriodTest)->
428    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
429
430/**
431  * @tc.name: RegSeamlessChangeCallbackTest
432  * @tc.desc: Benchmarktest for interface RegSeamlessChangeCallbackTest.
433  */
434BENCHMARK_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
446BENCHMARK_REGISTER_F(DisplayBenchmarkTest, RegSeamlessChangeCallbackTest)->
447    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
448
449/**
450  * @tc.name: SetLayerPerFrameParameterTest
451  * @tc.desc: Benchmarktest for interface SetLayerPerFrameParameter.
452  */
453BENCHMARK_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
473BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetLayerPerFrameParameterTest)->
474    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
475
476/**
477  * @tc.name: GetSupportedLayerPerFrameParameterKeyTest
478  * @tc.desc: Benchmarktest for interface GetSupportedLayerPerFrameParameterKey.
479  */
480BENCHMARK_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
493BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetSupportedLayerPerFrameParameterKeyTest)->
494    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
495
496/**
497  * @tc.name: SetDisplayOverlayResolutionTest
498  * @tc.desc: Benchmarktest for interface SetDisplayOverlayResolution.
499  */
500BENCHMARK_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
513BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayOverlayResolutionTest)->
514    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
515
516/**
517  * @tc.name: RegRefreshCallbackTest
518  * @tc.desc: Benchmarktest for interface RegRefreshCallback.
519  */
520BENCHMARK_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
532BENCHMARK_REGISTER_F(DisplayBenchmarkTest, RegRefreshCallbackTest)->
533    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
534
535/**
536  * @tc.name: GetDisplaySupportedColorGamutsTest
537  * @tc.desc: Benchmarktest for interface GetDisplaySupportedColorGamuts.
538  */
539BENCHMARK_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
552BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetDisplaySupportedColorGamutsTest)->
553    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
554
555/**
556  * @tc.name: GetHDRCapabilityInfosTest
557  * @tc.desc: Benchmarktest for interface GetHDRCapabilityInfos.
558  */
559BENCHMARK_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
572BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetHDRCapabilityInfosTest)->
573    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
574
575/**
576  * @tc.name: SetDisplayClientCropTest
577  * @tc.desc: Benchmarktest for interface SetDisplayClientCrop.
578  */
579BENCHMARK_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
591BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetDisplayClientCropTest)->
592    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
593
594/**
595  * @tc.name: SetHardwareCursorPositionTest
596  * @tc.desc: Benchmarktest for interface SetHardwareCursorPositionTest.
597  */
598BENCHMARK_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
612BENCHMARK_REGISTER_F(DisplayBenchmarkTest, SetHardwareCursorPositionTest)->
613    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
614
615/**
616  * @tc.name: EnableHardwareCursorStatsTest
617  * @tc.desc: Benchmarktest for interface EnableHardwareCursorStatsTest.
618  */
619BENCHMARK_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
632BENCHMARK_REGISTER_F(DisplayBenchmarkTest, EnableHardwareCursorStatsTest)->
633    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
634
635/**
636  * @tc.name: GetHardwareCursorStatsTest
637  * @tc.desc: Benchmarktest for interface GetHardwareCursorStatsTest.
638  */
639BENCHMARK_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
653BENCHMARK_REGISTER_F(DisplayBenchmarkTest, GetHardwareCursorStatsTest)->
654    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
655
656/**
657  * @tc.name: ClearClientBufferTest
658  * @tc.desc: Benchmarktest for interface ClearClientBufferTest.
659  */
660BENCHMARK_F(DisplayBenchmarkTest, ClearClientBufferTest)(benchmark::State &state)
661{
662    int32_t ret = 0;
663    for (auto _ : state) {
664        ret = g_composerDevice->ClearClientBuffer(g_displayIds[0]);
665    }
666    if (ret == DISPLAY_NOT_SUPPORT) {
667        return;
668    }
669    EXPECT_EQ(DISPLAY_SUCCESS, ret);
670}
671
672BENCHMARK_REGISTER_F(DisplayBenchmarkTest, ClearClientBufferTest)->
673    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
674
675/**
676  * @tc.name: ClearLayerBufferTest
677  * @tc.desc: Benchmarktest for interface ClearLayerBufferTest.
678  */
679BENCHMARK_F(DisplayBenchmarkTest, ClearLayerBufferTest)(benchmark::State &state)
680{
681    int32_t ret = 0;
682    uint32_t layerId = 1;
683    for (auto _ : state) {
684        ret = g_composerDevice->ClearLayerBuffer(g_displayIds[0], layerId);
685    }
686    if (ret == DISPLAY_NOT_SUPPORT) {
687        return;
688    }
689    EXPECT_EQ(DISPLAY_FAILURE, ret);
690}
691
692BENCHMARK_REGISTER_F(DisplayBenchmarkTest, ClearLayerBufferTest)->
693    Iterations(30)->Repetitions(3)->ReportAggregatesOnly();
694
695} // namespace
696
697int main(int argc, char** argv)
698{
699    int ret = HdiTestDevice::GetInstance().InitDevice();
700    DISPLAY_TEST_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_TEST_LOGE("Init Device Failed"));
701    ::testing::InitGoogleTest(&argc, argv);
702    ::benchmark::Initialize(&argc, argv);
703    if (::benchmark::ReportUnrecognizedArguments(argc, argv)) {
704        return 1;
705    }
706    g_composerDevice = HdiTestDevice::GetInstance().GetDeviceInterface();
707    DISPLAY_TEST_CHK_RETURN((g_composerDevice == nullptr), DISPLAY_FAILURE,
708        DISPLAY_TEST_LOGE("get composer interface failed"));
709    g_gralloc.reset(IDisplayBuffer::Get());
710    DISPLAY_TEST_CHK_RETURN((g_gralloc == nullptr), DISPLAY_FAILURE,
711        DISPLAY_TEST_LOGE("get buffer interface failed"));
712    auto display = HdiTestDevice::GetInstance().GetFirstDisplay();
713    if (display != nullptr) {
714        g_displayIds = HdiTestDevice::GetInstance().GetDevIds();
715        display->SetDisplayVsyncEnabled(false);
716    }
717    ::benchmark::RunSpecifiedBenchmarks();
718    ::benchmark::Shutdown();
719    HdiTestDevice::GetInstance().GetFirstDisplay()->ResetClientLayer();
720    return ret;
721}
722