1 /*
2  * Copyright (c) 2022-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     if (micClient_ == nullptr) {
58         return;
59     }
60     IAVEngineProvider *providerPtr = nullptr;
61     auto message = std::make_shared<AVTransMessage>();
62     micClient_->OnEngineTransMessage(message);
63     EXPECT_EQ(DH_SUCCESS, micClient_->InitSenderEngine(providerPtr));
64 }
65 
66 /**
67  * @tc.name: OnStateChange_001
68  * @tc.desc: Verify the OnStateChange function.
69  * @tc.type: FUNC
70  * @tc.require: AR000H0E6G
71  */
72 HWTEST_F(DMicClientTest, OnStateChange_001, TestSize.Level1)
73 {
74     if (micClient_ == nullptr) {
75         return;
76     }
77     EXPECT_NE(DH_SUCCESS, micClient_->OnStateChange(AudioEventType::NOTIFY_OPEN_SPEAKER_RESULT));
78 }
79 
80 /**
81  * @tc.name: OnStateChange_002
82  * @tc.desc: Verify the OnStateChange function.
83  * @tc.type: FUNC
84  * @tc.require: AR000H0E6G
85  */
86 HWTEST_F(DMicClientTest, OnStateChange_002, TestSize.Level1)
87 {
88     if (micClient_ == nullptr) {
89         return;
90     }
91     EXPECT_EQ(DH_SUCCESS, micClient_->OnStateChange(AudioEventType::DATA_CLOSED));
92 }
93 
94 /**
95  * @tc.name: SetUp_001
96  * @tc.desc: Verify the SetUp function.
97  * @tc.type: FUNC
98  * @tc.require: AR000H0E6G
99  */
100 HWTEST_F(DMicClientTest, SetUp_001, TestSize.Level1)
101 {
102     if (micClient_ == nullptr) {
103         return;
104     }
105     std::string devId = "testID";
106     auto clientCallback = std::make_shared<MockIAudioEventCallback>();
107     micClient_->SetAttrs(devId, clientCallback);
108     AudioParam audioParam;
109     EXPECT_NE(DH_SUCCESS, micClient_->SetUp(audioParam));
110     EXPECT_EQ(DH_SUCCESS, micClient_->SetUp(audioParam_));
111 }
112 
113 /**
114  * @tc.name: StartCapture001
115  * @tc.desc: Verify the StartCapture function.
116  * @tc.type: FUNC
117  * @tc.require: AR000H0E6G
118  */
119 HWTEST_F(DMicClientTest, StartCapture001, TestSize.Level1)
120 {
121     if (micClient_ == nullptr) {
122         return;
123     }
124     micClient_->CaptureThreadRunning();
125     EXPECT_NE(DH_SUCCESS, micClient_->StartCapture());
126     EXPECT_NE(DH_SUCCESS, micClient_->StopCapture());
127 
128     AudioStandard::AudioCapturerOptions capturerOptions = {
129         {
130             static_cast<AudioStandard::AudioSamplingRate>(audioParam_.comParam.sampleRate),
131             AudioStandard::AudioEncodingType::ENCODING_PCM,
132             static_cast<AudioStandard::AudioSampleFormat>(audioParam_.comParam.bitFormat),
133             static_cast<AudioStandard::AudioChannel>(audioParam_.comParam.channelMask),
134         },
135         {
136             static_cast<AudioStandard::SourceType>(audioParam_.captureOpts.sourceType),
137             0,
138         }
139     };
140     micClient_->audioCapturer_ = AudioStandard::AudioCapturer::Create(capturerOptions);
141     micClient_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
142     micClient_->clientStatus_ = AudioStatus::STATUS_STOP;
143     EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->StartCapture());
144     micClient_->clientStatus_ = AudioStatus::STATUS_READY;
145     EXPECT_NE(nullptr, micClient_->audioCapturer_);
146     EXPECT_EQ(DH_SUCCESS, micClient_->StartCapture());
147     micClient_->micTrans_ = nullptr;
148     EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->StartCapture());
149     EXPECT_NE(DH_SUCCESS, micClient_->StopCapture());
150 }
151 
152 /**
153  * @tc.name: StopCapture001
154  * @tc.desc: Verify the StopCapture function.
155  * @tc.type: FUNC
156  * @tc.require: AR000H0E6G
157  */
158 HWTEST_F(DMicClientTest, StopCapture001, TestSize.Level1)
159 {
160     if (micClient_ == nullptr) {
161         return;
162     }
163     std::shared_ptr<AudioData> audioData = nullptr;
164     EXPECT_NE(DH_SUCCESS, micClient_->StopCapture());
165     micClient_->clientStatus_ = STATUS_START;
166     EXPECT_NE(DH_SUCCESS, micClient_->StopCapture());
167     size_t length = 1;
168     micClient_->OnReadData(length);
169     EXPECT_EQ(DH_SUCCESS, micClient_->OnDecodeTransDataDone(audioData));
170 }
171 
172 /**
173  * @tc.name: StopCapture002
174  * @tc.desc: Verify the StopCapture function.
175  * @tc.type: FUNC
176  * @tc.require: AR000H0E6G
177  */
178 HWTEST_F(DMicClientTest, StopCapture002, TestSize.Level1)
179 {
180     if (micClient_ == nullptr) {
181         return;
182     }
183     micClient_->clientStatus_ = STATUS_START;
184     EXPECT_EQ(ERR_DH_AUDIO_FAILED, micClient_->StopCapture());
185     micClient_->isCaptureReady_.store(true);
186     EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->StopCapture());
187     micClient_->SetUp(audioParam_);
188     EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->StopCapture());
189 }
190 
191 /**
192  * @tc.name: Release001
193  * @tc.desc: Verify the Release function.
194  * @tc.type: FUNC
195  * @tc.require: AR000H0E6G
196  */
197 HWTEST_F(DMicClientTest, Release001, TestSize.Level1)
198 {
199     if (micClient_ == nullptr) {
200         return;
201     }
202     micClient_->clientStatus_ = AudioStatus::STATUS_START;
203     EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->Release());
204     micClient_->clientStatus_ = AudioStatus::STATUS_STOP;
205     micClient_->micTrans_ = nullptr;
206     EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->Release());
207     micClient_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
208 
209     AudioStandard::AudioCapturerOptions capturerOptions = {
210         {
211             static_cast<AudioStandard::AudioSamplingRate>(audioParam_.comParam.sampleRate),
212             AudioStandard::AudioEncodingType::ENCODING_PCM,
213             static_cast<AudioStandard::AudioSampleFormat>(audioParam_.comParam.bitFormat),
214             static_cast<AudioStandard::AudioChannel>(audioParam_.comParam.channelMask),
215         },
216         {
217             static_cast<AudioStandard::SourceType>(audioParam_.captureOpts.sourceType),
218             0,
219         }
220     };
221     micClient_->audioCapturer_ = AudioStandard::AudioCapturer::Create(capturerOptions);
222     EXPECT_NE(nullptr, micClient_->audioCapturer_);
223     EXPECT_EQ(DH_SUCCESS, micClient_->Release());
224     micClient_->audioCapturer_ = nullptr;
225     micClient_->micTrans_ = std::make_shared<MockIAudioDataTransport>();
226     micClient_->clientStatus_ = AudioStatus::STATUS_STOP;
227     EXPECT_EQ(ERR_DH_AUDIO_FAILED, micClient_->Release());
228     micClient_->clientStatus_ = AudioStatus::STATUS_IDLE;
229     EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, micClient_->Release());
230 }
231 
232 /**
233  * @tc.name: SendMessage_001
234  * @tc.desc: Verify the SendMessage function.
235  * @tc.type: FUNC
236  * @tc.require: AR000H0E6G
237  */
238 HWTEST_F(DMicClientTest, SendMessage_001, TestSize.Level1)
239 {
240     if (micClient_ == nullptr) {
241         return;
242     }
243     std::string content = "content";
244     std::string dstDevId = "dstDevId";
245     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, micClient_->SendMessage(EVENT_UNKNOWN, content, dstDevId));
246     EXPECT_EQ(DH_SUCCESS, micClient_->SendMessage(NOTIFY_OPEN_MIC_RESULT, content, dstDevId));
247     micClient_->micTrans_ = nullptr;
248     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, micClient_->SendMessage(NOTIFY_OPEN_MIC_RESULT, content, dstDevId));
249 }
250 
251 /**
252  * @tc.name: AudioFwkClientSetUp_001
253  * @tc.desc: Verify the AudioFwkClientSetUp function.
254  * @tc.type: FUNC
255  * @tc.require: AR000H0E6G
256  */
257 HWTEST_F(DMicClientTest, AudioFwkClientSetUp_001, TestSize.Level1)
258 {
259     if (micClient_ == nullptr) {
260         return;
261     }
262     audioParam_.captureOpts.capturerFlags = MMAP_MODE;
263     int32_t actual = micClient_->AudioFwkClientSetUp();
264     EXPECT_EQ(ERR_DH_AUDIO_CLIENT_CAPTURER_CREATE_FAILED, actual);
265     audioParam_.captureOpts.capturerFlags = NORMAL_MODE;
266     actual = micClient_->AudioFwkClientSetUp();
267     EXPECT_NE(DH_SUCCESS, actual);
268 }
269 
270 /**
271  * @tc.name: TransSetUp_001
272  * @tc.desc: Verify the TransSetUp function.
273  * @tc.type: FUNC
274  * @tc.require: AR000H0E6G
275  */
276 HWTEST_F(DMicClientTest, TransSetUp_001, TestSize.Level1)
277 {
278     if (micClient_ == nullptr) {
279         return;
280     }
281     int32_t actual = micClient_->TransSetUp();
282     EXPECT_EQ(DH_SUCCESS, actual);
283     micClient_->micTrans_ = nullptr;
284     actual = micClient_->TransSetUp();
285     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, actual);
286 }
287 } // DistributedHardware
288 } // OHOS
289