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