1 /*
2 * Copyright (c) 2024 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 "dmic_client_test.h"
17
18 #include "audio_event.h"
19
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace DistributedHardware {
SetUpTestCase(void)24 void DMicClientTest::SetUpTestCase(void) {}
25
TearDownTestCase(void)26 void DMicClientTest::TearDownTestCase(void) {}
27
SetUp()28 void DMicClientTest::SetUp()
29 {
30 std::string devId = "hello";
31 int32_t dhId = DEFAULT_CAPTURE_ID;
32 clientCallback_ = std::make_shared<MockIAudioEventCallback>();
33 micClient_ = std::make_shared<DMicClient>(devId, dhId, clientCallback_);
34 micClient_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
35
36 audioParam_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC;
37 audioParam_.comParam.sampleRate = AudioSampleRate::SAMPLE_RATE_48000;
38 audioParam_.comParam.bitFormat = AudioSampleFormat::SAMPLE_S16LE;
39 audioParam_.comParam.channelMask = AudioChannel::STEREO;
40 audioParam_.captureOpts.sourceType = SourceType::SOURCE_TYPE_MIC;
41 }
42
TearDown()43 void DMicClientTest::TearDown()
44 {
45 clientCallback_ = nullptr;
46 micClient_ = nullptr;
47 }
48
49 /**
50 * @tc.name: InitSenderEngine_001
51 * @tc.desc: Verify the InitSenderEngine function.
52 * @tc.type: FUNC
53 * @tc.require: AR000H0E6G
54 */
55 HWTEST_F(DMicClientTest, InitSenderEngine_001, TestSize.Level1)
56 {
57 ASSERT_TRUE(micClient_ != nullptr);
58 IAVEngineProvider *providerPtr = nullptr;
59 auto message = std::make_shared<AVTransMessage>();
60 micClient_->OnEngineTransMessage(message);
61 EXPECT_EQ(DH_SUCCESS, micClient_->InitSenderEngine(providerPtr));
62 }
63
64 /**
65 * @tc.name: OnStateChange_001
66 * @tc.desc: Verify the OnStateChange function.
67 * @tc.type: FUNC
68 * @tc.require: AR000H0E6G
69 */
70 HWTEST_F(DMicClientTest, OnStateChange_001, TestSize.Level1)
71 {
72 ASSERT_TRUE(micClient_ != nullptr);
73 EXPECT_NE(DH_SUCCESS, micClient_->OnStateChange(AudioEventType::NOTIFY_OPEN_SPEAKER_RESULT));
74 }
75
76 /**
77 * @tc.name: OnStateChange_002
78 * @tc.desc: Verify the OnStateChange function.
79 * @tc.type: FUNC
80 * @tc.require: AR000H0E6G
81 */
82 HWTEST_F(DMicClientTest, OnStateChange_002, TestSize.Level1)
83 {
84 ASSERT_TRUE(micClient_ != nullptr);
85 EXPECT_EQ(DH_SUCCESS, micClient_->OnStateChange(AudioEventType::DATA_CLOSED));
86 }
87
88 /**
89 * @tc.name: SetUp_001
90 * @tc.desc: Verify the SetUp function.
91 * @tc.type: FUNC
92 * @tc.require: AR000H0E6G
93 */
94 HWTEST_F(DMicClientTest, SetUp_001, TestSize.Level1)
95 {
96 ASSERT_TRUE(micClient_ != nullptr);
97 std::string devId = "testID";
98 auto clientCallback = std::make_shared<MockIAudioEventCallback>();
99 micClient_->SetAttrs(devId, clientCallback);
100 AudioParam audioParam;
101 EXPECT_NE(DH_SUCCESS, micClient_->SetUp(audioParam));
102 EXPECT_EQ(DH_SUCCESS, micClient_->SetUp(audioParam_));
103 }
104
105 /**
106 * @tc.name: StartCapture001
107 * @tc.desc: Verify the StartCapture function.
108 * @tc.type: FUNC
109 * @tc.require: AR000H0E6G
110 */
111 HWTEST_F(DMicClientTest, StartCapture001, TestSize.Level1)
112 {
113 ASSERT_TRUE(micClient_ != nullptr);
114 micClient_->CaptureThreadRunning();
115 EXPECT_NE(DH_SUCCESS, micClient_->StartCapture());
116 EXPECT_NE(DH_SUCCESS, micClient_->StopCapture());
117
118 AudioStandard::AudioCapturerOptions capturerOptions = {
119 {
120 static_cast<AudioStandard::AudioSamplingRate>(audioParam_.comParam.sampleRate),
121 AudioStandard::AudioEncodingType::ENCODING_PCM,
122 static_cast<AudioStandard::AudioSampleFormat>(audioParam_.comParam.bitFormat),
123 static_cast<AudioStandard::AudioChannel>(audioParam_.comParam.channelMask),
124 },
125 {
126 static_cast<AudioStandard::SourceType>(audioParam_.captureOpts.sourceType),
127 0,
128 }
129 };
130 micClient_->audioCapturer_ = AudioStandard::AudioCapturer::Create(capturerOptions);
131 micClient_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
132 micClient_->clientStatus_ = AudioStatus::STATUS_STOP;
133 EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->StartCapture());
134 micClient_->clientStatus_ = AudioStatus::STATUS_READY;
135 EXPECT_NE(nullptr, micClient_->audioCapturer_);
136 EXPECT_EQ(DH_SUCCESS, micClient_->StartCapture());
137 micClient_->micTrans_ = nullptr;
138 EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->StartCapture());
139 EXPECT_NE(DH_SUCCESS, micClient_->StopCapture());
140 }
141
142 /**
143 * @tc.name: StopCapture001
144 * @tc.desc: Verify the StopCapture function.
145 * @tc.type: FUNC
146 * @tc.require: AR000H0E6G
147 */
148 HWTEST_F(DMicClientTest, StopCapture001, TestSize.Level1)
149 {
150 ASSERT_TRUE(micClient_ != nullptr);
151 std::shared_ptr<AudioData> audioData = nullptr;
152 EXPECT_NE(DH_SUCCESS, micClient_->StopCapture());
153 micClient_->clientStatus_ = STATUS_START;
154 EXPECT_NE(DH_SUCCESS, micClient_->StopCapture());
155 size_t length = 1;
156 micClient_->OnReadData(length);
157 EXPECT_EQ(DH_SUCCESS, micClient_->OnDecodeTransDataDone(audioData));
158 }
159
160 /**
161 * @tc.name: StopCapture002
162 * @tc.desc: Verify the StopCapture function.
163 * @tc.type: FUNC
164 * @tc.require: AR000H0E6G
165 */
166 HWTEST_F(DMicClientTest, StopCapture002, TestSize.Level1)
167 {
168 ASSERT_TRUE(micClient_ != nullptr);
169 micClient_->clientStatus_ = STATUS_START;
170 EXPECT_EQ(ERR_DH_AUDIO_FAILED, micClient_->StopCapture());
171 micClient_->isCaptureReady_.store(true);
172 EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->StopCapture());
173 micClient_->SetUp(audioParam_);
174 EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->StopCapture());
175 }
176
177 /**
178 * @tc.name: Release001
179 * @tc.desc: Verify the Release function.
180 * @tc.type: FUNC
181 * @tc.require: AR000H0E6G
182 */
183 HWTEST_F(DMicClientTest, Release001, TestSize.Level1)
184 {
185 ASSERT_TRUE(micClient_ != nullptr);
186 micClient_->clientStatus_ = AudioStatus::STATUS_START;
187 EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->Release());
188 micClient_->clientStatus_ = AudioStatus::STATUS_STOP;
189 micClient_->micTrans_ = nullptr;
190 EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->Release());
191 micClient_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
192
193 AudioStandard::AudioCapturerOptions capturerOptions = {
194 {
195 static_cast<AudioStandard::AudioSamplingRate>(audioParam_.comParam.sampleRate),
196 AudioStandard::AudioEncodingType::ENCODING_PCM,
197 static_cast<AudioStandard::AudioSampleFormat>(audioParam_.comParam.bitFormat),
198 static_cast<AudioStandard::AudioChannel>(audioParam_.comParam.channelMask),
199 },
200 {
201 static_cast<AudioStandard::SourceType>(audioParam_.captureOpts.sourceType),
202 0,
203 }
204 };
205 micClient_->audioCapturer_ = AudioStandard::AudioCapturer::Create(capturerOptions);
206 EXPECT_NE(nullptr, micClient_->audioCapturer_);
207 EXPECT_EQ(DH_SUCCESS, micClient_->Release());
208 micClient_->audioCapturer_ = nullptr;
209 micClient_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
210 micClient_->clientStatus_ = AudioStatus::STATUS_STOP;
211 EXPECT_EQ(ERR_DH_AUDIO_FAILED, micClient_->Release());
212 micClient_->clientStatus_ = AudioStatus::STATUS_IDLE;
213 EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->Release());
214 }
215
216 /**
217 * @tc.name: SendMessage_001
218 * @tc.desc: Verify the SendMessage function.
219 * @tc.type: FUNC
220 * @tc.require: AR000H0E6G
221 */
222 HWTEST_F(DMicClientTest, SendMessage_001, TestSize.Level1)
223 {
224 ASSERT_TRUE(micClient_ != nullptr);
225 std::string content = "content";
226 std::string dstDevId = "dstDevId";
227 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, micClient_->SendMessage(EVENT_UNKNOWN, content, dstDevId));
228 micClient_->InitCtrlTrans();
229 EXPECT_EQ(DH_SUCCESS, micClient_->SendMessage(NOTIFY_OPEN_MIC_RESULT, content, dstDevId));
230 micClient_->micCtrlTrans_ = nullptr;
231 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, micClient_->SendMessage(NOTIFY_OPEN_MIC_RESULT, content, dstDevId));
232 }
233
234 /**
235 * @tc.name: AudioFwkClientSetUp_001
236 * @tc.desc: Verify the AudioFwkClientSetUp function.
237 * @tc.type: FUNC
238 * @tc.require: AR000H0E6G
239 */
240 HWTEST_F(DMicClientTest, AudioFwkClientSetUp_001, TestSize.Level1)
241 {
242 ASSERT_TRUE(micClient_ != nullptr);
243 audioParam_.captureOpts.capturerFlags = MMAP_MODE;
244 int32_t actual = micClient_->AudioFwkClientSetUp();
245 EXPECT_EQ(ERR_DH_AUDIO_CLIENT_CAPTURER_CREATE_FAILED, actual);
246 audioParam_.captureOpts.capturerFlags = NORMAL_MODE;
247 actual = micClient_->AudioFwkClientSetUp();
248 EXPECT_NE(DH_SUCCESS, actual);
249 }
250
251 /**
252 * @tc.name: TransSetUp_001
253 * @tc.desc: Verify the TransSetUp function.
254 * @tc.type: FUNC
255 * @tc.require: AR000H0E6G
256 */
257 HWTEST_F(DMicClientTest, TransSetUp_001, TestSize.Level1)
258 {
259 ASSERT_TRUE(micClient_ != nullptr);
260 int32_t actual = micClient_->TransSetUp();
261 EXPECT_EQ(DH_SUCCESS, actual);
262 micClient_->micTrans_ = nullptr;
263 actual = micClient_->TransSetUp();
264 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, actual);
265 }
266 } // DistributedHardware
267 } // OHOS
268