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 "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 ASSERT_TRUE(speakerClient_ != nullptr);
62 IAVEngineProvider *providerPtr = nullptr;
63
64 AVTransEvent event1 = { EventType::EVENT_START_SUCCESS, "", ""};
65 speakerClient_->OnEngineTransEvent(event1);
66 speakerClient_->OnCtrlTransEvent(event1);
67 AVTransEvent event2 = { EventType::EVENT_STOP_SUCCESS, "", ""};
68 speakerClient_->OnEngineTransEvent(event2);
69 speakerClient_->OnCtrlTransEvent(event2);
70 AVTransEvent event3 = { EventType::EVENT_CHANNEL_CLOSED, "", ""};
71 speakerClient_->OnEngineTransEvent(event3);
72 speakerClient_->OnCtrlTransEvent(event3);
73 AVTransEvent event4 = { EventType::EVENT_START_FAIL, "", ""};
74 speakerClient_->OnEngineTransEvent(event4);
75 speakerClient_->OnCtrlTransEvent(event4);
76 auto message = std::make_shared<AVTransMessage>();
77 speakerClient_->OnEngineTransMessage(message);
78 speakerClient_->OnCtrlTransMessage(message);
79 auto data = std::make_shared<AudioData>(4096);
80 speakerClient_->OnEngineTransDataAvailable(data);
81 EXPECT_EQ(DH_SUCCESS, speakerClient_->InitReceiverEngine(providerPtr));
82 }
83
84 /**
85 * @tc.name: OnStateChange_001
86 * @tc.desc: Verify the OnStateChange function.
87 * @tc.type: FUNC
88 * @tc.require: AR000H0E6G
89 */
90 HWTEST_F(DSpeakerClientTest, OnStateChange_001, TestSize.Level1)
91 {
92 ASSERT_TRUE(speakerClient_ != nullptr);
93 AudioStandard::VolumeEvent event;
94 event.volume = 1;
95 event.updateUi = 1;
96 event.volumeGroupId = 1;
97
98 speakerClient_->OnVolumeKeyEvent(event);
99 EXPECT_EQ(DH_SUCCESS, speakerClient_->OnStateChange(AudioEventType::DATA_OPENED));
100 EXPECT_EQ(DH_SUCCESS, speakerClient_->OnStateChange(AudioEventType::DATA_CLOSED));
101 EXPECT_NE(DH_SUCCESS, speakerClient_->OnStateChange(AudioEventType::SPEAKER_OPENED));
102 EXPECT_EQ(ERR_DH_AUDIO_NOT_SUPPORT, speakerClient_->OnStateChange(AudioEventType::EVENT_UNKNOWN));
103 }
104
105 /**
106 * @tc.name: SetUp_001
107 * @tc.desc: Verify the SetUp function.
108 * @tc.type: FUNC
109 * @tc.require: AR000H0E6G
110 */
111 HWTEST_F(DSpeakerClientTest, SetUp_001, TestSize.Level1)
112 {
113 ASSERT_TRUE(speakerClient_ != nullptr);
114 AudioParam audioParam;
115 EXPECT_EQ(DH_SUCCESS, speakerClient_->SetUp(audioParam));
116 EXPECT_EQ(DH_SUCCESS, speakerClient_->SetUp(audioParam_));
117 speakerClient_->speakerTrans_ = nullptr;
118 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->SetUp(audioParam));
119 EXPECT_EQ(DH_SUCCESS, speakerClient_->Release());
120 speakerClient_->clientStatus_ = AudioStatus::STATUS_READY;
121 EXPECT_EQ(DH_SUCCESS, speakerClient_->Release());
122 }
123
124 /**
125 * @tc.name: StartRender_001
126 * @tc.desc: Verify the StartRender and StopRender function.
127 * @tc.type: FUNC
128 * @tc.require: AR000H0E6G
129 */
130 HWTEST_F(DSpeakerClientTest, StartRender001, TestSize.Level1)
131 {
132 ASSERT_TRUE(speakerClient_ != nullptr);
133 EXPECT_NE(DH_SUCCESS, speakerClient_->StartRender());
134 EXPECT_NE(DH_SUCCESS, speakerClient_->StopRender());
135
136 speakerClient_->clientStatus_ = STATUS_START;
137 EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, speakerClient_->StartRender());
138 size_t length = 1;
139 speakerClient_->OnWriteData(length);
140 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->StopRender());
141 speakerClient_->isRenderReady_.store(true);
142 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->StopRender());
143 speakerClient_->CreateAudioRenderer(audioParam_);
144 EXPECT_EQ(ERR_DH_AUDIO_CLIENT_RENDER_STOP_FAILED, speakerClient_->StopRender());
145 }
146
147 /**
148 * @tc.name: StopRender_001
149 * @tc.desc: Verify the StopRender function.
150 * @tc.type: FUNC
151 * @tc.require: AR000H0E6G
152 */
153 HWTEST_F(DSpeakerClientTest, StopRender001, TestSize.Level1)
154 {
155 ASSERT_TRUE(speakerClient_ != nullptr);
156 EXPECT_NE(DH_SUCCESS, speakerClient_->StopRender());
157 std::string args = "args";
158 AudioEvent event;
159 speakerClient_->isRenderReady_ = true;
160 speakerClient_->FlushJitterQueue();
161 speakerClient_->PlayStatusChange(args);
162 speakerClient_->SetAudioParameters(event);
163 speakerClient_->SetMute(event);
164 for (size_t i = 0; i < 10; i++) {
165 std::shared_ptr<AudioData> data = std::make_shared<AudioData>(4096);
166 speakerClient_->dataQueue_.push(data);
167 }
168 args = "restart";
169 speakerClient_->PlayStatusChange(args);
170
171 if (speakerClient_->renderDataThread_.joinable()) {
172 speakerClient_->isRenderReady_.store(false);
173 speakerClient_->renderDataThread_.join();
174 }
175 event.content = "AUDIO_VOLUME_TYPE=2;";
176 auto ret = speakerClient_->SetAudioParameters(event);
177 EXPECT_NE(DH_SUCCESS, ret);
178 }
179
180 /**
181 * @tc.name: OnDecodeTransDataDone_001
182 * @tc.desc: Verify the OnDecodeTransDataDone function.
183 * @tc.type: FUNC
184 * @tc.require: AR000H0E6G
185 */
186 HWTEST_F(DSpeakerClientTest, OnDecodeTransDataDone001, TestSize.Level1)
187 {
188 ASSERT_TRUE(speakerClient_ != nullptr);
189 std::shared_ptr<AudioData> audioData = nullptr;
190 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->OnDecodeTransDataDone(audioData));
191 for (size_t i = 0; i < 11; i++) {
192 std::shared_ptr<AudioData> data = std::make_shared<AudioData>(4096);
193 speakerClient_->dataQueue_.push(data);
194 }
195 audioData = std::make_shared<AudioData>(4096);
196 EXPECT_EQ(DH_SUCCESS, speakerClient_->OnDecodeTransDataDone(audioData));
197 }
198
199 /**
200 * @tc.name: Release_001
201 * @tc.desc: Verify the Release function.
202 * @tc.type: FUNC
203 * @tc.require: AR000H0E6G
204 */
205 HWTEST_F(DSpeakerClientTest, Release001, TestSize.Level1)
206 {
207 ASSERT_TRUE(speakerClient_ != nullptr);
208 speakerClient_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
209 std::string args = "{\"ChangeType\":\"restart\"}";
210 speakerClient_->PlayStatusChange(args);
211 args = "{\"ChangeType\":\"pause\"}";
212 speakerClient_->PlayStatusChange(args);
213 speakerClient_->Pause();
214 EXPECT_EQ(ERR_DH_AUDIO_SA_STATUS_ERR, speakerClient_->Release());
215 }
216
217 /**
218 * @tc.name: GetVolumeLevel_001
219 * @tc.desc: Verify the GetVolumeLevel function.
220 * @tc.type: FUNC
221 * @tc.require: AR000H0E6G
222 */
223 HWTEST_F(DSpeakerClientTest, GetVolumeLevel_001, TestSize.Level1)
224 {
225 ASSERT_TRUE(speakerClient_ != nullptr);
226 AudioStandard::InterruptEvent eventType = {static_cast<AudioStandard::InterruptType>(1),
227 static_cast<AudioStandard::InterruptForceType>(0), static_cast<AudioStandard::InterruptHint>(0)};
228 speakerClient_->OnInterrupt(eventType);
229
230 std::string volEvent = speakerClient_->GetVolumeLevel();
231 EXPECT_NE("", volEvent);
232 }
233
234 /**
235 * @tc.name: SendMessage_001
236 * @tc.desc: Verify the SendMessage function.
237 * @tc.type: FUNC
238 * @tc.require: AR000H0E6G
239 */
240 HWTEST_F(DSpeakerClientTest, SendMessage_001, TestSize.Level1)
241 {
242 ASSERT_TRUE(speakerClient_ != nullptr);
243 std::string content = "content";
244 std::string dstDevId = "dstDevId";
245 audioParam_.renderOpts.renderFlags = MMAP_MODE;
246 speakerClient_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
247 speakerClient_->Pause();
248 speakerClient_->InitCtrlTrans();
249 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->SendMessage(EVENT_UNKNOWN, content, dstDevId));
250 EXPECT_EQ(DH_SUCCESS, speakerClient_->SendMessage(NOTIFY_OPEN_SPEAKER_RESULT, content, dstDevId));
251 speakerClient_->speakerCtrlTrans_ = nullptr;
252 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->SendMessage(NOTIFY_OPEN_SPEAKER_RESULT, content, dstDevId));
253 }
254 } // DistributedHardware
255 } // OHOS
256