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#include <gtest/gtest.h>
16#include <benchmark/benchmark.h>
17#include "v3_0/codec_callback_service.h"
18#include "v3_0/icodec_callback.h"
19#include "v3_0/icodec_component_manager.h"
20using namespace std;
21using namespace testing::ext;
22using OHOS::sptr;
23using namespace OHOS::HDI::Codec::V3_0;
24constexpr int64_t APP_DATA = 3;
25namespace {
26const int32_t ITERATION_FREQUENCY = 100;
27const int32_t REPETITION_FREQUENCY = 3;
28class CodecBenchmarkManagerTest : public benchmark::Fixture {
29public:
30    void SetUp(const ::benchmark::State &state)
31    {
32        manager_ = ICodecComponentManager::Get();
33        callback_ = new CodecCallbackService();
34    }
35    void TearDown(const ::benchmark::State &state)
36    {
37        manager_ = nullptr;
38        callback_ = nullptr;
39    }
40
41public:
42    sptr<ICodecComponentManager> manager_;
43    sptr<ICodecCallback> callback_;
44};
45
46BENCHMARK_F(CodecBenchmarkManagerTest, GetComponentNum)(benchmark::State &state)
47{
48    ASSERT_TRUE(manager_ != nullptr);
49    int32_t count = 0;
50    int32_t ret;
51    for (auto _ : state) {
52        ret = manager_->GetComponentNum(count);
53        ASSERT_EQ(ret, HDF_SUCCESS);
54        EXPECT_TRUE(count >= 0);
55    }
56}
57
58BENCHMARK_REGISTER_F(CodecBenchmarkManagerTest, GetComponentNum)->
59    Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
60
61BENCHMARK_F(CodecBenchmarkManagerTest, GetComponentCapabilityList)(benchmark::State &state)
62{
63    ASSERT_TRUE(manager_ != nullptr);
64    int32_t count = 0;
65    auto ret = manager_->GetComponentNum(count);
66    ASSERT_EQ(ret, HDF_SUCCESS);
67    ASSERT_TRUE(count > 0);
68
69    std::vector<CodecCompCapability> capList;
70    for (auto _ : state) {
71        ret = manager_->GetComponentCapabilityList(capList, count);
72        ASSERT_EQ(ret, HDF_SUCCESS);
73    }
74}
75
76BENCHMARK_REGISTER_F(CodecBenchmarkManagerTest, GetComponentCapabilityList)->
77    Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
78
79BENCHMARK_F(CodecBenchmarkManagerTest, CreateComponent)(benchmark::State &state)
80{
81    ASSERT_TRUE(manager_ != nullptr);
82    std::string compName("");
83    int32_t count = 0;
84    auto ret = manager_->GetComponentNum(count);
85    ASSERT_EQ(ret, HDF_SUCCESS);
86    ASSERT_TRUE(count > 0);
87
88    std::vector<CodecCompCapability> capList;
89    ret = manager_->GetComponentCapabilityList(capList, count);
90    ASSERT_EQ(ret, HDF_SUCCESS);
91
92    compName = capList[0].compName;
93    ASSERT_FALSE(compName.empty());
94    sptr<ICodecComponent> component;
95    uint32_t componentId = 0;
96    for (auto _ : state) {
97        ret = manager_->CreateComponent(component, componentId, compName, APP_DATA, callback_);
98        ASSERT_EQ(ret, HDF_SUCCESS);
99        if (componentId != 0) {
100            manager_->DestroyComponent(componentId);
101        }
102    }
103}
104
105BENCHMARK_REGISTER_F(CodecBenchmarkManagerTest, CreateComponent)->
106    Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
107
108BENCHMARK_F(CodecBenchmarkManagerTest, DestroyComponent)(benchmark::State &state)
109{
110    ASSERT_TRUE(manager_ != nullptr);
111    std::string compName("");
112    int32_t count = 0;
113    auto ret = manager_->GetComponentNum(count);
114    ASSERT_EQ(ret, HDF_SUCCESS);
115    ASSERT_TRUE(count > 0);
116
117    std::vector<CodecCompCapability> capList;
118    ret = manager_->GetComponentCapabilityList(capList, count);
119    ASSERT_EQ(ret, HDF_SUCCESS);
120
121    compName = capList[0].compName;
122    ASSERT_FALSE(compName.empty());
123    sptr<ICodecComponent> component;
124    uint32_t componentId = 0;
125    for (auto _ : state) {
126        ret = manager_->CreateComponent(component, componentId, compName, APP_DATA, callback_);
127        ASSERT_EQ(ret, HDF_SUCCESS);
128        if (componentId != 0) {
129            manager_->DestroyComponent(componentId);
130        }
131    }
132}
133
134BENCHMARK_REGISTER_F(CodecBenchmarkManagerTest, DestroyComponent)->
135    Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
136}  // namespace
137