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 "dspeaker_client_test.h"
17 
18 #include <thread>
19 #include <chrono>
20 
21 #include "av_trans_types.h"
22 
23 using namespace testing::ext;
24 
25 namespace OHOS {
26 namespace DistributedHardware {
SetUpTestCase(void)27 void DSpeakerClientTest::SetUpTestCase(void) {}
28 
TearDownTestCase(void)29 void DSpeakerClientTest::TearDownTestCase(void) {}
30 
SetUp()31 void DSpeakerClientTest::SetUp()
32 {
33     std::string devId = "hello";
34     const int32_t dhId = 1;
35     clientCallback_ = std::make_shared<MockIAudioEventCallback>();
36     speakerClient_ = std::make_shared<DSpeakerClient>(devId, dhId, clientCallback_);
37     speakerClient_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
38 
39     audioParam_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC;
40     audioParam_.comParam.sampleRate = AudioSampleRate::SAMPLE_RATE_48000;
41     audioParam_.comParam.bitFormat = AudioSampleFormat::SAMPLE_S16LE;
42     audioParam_.comParam.channelMask = AudioChannel::STEREO;
43     audioParam_.renderOpts.contentType = ContentType::CONTENT_TYPE_MUSIC;
44     audioParam_.renderOpts.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
45 }
46 
TearDown()47 void DSpeakerClientTest::TearDown()
48 {
49     speakerClient_ = nullptr;
50     clientCallback_ = nullptr;
51 }
52 
53 /**
54  * @tc.name: InitReceiverEngine_001
55  * @tc.desc: Verify the InitReceiverEngine function.
56  * @tc.type: FUNC
57  * @tc.require: AR000H0E6G
58  */
59 HWTEST_F(DSpeakerClientTest, InitReceiverEngine_001, TestSize.Level1)
60 {
61     if (speakerClient_ == nullptr) {
62         return;
63     }
64     IAVEngineProvider *providerPtr = nullptr;
65 
66     AVTransEvent event1 = { EventType::EVENT_START_SUCCESS, "", ""};
67     speakerClient_->OnEngineTransEvent(event1);
68     AVTransEvent event2 = { EventType::EVENT_STOP_SUCCESS, "", ""};
69     speakerClient_->OnEngineTransEvent(event2);
70     auto message = std::make_shared<AVTransMessage>();
71     speakerClient_->OnEngineTransMessage(message);
72     auto data = std::make_shared<AudioData>(4096);
73     speakerClient_->OnEngineTransDataAvailable(data);
74     EXPECT_EQ(DH_SUCCESS, speakerClient_->InitReceiverEngine(providerPtr));
75 }
76 
77 /**
78  * @tc.name: OnStateChange_001
79  * @tc.desc: Verify the OnStateChange function.
80  * @tc.type: FUNC
81  * @tc.require: AR000H0E6G
82  */
83 HWTEST_F(DSpeakerClientTest, OnStateChange_001, TestSize.Level1)
84 {
85     if (speakerClient_ == nullptr) {
86         return;
87     }
88     AudioStandard::VolumeEvent event;
89     event.volume = 1;
90     event.updateUi = 1;
91     event.volumeGroupId = 1;
92 
93     speakerClient_->OnVolumeKeyEvent(event);
94     EXPECT_EQ(DH_SUCCESS, speakerClient_->OnStateChange(AudioEventType::DATA_OPENED));
95     EXPECT_EQ(DH_SUCCESS, speakerClient_->OnStateChange(AudioEventType::DATA_CLOSED));
96     EXPECT_NE(DH_SUCCESS, speakerClient_->OnStateChange(AudioEventType::SPEAKER_OPENED));
97     EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, speakerClient_->OnStateChange(AudioEventType::EVENT_UNKNOWN));
98 }
99 
100 /**
101  * @tc.name: SetUp_001
102  * @tc.desc: Verify the SetUp function.
103  * @tc.type: FUNC
104  * @tc.require: AR000H0E6G
105  */
106 HWTEST_F(DSpeakerClientTest, SetUp_001, TestSize.Level1)
107 {
108     if (speakerClient_ == nullptr) {
109         return;
110     }
111     AudioParam audioParam;
112     EXPECT_EQ(DH_SUCCESS, speakerClient_->SetUp(audioParam));
113     EXPECT_EQ(DH_SUCCESS, speakerClient_->SetUp(audioParam_));
114     speakerClient_->speakerTrans_ = nullptr;
115     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->SetUp(audioParam));
116     EXPECT_EQ(DH_SUCCESS, speakerClient_->Release());
117     speakerClient_->clientStatus_ = AudioStatus::STATUS_READY;
118     EXPECT_EQ(DH_SUCCESS, speakerClient_->Release());
119 }
120 
121 /**
122  * @tc.name: StartRender_001
123  * @tc.desc: Verify the StartRender and StopRender function.
124  * @tc.type: FUNC
125  * @tc.require: AR000H0E6G
126  */
127 HWTEST_F(DSpeakerClientTest, StartRender001, TestSize.Level1)
128 {
129     if (speakerClient_ == nullptr) {
130         return;
131     }
132     EXPECT_NE(DH_SUCCESS, speakerClient_->StartRender());
133     EXPECT_NE(DH_SUCCESS, speakerClient_->StopRender());
134 
135     speakerClient_->clientStatus_ = STATUS_START;
136     EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, speakerClient_->StartRender());
137     size_t length = 1;
138     speakerClient_->OnWriteData(length);
139     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->StopRender());
140     speakerClient_->isRenderReady_.store(true);
141     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->StopRender());
142     speakerClient_->CreateAudioRenderer(audioParam_);
143     EXPECT_EQ(ERR_DH_AUDIO_CLIENT_RENDER_STOP_FAILED, speakerClient_->StopRender());
144 }
145 
146 /**
147  * @tc.name: StopRender_001
148  * @tc.desc: Verify the StopRender function.
149  * @tc.type: FUNC
150  * @tc.require: AR000H0E6G
151  */
152 HWTEST_F(DSpeakerClientTest, StopRender001, TestSize.Level1)
153 {
154     if (speakerClient_ == nullptr) {
155         return;
156     }
157     EXPECT_NE(DH_SUCCESS, speakerClient_->StopRender());
158     std::string args = "args";
159     AudioEvent event;
160     speakerClient_->isRenderReady_ = true;
161     speakerClient_->FlushJitterQueue();
162     speakerClient_->PlayStatusChange(args);
163     speakerClient_->SetAudioParameters(event);
164     speakerClient_->SetMute(event);
165     for (size_t i = 0; i < 10; i++) {
166         std::shared_ptr<AudioData> data = std::make_shared<AudioData>(4096);
167         speakerClient_->dataQueue_.push(data);
168     }
169     args = "restart";
170     speakerClient_->PlayStatusChange(args);
171 
172     if (speakerClient_->renderDataThread_.joinable()) {
173         speakerClient_->isRenderReady_.store(false);
174         speakerClient_->renderDataThread_.join();
175     }
176     event.content = "AUDIO_VOLUME_TYPE=2;";
177     auto ret = speakerClient_->SetAudioParameters(event);
178     EXPECT_NE(DH_SUCCESS, ret);
179 }
180 
181 /**
182  * @tc.name: OnDecodeTransDataDone_001
183  * @tc.desc: Verify the OnDecodeTransDataDone function.
184  * @tc.type: FUNC
185  * @tc.require: AR000H0E6G
186  */
187 HWTEST_F(DSpeakerClientTest, OnDecodeTransDataDone001, TestSize.Level1)
188 {
189     if (speakerClient_ == nullptr) {
190         return;
191     }
192     std::shared_ptr<AudioData> audioData = nullptr;
193     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->OnDecodeTransDataDone(audioData));
194     for (size_t i = 0; i < 11; i++) {
195         std::shared_ptr<AudioData> data = std::make_shared<AudioData>(4096);
196         speakerClient_->dataQueue_.push(data);
197     }
198     audioData = std::make_shared<AudioData>(4096);
199     EXPECT_EQ(DH_SUCCESS, speakerClient_->OnDecodeTransDataDone(audioData));
200 }
201 
202 /**
203  * @tc.name: Release_001
204  * @tc.desc: Verify the Release function.
205  * @tc.type: FUNC
206  * @tc.require: AR000H0E6G
207  */
208 HWTEST_F(DSpeakerClientTest, Release001, TestSize.Level1)
209 {
210     if (speakerClient_ == nullptr) {
211         return;
212     }
213     speakerClient_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
214     std::string args = "{\"ChangeType\":\"restart\"}";
215     speakerClient_->PlayStatusChange(args);
216     args = "{\"ChangeType\":\"pause\"}";
217     speakerClient_->PlayStatusChange(args);
218     speakerClient_->Pause();
219     EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, speakerClient_->Release());
220 }
221 
222 /**
223  * @tc.name: GetVolumeLevel_001
224  * @tc.desc: Verify the GetVolumeLevel function.
225  * @tc.type: FUNC
226  * @tc.require: AR000H0E6G
227  */
228 HWTEST_F(DSpeakerClientTest, GetVolumeLevel_001, TestSize.Level1)
229 {
230     if (speakerClient_ == nullptr) {
231         return;
232     }
233     AudioStandard::InterruptEvent eventType = {static_cast<AudioStandard::InterruptType>(1),
234         static_cast<AudioStandard::InterruptForceType>(0), static_cast<AudioStandard::InterruptHint>(0)};
235     speakerClient_->OnInterrupt(eventType);
236 
237     std::string volEvent = speakerClient_->GetVolumeLevel();
238     EXPECT_NE("", volEvent);
239 }
240 
241 /**
242  * @tc.name: SendMessage_001
243  * @tc.desc: Verify the SendMessage function.
244  * @tc.type: FUNC
245  * @tc.require: AR000H0E6G
246  */
247 HWTEST_F(DSpeakerClientTest, SendMessage_001, TestSize.Level1)
248 {
249     if (speakerClient_ == nullptr) {
250         return;
251     }
252     std::string content = "content";
253     std::string dstDevId = "dstDevId";
254     audioParam_.renderOpts.renderFlags = MMAP_MODE;
255     speakerClient_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
256     speakerClient_->Pause();
257     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->SendMessage(EVENT_UNKNOWN, content, dstDevId));
258     EXPECT_EQ(DH_SUCCESS, speakerClient_->SendMessage(NOTIFY_OPEN_SPEAKER_RESULT, content, dstDevId));
259     speakerClient_->speakerTrans_ = nullptr;
260     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->SendMessage(NOTIFY_OPEN_SPEAKER_RESULT, content, dstDevId));
261 }
262 } // DistributedHardware
263 } // OHOS
264