1 /*
2  * Copyright (c) 2022 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 <gtest/gtest.h>
17 #include "hdi_service_common.h"
18 #include "osal_mem.h"
19 
20 using namespace std;
21 using namespace testing::ext;
22 using namespace OHOS::Audio;
23 
24 namespace {
25 const float COUNT = 1000;             // number of interface calls
26 const int32_t LOWLATENCY = 10000;     // low interface delay:10ms
27 
28 class AudioIdlHdiManagerPerformaceTest : public testing::Test {
29 public:
30     static void SetUpTestCase(void);
31     static void TearDownTestCase(void);
32     void SetUp();
33     void TearDown();
34     static TestAudioManager *manager;
35 };
36 using THREAD_FUNC = void *(*)(void *);
37 TestAudioManager *AudioIdlHdiManagerPerformaceTest::manager = nullptr;
38 
SetUpTestCase(void)39 void AudioIdlHdiManagerPerformaceTest::SetUpTestCase(void)
40 {
41     manager = IAudioManagerGet(IS_STUB);
42     ASSERT_NE(nullptr, manager);
43 }
44 
TearDownTestCase(void)45 void AudioIdlHdiManagerPerformaceTest::TearDownTestCase(void)
46 {
47     if (manager != nullptr) {
48         (void)IAudioManagerRelease(manager, IS_STUB);
49     }
50 }
51 
SetUp(void)52 void AudioIdlHdiManagerPerformaceTest::SetUp(void) {}
53 
TearDown(void)54 void AudioIdlHdiManagerPerformaceTest::TearDown(void) {}
55 
56 /**
57 * @tc.name  AudioManagerGetAllAdapterPerformance_001
58 * @tc.desc  tests the performace of ManagerGetAllAdapters interface by executing 1000 times,
59 *           and calculates the delay time and average of Delay Time.
60 * @tc.type: PERF
61 */
62 HWTEST_F(AudioIdlHdiManagerPerformaceTest, AudioManagerGetAllAdaptersPerformance_001, TestSize.Level1)
63 {
64     int32_t ret;
65     uint32_t descsLen = AUDIO_ADAPTER_MAX_NUM;
66     struct PrepareAudioPara audiopara = { .manager = manager, .totalTime = 0 };
67     ASSERT_NE(nullptr, audiopara.manager);
68 
69     for (int i = 0; i < COUNT; ++i) {
70         audiopara.descs = (struct AudioAdapterDescriptor*)OsalMemCalloc(
71                               sizeof(struct AudioAdapterDescriptor) * (AUDIO_ADAPTER_MAX_NUM));
72         ASSERT_NE(nullptr, audiopara.descs);
73         gettimeofday(&audiopara.start, NULL);
74         ret = audiopara.manager->GetAllAdapters(audiopara.manager, audiopara.descs, &descsLen);
75         gettimeofday(&audiopara.end, NULL);
76         EXPECT_EQ(HDF_SUCCESS, ret);
77         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
78                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
79         audiopara.totalTime += audiopara.delayTime;
80         TestReleaseAdapterDescs(&audiopara.descs, descsLen);
81         audiopara.descs = nullptr;
82     }
83     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
84     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
85 }
86 
87 /**
88 * @tc.name  AudioManagerLoadAdapterPerformance_001
89 * @tc.desc  tests the performace of ManagerLoadAdapter interface by executing 1000 times,
90 *           and calculates the delay time and average of Delay Time.
91 * @tc.type: PERF
92 */
93 HWTEST_F(AudioIdlHdiManagerPerformaceTest, AudioManagerLoadAdapterPerformance_001, TestSize.Level1)
94 {
95     int32_t ret;
96     uint32_t descsLen = AUDIO_ADAPTER_MAX_NUM;
97     struct PrepareAudioPara audiopara = { .manager = manager, .totalTime = 0 };
98     ASSERT_NE(nullptr, audiopara.manager);
99     ret = GetAdapters(audiopara.manager, audiopara.descs, descsLen);
100     ASSERT_EQ(HDF_SUCCESS, ret);
101     audiopara.desc = &audiopara.descs[0];
102     EXPECT_NE(nullptr, audiopara.desc);
103 
104     for (int i = 0; i < COUNT; ++i) {
105         gettimeofday(&audiopara.start, NULL);
106         ret = audiopara.manager->LoadAdapter(audiopara.manager, audiopara.desc, &audiopara.adapter);
107         gettimeofday(&audiopara.end, NULL);
108         EXPECT_EQ(HDF_SUCCESS, ret);
109 
110         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
111                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
112         audiopara.totalTime += audiopara.delayTime;
113         ret = audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.desc->adapterName);
114         EXPECT_EQ(HDF_SUCCESS, ret);
115         IAudioAdapterRelease(audiopara.adapter, IS_STUB);
116         audiopara.adapter = nullptr;
117     }
118     TestReleaseAdapterDescs(&audiopara.descs, descsLen);
119     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
120     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
121 }
122 
123 /**
124 * @tc.name  AudioManagerUnLoadAdapterPerformance_001
125 * @tc.desc  tests the performace of ManagerLoadAdapter interface by executing 1000 times,
126 *           and calculates the delay time and average of Delay Time.
127 * @tc.type: PERF
128 */
129 HWTEST_F(AudioIdlHdiManagerPerformaceTest, AudioManagerUnLoadAdapterPerformance_001, TestSize.Level1)
130 {
131     int32_t ret;
132     struct PrepareAudioPara audiopara = {
133         .manager = manager, .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(),
134         .totalTime = 0
135     };
136     ASSERT_NE(nullptr, audiopara.manager);
137 
138     for (int i = 0; i < COUNT; ++i) {
139         ret = GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName, &audiopara.adapter,
140                              audiopara.audioPort);
141         EXPECT_EQ(HDF_SUCCESS, ret);
142         gettimeofday(&audiopara.start, NULL);
143         ret = audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapterName);
144         gettimeofday(&audiopara.end, NULL);
145         EXPECT_EQ(HDF_SUCCESS, ret);
146         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
147                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
148         audiopara.totalTime += audiopara.delayTime;
149         IAudioAdapterRelease(audiopara.adapter, IS_STUB);
150         audiopara.adapter = nullptr;
151         if (audiopara.audioPort.portName != nullptr) {
152             free(audiopara.audioPort.portName);
153         }
154     }
155     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
156     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
157 }
158 }
159