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 <iostream>
17 #include "gtest/gtest.h"
18 #include "audio_errors.h"
19 #include "audio_offload_stream_unit_test.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace AudioStandard {
SetUpTestCase(void)25 void AudioOffloadStreamTest::SetUpTestCase(void) {}
TearDownTestCase(void)26 void AudioOffloadStreamTest::TearDownTestCase(void) {}
SetUp(void)27 void AudioOffloadStreamTest::SetUp(void)
28 {
29 audioOffloadStream_ = &AudioOffloadStream::GetInstance();
30 }
TearDown(void)31 void AudioOffloadStreamTest::TearDown(void)
32 {
33 if (audioOffloadStream_ != nullptr) {
34 audioOffloadStream_ = nullptr;
35 }
36 }
37
38 /**
39 * @tc.name : HandlePowerStateChanged_NoChange_Test
40 * @tc.number: AudioOffloadStreamTest_001
41 * @tc.desc : Test scenario where the power state does not change.
42 */
43 HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_NoChange_Test, TestSize.Level2)
44 {
45 audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE;
46 PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE;
47 audioOffloadStream_->HandlePowerStateChanged(state);
48 EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::FREEZE);
49 }
50
51 /**
52 * @tc.name : HandlePowerStateChanged_ActiveToInactive_Test
53 * @tc.number: AudioOffloadStreamTest_002
54 * @tc.desc : Test scenario where the power state changes from ACTIVE to INACTIVE.
55 */
56 HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_ActiveToInactive_Test, TestSize.Level2)
57 {
58 audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE;
59 PowerMgr::PowerState state = PowerMgr::PowerState::INACTIVE;
60 audioOffloadStream_->HandlePowerStateChanged(state);
61 EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::INACTIVE);
62 }
63
64 /**
65 * @tc.name : HandlePowerStateChanged_NoOffloadSupport_Test
66 * @tc.number: AudioOffloadStreamTest_003
67 * @tc.desc : Test scenario where the device does not support offload.
68 */
69 HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_NoOffloadSupport_Test, TestSize.Level3)
70 {
71 audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE;
72 PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE;
73 audioOffloadStream_->HandlePowerStateChanged(state);
74 EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::FREEZE);
75 }
76
77 /**
78 * @tc.name : HandlePowerStateChanged_OffloadSessionIDNotSet_Test
79 * @tc.number: audioOffloadStreamTest_004
80 * @tc.desc : Test scenario where the offload session ID is not set.
81 */
82 HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_OffloadSessionIDNotSet_Test, TestSize.Level3)
83 {
84 audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE;
85 PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE;
86 audioOffloadStream_->offloadSessionID_ = std::nullopt;
87 audioOffloadStream_->HandlePowerStateChanged(state);
88 EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::FREEZE);
89 }
90
91 /**
92 * @tc.name : HandlePowerStateChanged_OffloadSessionIDSet_Test
93 * @tc.number: audioOffloadStreamTest_005
94 * @tc.desc : Test scenario where the offload session ID is set.
95 */
96 HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_OffloadSessionIDSet_Test, TestSize.Level3)
97 {
98 audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE;
99 PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE;
100 audioOffloadStream_->offloadSessionID_ = 1;
101 audioOffloadStream_->HandlePowerStateChanged(state);
102 EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::FREEZE);
103 }
104
105 /**
106 * @tc.name : CheckStreamOffloadMode_001
107 * @tc.number: Audio_OffloadStream_006
108 * @tc.desc : Test CheckStreamOffloadMode when offload not available from xml.
109 */
110 HWTEST_F(AudioOffloadStreamTest, CheckStreamOffloadMode_001, TestSize.Level3)
111 {
112 // 模拟GetOffloadAvailableFromXml返回false
113 audioOffloadStream_->isOffloadAvailable_ = false;
114 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
115 int64_t activateSessionId = 1;
116
117 bool result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
118 EXPECT_FALSE(result);
119 }
120
121 /**
122 * @tc.name : CheckStreamOffloadMode_002
123 * @tc.number: Audio_OffloadStream_007
124 * @tc.desc : Test CheckStreamOffloadMode when offload not available on current output device.
125 */
126 HWTEST_F(AudioOffloadStreamTest, CheckStreamOffloadMode_002, TestSize.Level3)
127 {
128 // 模拟GetOffloadAvailableFromXml返回true
129 audioOffloadStream_->isOffloadAvailable_ = true;
130
131 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
132 int64_t activateSessionId = 1;
133 bool result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
134 EXPECT_FALSE(result);
135 }
136
137 /**
138 * @tc.name : CheckStreamOffloadMode_003
139 * @tc.number: Audio_OffloadStream_008
140 * @tc.desc : Test CheckStreamOffloadMode when offload not available on current output device.
141 */
142 HWTEST_F(AudioOffloadStreamTest, CheckStreamOffloadMode_003, TestSize.Level3)
143 {
144 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
145 int64_t activateSessionId = 6;
146 AudioStreamChangeInfo streamChangeInfo;
147 streamChangeInfo.audioRendererChangeInfo.clientUID = 1;
148 streamChangeInfo.audioRendererChangeInfo.sessionId = 1;
149 streamChangeInfo.audioRendererChangeInfo.channelCount = 3;
150 streamChangeInfo.audioRendererChangeInfo.createrUID = 2;
151 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_NEW;
152 streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType = PIPE_TYPE_DIRECT_MUSIC;
153 audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo);
154
155 audioOffloadStream_->isOffloadAvailable_ = true;
156 audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER;
157 bool result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
158 EXPECT_FALSE(result);
159
160 streamType = AudioStreamType::STREAM_MUSIC;
161 result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
162 EXPECT_FALSE(result);
163
164 streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType = PIPE_TYPE_DIRECT_MUSIC;
165 audioOffloadStream_->streamCollector_.audioRendererChangeInfos_.clear();
166 audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo);
167 result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
168 EXPECT_FALSE(result);
169
170 streamChangeInfo.audioRendererChangeInfo.channelCount = 2;
171 audioOffloadStream_->streamCollector_.audioRendererChangeInfos_.clear();
172 audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo);
173 result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
174 EXPECT_FALSE(result);
175
176 activateSessionId = 1;
177 result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
178 EXPECT_FALSE(result);
179
180 streamChangeInfo.audioRendererChangeInfo.sessionId = 1041;
181 audioOffloadStream_->streamCollector_.audioRendererChangeInfos_.clear();
182 audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo);
183 result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
184 EXPECT_FALSE(result);
185
186 activateSessionId = 1041;
187 streamChangeInfo.audioRendererChangeInfo.sessionId = 1041;
188 audioOffloadStream_->streamCollector_.audioRendererChangeInfos_.clear();
189 audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo);
190 result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
191 EXPECT_EQ(audioOffloadStream_->streamCollector_.GetUid(activateSessionId), 2);
192 EXPECT_FALSE(result);
193 }
194
195 /**
196 * @tc.name : MoveToNewPipe_ShouldReturnError_WhenStreamIsIllegal
197 * @tc.number: AudioOffloadStreamTest_008
198 * @tc.desc : Test if MoveToNewPipe .
199 */
200 HWTEST_F(AudioOffloadStreamTest, MoveToNewPipe_ShouldReturnError_WhenStreamIsIllegal, TestSize.Level3)
201 {
202 AudioStreamChangeInfo streamChangeInfo;
203 streamChangeInfo.audioRendererChangeInfo.clientUID = 1;
204 streamChangeInfo.audioRendererChangeInfo.sessionId = 1;
205 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_NEW;
206 int32_t ret = audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo);
207 EXPECT_EQ(ret, SUCCESS);
208 uint32_t sessionId = 1;
209 AudioPipeType pipeType = AudioPipeType::PIPE_TYPE_NORMAL_OUT;
210 // Arrange
211 int32_t defaultUid = -1;
212 // Act
213 int32_t result = audioOffloadStream_->MoveToNewPipe(sessionId, pipeType);
214 // Assert
215 EXPECT_NE(result, ERROR);
216 }
217
218
219 /**
220 * @tc.name : DynamicUnloadOffloadModule_ShouldReturnSuccess_WhenOffloadIsOpened
221 * @tc.number: AudioOffloadStreamTest_009
222 * @tc.desc : Test DynamicUnloadOffloadModule function when offload is opened.
223 */
224 HWTEST_F(AudioOffloadStreamTest, DynamicUnloadOffloadModule_ShouldReturnSuccess_WhenOffloadIsOpened, TestSize.Level3)
225 {
226 // Arrange
227 audioOffloadStream_->isOffloadOpened_.store(true);
228 // Act
229 int32_t result = audioOffloadStream_->DynamicUnloadOffloadModule();
230 // Assert
231 EXPECT_EQ(result, SUCCESS);
232 EXPECT_FALSE(audioOffloadStream_->isOffloadOpened_.load());
233 }
234
235 /**
236 * @tc.name : DynamicUnloadOffloadModule_ShouldReturnSuccess_WhenOffloadIsNotOpened
237 * @tc.number: AudioOffloadStreamTest_010
238 * @tc.desc : Test DynamicUnloadOffloadModule function when offload is not opened.
239 */
240 HWTEST_F(AudioOffloadStreamTest, DynamicUnloadOffloadModule_ShouldReturnSuccess_WhenOffloadIsNotOpened, TestSize.Level3)
241 {
242 // Arrange
243 audioOffloadStream_->isOffloadOpened_.store(false);
244 // Act
245 int32_t result = audioOffloadStream_->DynamicUnloadOffloadModule();
246 // Assert
247 EXPECT_EQ(result, SUCCESS);
248 }
249
250 /**
251 * @tc.name : ReleaseOffloadStream_WhenSessionIdDoesNotMatch
252 * @tc.number: AudioOffloadStreamTest_011
253 * @tc.desc : Test if the offload stream is not released when the session ID does not match.
254 */
255 HWTEST_F(AudioOffloadStreamTest, ReleaseOffloadStream_WhenSessionIdDoesNotMatch, TestSize.Level0)
256 {
257 // Arrange
258 uint32_t sessionId = 123;
259 uint32_t differentSessionId = 456;
260 audioOffloadStream_->offloadSessionID_ = sessionId;
261 // Act
262 audioOffloadStream_->RemoteOffloadStreamRelease(differentSessionId);
263 // Assert
264 EXPECT_TRUE(audioOffloadStream_->offloadSessionID_.has_value());
265 }
266
267 /**
268 * @tc.name : CheckStreamMode_ShouldActivate_WhenMultichannel
269 * @tc.number: AudioOffloadStreamTest_012
270 * @tc.desc : Test CheckStreamMode function when CheckStreamMultichannelMode returns true
271 */
272 HWTEST_F(AudioOffloadStreamTest, CheckStreamMode_ShouldActivate_WhenMultichannel, TestSize.Level0)
273 {
274 // Arrange
275 int64_t activateSessionId = 1;
276 // Act
277 audioOffloadStream_->CheckStreamMode(activateSessionId);
278 // Assert
279 EXPECT_EQ(DeviceType::DEVICE_TYPE_SPEAKER, audioOffloadStream_->audioActiveDevice_.GetCurrentOutputDeviceType());
280 }
281
282 /**
283 * @tc.name : AudioOffloadStreamTest_013
284 * @tc.number: AudioOffloadStreamTest_013
285 * @tc.desc : Test FilterSinkInputs function
286 */
287 HWTEST_F(AudioOffloadStreamTest, FilterSinkInputs_ShouldReturnEmpty_WhenSinkInputsIsEmpty, TestSize.Level0)
288 {
289 AudioOffloadStream audioOffloadStream;
290 std::vector<SinkInput> sinkInputs;
291 std::vector<SinkInput> result = audioOffloadStream.FilterSinkInputs(1, sinkInputs);
292 EXPECT_TRUE(result.empty());
293 SinkInput sinkInput;
294 sinkInput.uid = 123;
295 sinkInput.streamType = AudioStreamType::STREAM_DEFAULT;
296 sinkInputs.push_back(sinkInput);
297
298 result = audioOffloadStream.FilterSinkInputs(1, sinkInputs);
299 EXPECT_TRUE(result.empty());
300 sinkInput.streamId = 1;
301 sinkInputs.push_back(sinkInput);
302
303 result = audioOffloadStream.FilterSinkInputs(1, sinkInputs);
304 EXPECT_EQ(result.size(), 0);
305 }
306
307 /**
308 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
309 * @tc.number: AudioOffloadStreamTest_014
310 * @tc.desc : Test scenario when spatialization is enabled and effect offload is enabled.
311 */
312 HWTEST_F(AudioOffloadStreamTest, SpatializationEnabledAndEffectOffloadEnabled, TestSize.Level0)
313 {
314 AudioOffloadStream audioOffloadStream;
315 std::vector<int32_t> allSessions = {1, 2, 3};
316 audioOffloadStream.ResetOffloadModeOnSpatializationChanged(allSessions);
317
318 EXPECT_EQ(audioOffloadStream.currentPowerState_, PowerMgr::PowerState::AWAKE);
319 }
320
321 /**
322 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
323 * @tc.number: AudioOffloadStreamTest_015
324 * @tc.desc : Test ConstructMchAudioModuleInfo Interface.
325 */
326 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_015, TestSize.Level0)
327 {
328 DeviceType deviceType = DeviceType::DEVICE_TYPE_SPEAKER;
329 AudioOffloadStream audioOffloadStream;
330 AudioModuleInfo ret;
331
332 ret = audioOffloadStream.ConstructMchAudioModuleInfo(deviceType);
333 EXPECT_EQ(ret.channels, "6");
334 }
335
336 /**
337 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
338 * @tc.number: AudioOffloadStreamTest_016
339 * @tc.desc : Test LoadMchModule Interface.
340 */
341 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_016, TestSize.Level0)
342 {
343 AudioOffloadStream audioOffloadStream;
344 int32_t ret;
345
346 ret = audioOffloadStream.LoadMchModule();
347 EXPECT_EQ(ret, SUCCESS);
348 }
349
350 /**
351 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
352 * @tc.number: AudioOffloadStreamTest_017
353 * @tc.desc : Test ConstructOffloadAudioModuleInfo Interface.
354 */
355 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_017, TestSize.Level0)
356 {
357 DeviceType deviceType = DeviceType::DEVICE_TYPE_SPEAKER;
358 AudioOffloadStream audioOffloadStream;
359 AudioModuleInfo ret;
360
361 ret = audioOffloadStream.ConstructOffloadAudioModuleInfo(deviceType);
362 EXPECT_EQ(ret.channels, "2");
363 }
364
365 /**
366 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
367 * @tc.number: AudioOffloadStreamTest_018
368 * @tc.desc : Test UnloadMchModule Interface.
369 */
370 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_018, TestSize.Level0)
371 {
372 AudioOffloadStream audioOffloadStream;
373 int32_t ret;
374
375 ret = audioOffloadStream.UnloadMchModule();
376 EXPECT_NE(ret, SUCCESS);
377 }
378
379 /**
380 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
381 * @tc.number: AudioOffloadStreamTest_019
382 * @tc.desc : Test LoadOffloadModule Interface.
383 */
384 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_019, TestSize.Level0)
385 {
386 AudioIOHandle audioIOHandle = 3;
387 AudioOffloadStream audioOffloadStream;
388 int32_t ret;
389
390 ret = audioOffloadStream.LoadOffloadModule();
391 EXPECT_EQ(ret, SUCCESS);
392
393 audioOffloadStream.audioIOHandleMap_.IOHandles_[OFFLOAD_PRIMARY_SPEAKER] = audioIOHandle;
394 ret = audioOffloadStream.LoadOffloadModule();
395 EXPECT_EQ(ret, SUCCESS);
396 }
397
398 /**
399 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
400 * @tc.number: AudioOffloadStreamTest_020
401 * @tc.desc : Test UnloadOffloadModule Interface.
402 */
403 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_020, TestSize.Level0)
404 {
405 AudioOffloadStream audioOffloadStream;
406 int32_t ret;
407
408 audioOffloadStream.isOffloadOpened_.store(true);
409 ret = audioOffloadStream.UnloadOffloadModule();
410 EXPECT_NE(ret, SUCCESS);
411 }
412
413 /**
414 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
415 * @tc.number: AudioOffloadStreamTest_021
416 * @tc.desc : Test ActivateConcurrencyFromServer Interface.
417 */
418 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_021, TestSize.Level0)
419 {
420 AudioPipeType incomingPipe = PIPE_TYPE_UNKNOWN;
421 AudioOffloadStream audioOffloadStream;
422 int32_t ret;
423
424 ret = audioOffloadStream.ActivateConcurrencyFromServer(incomingPipe);
425 EXPECT_EQ(ret, SUCCESS);
426 }
427
428 /**
429 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
430 * @tc.number: AudioOffloadStreamTest_022
431 * @tc.desc : Test OffloadStreamSetCheck Interface.
432 */
433 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_022, TestSize.Level0)
434 {
435 uint32_t sessionId = 1;
436 AudioOffloadStream audioOffloadStream;
437 AudioStreamChangeInfo streamChangeInfo;
438 streamChangeInfo.audioRendererChangeInfo.clientUID = 1;
439 streamChangeInfo.audioRendererChangeInfo.sessionId = 1;
440 streamChangeInfo.audioRendererChangeInfo.channelCount = 3;
441 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_NEW;
442 streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType = PIPE_TYPE_DIRECT_MUSIC;
443
444 audioOffloadStream.streamCollector_.AddRendererStream(streamChangeInfo);
445 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = LOCAL_NETWORK_ID;
446 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.macAddress_ = "00:11:22:33:44:55";
447 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_INVALID;
448 audioOffloadStream.OffloadStreamSetCheck(sessionId);
449 EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceNetworkId(), LOCAL_NETWORK_ID);
450
451 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = LOCAL_NETWORK_ID;
452 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.macAddress_ = "00:11:22:33:44:55";
453 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_REMOTE_CAST;
454 audioOffloadStream.OffloadStreamSetCheck(sessionId);
455 EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceType(), DEVICE_TYPE_REMOTE_CAST);
456
457 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = LOCAL_NETWORK_ID;
458 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.macAddress_ = "00:11:22:33:44:55";
459 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER;
460 audioOffloadStream.OffloadStreamSetCheck(sessionId);
461 EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceType(), DEVICE_TYPE_SPEAKER);
462
463 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = REMOTE_NETWORK_ID;
464 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.macAddress_ = "00:11:22:33:44:55";
465 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_NONE;
466 audioOffloadStream.OffloadStreamSetCheck(sessionId);
467 EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceNetworkId(), REMOTE_NETWORK_ID);
468
469 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = "";
470 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.macAddress_ = "00:11:22:33:44:55";
471 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_NONE;
472 audioOffloadStream.OffloadStreamSetCheck(sessionId);
473 EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceMacAddr(), "00:11:22:33:44:55");
474
475 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = "";
476 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.macAddress_ = "";
477 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_NONE;
478 audioOffloadStream.OffloadStreamSetCheck(sessionId);
479 EXPECT_EQ(audioOffloadStream.streamCollector_.GetStreamType(sessionId), STREAM_MUSIC);
480 }
481 } // namespace AudioStandard
482 } // namespace OHOS
483