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
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Audio;
22
23 namespace {
24 class AudioIdlHdiRenderSceneTest : public testing::Test {
25 public:
26 static void SetUpTestCase(void);
27 static void TearDownTestCase(void);
28 void SetUp();
29 void TearDown();
30 struct IAudioRender *render = nullptr;
31 static TestAudioManager *manager;
32 struct IAudioAdapter *adapter = nullptr;
33 };
34
35 TestAudioManager *AudioIdlHdiRenderSceneTest::manager = nullptr;
36
SetUpTestCase(void)37 void AudioIdlHdiRenderSceneTest::SetUpTestCase(void)
38 {
39 manager = IAudioManagerGet(IS_STUB);
40 ASSERT_NE(nullptr, manager);
41 }
42
TearDownTestCase(void)43 void AudioIdlHdiRenderSceneTest::TearDownTestCase(void)
44 {
45 if (manager != nullptr) {
46 (void)IAudioManagerRelease(manager, IS_STUB);
47 }
48 }
49
SetUp(void)50 void AudioIdlHdiRenderSceneTest::SetUp(void)
51 {
52 ASSERT_NE(nullptr, manager);
53 int32_t ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
54 ASSERT_EQ(HDF_SUCCESS, ret);
55 }
56
TearDown(void)57 void AudioIdlHdiRenderSceneTest::TearDown(void)
58 {
59 int32_t ret = ReleaseRenderSource(manager, adapter, render);
60 ASSERT_EQ(HDF_SUCCESS, ret);
61 }
62
63 /**
64 * @tc.name AudioRenderCheckSceneCapability_001
65 * @tc.desc Test AudioRenderCheckSceneCapability interface,return 0 if check scene's capability successful.
66 * @tc.type: FUNC
67 */
68 HWTEST_F(AudioIdlHdiRenderSceneTest, AudioRenderCheckSceneCapability_001, TestSize.Level1)
69 {
70 int32_t ret = -1;
71 bool supported = false;
72 struct AudioSceneDescriptor scenes = {};
73 scenes.scene.id = 0;
74 scenes.desc.pins = PIN_OUT_SPEAKER;
75 scenes.desc.desc = strdup("mic");
76
77 ASSERT_NE(nullptr, render);
78 ret = render->CheckSceneCapability(render, &scenes, &supported);
79 EXPECT_EQ(HDF_SUCCESS, ret);
80 EXPECT_TRUE(supported);
81 free(scenes.desc.desc);
82 }
83 /**
84 * @tc.name AudioRenderCheckSceneCapability_002
85 * @tc.desc Test RenderCheckSceneCapability interface,return -1 if the scene is not configed in the josn.
86 * @tc.type: FUNC
87 */
88 HWTEST_F(AudioIdlHdiRenderSceneTest, AudioRenderCheckSceneCapability_002, TestSize.Level1)
89 {
90 int32_t ret = -1;
91 bool supported = true;
92 struct AudioSceneDescriptor scenes = {};
93 scenes.scene.id = 5;
94 scenes.desc.pins = PIN_OUT_SPEAKER;
95 scenes.desc.desc = strdup("mic");
96
97 ASSERT_NE(nullptr, render);
98 ret = render->CheckSceneCapability(render, &scenes, &supported);
99 EXPECT_EQ(HDF_FAILURE, ret);
100 free(scenes.desc.desc);
101 }
102 /**
103 * @tc.name AudioRenderCheckSceneCapabilityNull_003
104 * @tc.desc Test AudioRenderCheckSceneCapability,return -3/-4 if the render is nullptr.
105 * @tc.type: FUNC
106 */
107 HWTEST_F(AudioIdlHdiRenderSceneTest, AudioRenderCheckSceneCapabilityNull_003, TestSize.Level1)
108 {
109 int32_t ret = -1;
110 bool supported = true;
111 struct AudioSceneDescriptor scenes = {};
112 struct IAudioRender *renderNull = nullptr;
113 scenes.scene.id = 0;
114 scenes.desc.pins = PIN_OUT_SPEAKER;
115 scenes.desc.desc = strdup("mic");
116
117 ASSERT_NE(nullptr, render);
118 ret = render->CheckSceneCapability(renderNull, &scenes, &supported);
119 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
120 free(scenes.desc.desc);
121 }
122 /**
123 * @tc.name AudioRenderCheckSceneCapabilityNull_004
124 * @tc.desc Test AudioRenderCheckSceneCapability interface,return -3 if the scene is nullptr.
125 * @tc.type: FUNC
126 */
127 HWTEST_F(AudioIdlHdiRenderSceneTest, AudioRenderCheckSceneCapabilityNull_004, TestSize.Level1)
128 {
129 int32_t ret = -1;
130 bool supported = true;
131 struct AudioSceneDescriptor *scenes = nullptr;
132 ASSERT_NE(nullptr, render);
133
134 ret = render->CheckSceneCapability(render, scenes, &supported);
135 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
136 }
137 #ifdef AUDIO_ADM_PASSTHROUGH
138 /**
139 * @tc.name AudioRenderCheckSceneCapabilityNull_005
140 * @tc.desc Test AudioRenderCheckSceneCapability interface,return -3 if the supported is nullptr.
141 * @tc.type: FUNC
142 */
143 HWTEST_F(AudioIdlHdiRenderSceneTest, AudioRenderCheckSceneCapabilityNull_005, TestSize.Level1)
144 {
145 int32_t ret = -1;
146 struct AudioSceneDescriptor scenes = {};
147 scenes.scene.id = 0;
148 scenes.desc.pins = PIN_OUT_SPEAKER;
149 scenes.desc.desc = strdup("mic");
150
151 ASSERT_NE(nullptr, render);
152 ret = render->CheckSceneCapability(render, &scenes, nullptr);
153 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
154 free(scenes.desc.desc);
155 }
156 #endif
157 /**
158 * @tc.name AudioRenderSelectScene_001
159 * @tc.desc Test RenderSelectScene interface,return 0 if select Render's scene successful.
160 * @tc.type: FUNC
161 */
162 HWTEST_F(AudioIdlHdiRenderSceneTest, AudioRenderSelectScene_001, TestSize.Level1)
163 {
164 int32_t ret = -1;
165 struct AudioSceneDescriptor scenes = {};
166 scenes.scene.id = 0;
167 scenes.desc.pins = PIN_OUT_SPEAKER;
168 scenes.desc.desc = strdup("mic");
169
170 ASSERT_NE(nullptr, render);
171 ret = render->SelectScene(render, &scenes);
172 EXPECT_EQ(HDF_SUCCESS, ret);
173
174 ret = AudioRenderStartAndOneFrame(render);
175 EXPECT_EQ(HDF_SUCCESS, ret);
176 ret = render->Stop(render);
177 EXPECT_EQ(HDF_SUCCESS, ret);
178 free(scenes.desc.desc);
179 }
180 /**
181 * @tc.name AudioRenderSelectScene_002
182 * @tc.desc Test RenderSelectScene, return 0 if select Render's scene successful after Render start.
183 * @tc.type: FUNC
184 */
185 HWTEST_F(AudioIdlHdiRenderSceneTest, AudioRenderSelectScene_002, TestSize.Level1)
186 {
187 int32_t ret = -1;
188 struct AudioSceneDescriptor scenes = {};
189 scenes.scene.id = 0;
190 scenes.desc.pins = PIN_OUT_SPEAKER;
191 scenes.desc.desc = strdup("mic");
192
193 ASSERT_NE(nullptr, render);
194 ret = AudioRenderStartAndOneFrame(render);
195 EXPECT_EQ(HDF_SUCCESS, ret);
196
197 ret = render->SelectScene(render, &scenes);
198 EXPECT_EQ(HDF_SUCCESS, ret);
199 ret = render->Stop(render);
200 EXPECT_EQ(HDF_SUCCESS, ret);
201 free(scenes.desc.desc);
202 }
203 /**
204 * @tc.name AudioRenderSelectSceneNull_003
205 * @tc.desc Test RenderSelectScene, return -3/-4 if the parameter handle is nullptr.
206 * @tc.type: FUNC
207 */
208 HWTEST_F(AudioIdlHdiRenderSceneTest, AudioRenderSelectSceneNull_003, TestSize.Level1)
209 {
210 int32_t ret = -1;
211 ASSERT_NE(nullptr, render);
212 struct AudioSceneDescriptor scenes = {};
213 scenes.scene.id = 0;
214 scenes.desc.pins = PIN_IN_MIC;
215 struct IAudioRender *renderNull = nullptr;
216 scenes.desc.desc = strdup("mic");
217
218 ret = render->SelectScene(renderNull, &scenes);
219 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
220 free(scenes.desc.desc);
221 }
222 /**
223 * @tc.name AudioRenderSelectSceneNull_004
224 * @tc.desc Test RenderSelectScene, return -3 if the parameter scene is nullptr.
225 * @tc.type: FUNC
226 */
227 HWTEST_F(AudioIdlHdiRenderSceneTest, AudioRenderSelectSceneNull_004, TestSize.Level1)
228 {
229 int32_t ret = -1;
230 struct AudioSceneDescriptor *scenes = nullptr;
231 ASSERT_NE(nullptr, render);
232
233 ret = render->SelectScene(render, scenes);
234 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
235 }
236 /**
237 * @tc.name AudioAudioRenderSelectScene_005
238 * @tc.desc Test AudioRenderSelectScene, return -1 if the scene is not configed in the josn.
239 * @tc.type: FUNC
240 */
241 HWTEST_F(AudioIdlHdiRenderSceneTest, AudioAudioRenderSelectScene_005, TestSize.Level1)
242 {
243 int32_t ret = -1;
244 struct AudioSceneDescriptor scenes = {};
245 scenes.scene.id = 5;
246 scenes.desc.pins = PIN_OUT_HDMI;
247 scenes.desc.desc = strdup("mic");
248
249 ASSERT_NE(nullptr, render);
250 ret = render->SelectScene(render, &scenes);
251 EXPECT_EQ(HDF_FAILURE, ret);
252 free(scenes.desc.desc);
253 }
254 }
255