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 "audio_interrupt_unit_test.h"
17 #include "audio_service_log.h"
18
19 #include "audio_interrupt_service.h"
20 #include "audio_policy_server.h"
21 #include <thread>
22 #include <memory>
23 #include <vector>
24 #include "binder_invoker.h"
25 #include "invoker_factory.h"
26 #include "ipc_thread_skeleton.h"
27
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace AudioStandard {
32
33 static AudioSessionStrategy strategyTest;
34
35 static std::shared_ptr<AudioInterruptService> audioInterruptService;
36 static sptr<AudioPolicyServer> serverTest = nullptr;
37 const int32_t CALLER_PID_TEST = 0;
38 const int32_t PIT_TEST = 0;
39 const int32_t SESSION_ID_TEST = 0;
40
41 const int32_t CALLER_PID = 0;
42 const int32_t DEFAULT_ZONE_ID = 0;
43 const int32_t VALUE_ERROR = -62980098;
44 const int32_t VALUE_SUCCESS = 1065353216;
45 const int32_t SYSTEM_ABILITY_ID = 3009;
46 const int32_t CALLER_UID = 1041;
47 const int32_t INTERRUPT_HINT_ERROR = -1;
48 const bool RUN_ON_CREATE = false;
49 const bool IS_SESSION_TIMEOUT = false;
50
SetUid1041()51 void SetUid1041()
52 {
53 IRemoteInvoker *remoteInvoker =
54 IPCThreadSkeleton::GetRemoteInvoker(IRemoteObject::IF_PROT_BINDER);
55 EXPECT_NE(nullptr, remoteInvoker);
56 BinderInvoker *ipcInvoker = (BinderInvoker *)remoteInvoker;
57 ipcInvoker->status_ = IRemoteInvoker::ACTIVE_INVOKER;
58 auto state = remoteInvoker->GetStatus();
59 EXPECT_EQ(state, IRemoteInvoker::ACTIVE_INVOKER);
60 ipcInvoker->callerUid_ = CALLER_UID;
61 }
62
SetUpTestCase(void)63 void AudioInterruptUnitTest::SetUpTestCase(void) {}
64
TearDownTestCase(void)65 void AudioInterruptUnitTest::TearDownTestCase(void)
66 {
67 audioInterruptService.reset();
68 serverTest = nullptr;
69 }
SetUp(void)70 void AudioInterruptUnitTest::SetUp(void) {}
TearDown(void)71 void AudioInterruptUnitTest::TearDown(void) {}
72
GetTnterruptServiceTest()73 std::shared_ptr<AudioInterruptService> GetTnterruptServiceTest()
74 {
75 return std::make_shared<AudioInterruptService>();
76 }
77
GetServerHandlerTest()78 std::shared_ptr<AudioPolicyServerHandler> GetServerHandlerTest()
79 {
80 return DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
81 }
82
83 bool g_hasServerInit = false;
GetPolicyServerTest()84 sptr<AudioPolicyServer> GetPolicyServerTest()
85 {
86 static int32_t systemAbilityId = 3009;
87 static bool runOnCreate = false;
88 static sptr<AudioPolicyServer> server =
89 sptr<AudioPolicyServer>::MakeSptr(systemAbilityId, runOnCreate);
90 if (!g_hasServerInit) {
91 server->OnStart();
92 server->OnAddSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID, "");
93 #ifdef FEATURE_MULTIMODALINPUT_INPUT
94 server->OnAddSystemAbility(MULTIMODAL_INPUT_SERVICE_ID, "");
95 #endif
96 server->OnAddSystemAbility(BLUETOOTH_HOST_SYS_ABILITY_ID, "");
97 server->OnAddSystemAbility(POWER_MANAGER_SERVICE_ID, "");
98 server->OnAddSystemAbility(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, "");
99 server->audioPolicyService_.SetDefaultDeviceLoadFlag(true);
100 g_hasServerInit = true;
101 }
102 return server;
103 }
104
105 #define PRINT_LINE printf("debug __LINE__:%d\n", __LINE__)
106
107 /**
108 * @tc.name : Test AudioInterruptService.
109 * @tc.number: AudioInterruptService_004
110 * @tc.desc : Test AddDumpInfo.
111 */
112 HWTEST(AudioInterruptUnitTest, AudioInterruptService_004, TestSize.Level1)
113 {
114 std::string dumpString;
115 auto interruptServiceTest = GetTnterruptServiceTest();
116 interruptServiceTest->zonesMap_.clear();
117 EXPECT_EQ(interruptServiceTest->zonesMap_.empty(), true);
118 interruptServiceTest->AudioInterruptZoneDump(dumpString);
119 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
120 interruptServiceTest->zonesMap_[0]->interruptCbsMap[0] = nullptr;
121 interruptServiceTest->AudioInterruptZoneDump(dumpString);
122 EXPECT_NE(dumpString.find("1 AudioInterruptZoneDump (s) available"), std::string::npos);
123 EXPECT_NE(dumpString.find("Interrupt callback size: 1"), std::string::npos);
124 }
125
126 /**
127 * @tc.name : Test AudioInterruptService.
128 * @tc.number: AudioInterruptService_005
129 * @tc.desc : Test AbandonAudioFocus.
130 */
131 HWTEST(AudioInterruptUnitTest, AudioInterruptService_005, TestSize.Level1)
132 {
133 auto interruptServiceTest = GetTnterruptServiceTest();
134 AudioInterrupt incomingInterrupt;
135 int32_t clientID = interruptServiceTest->clientOnFocus_;
136 auto retStatus = interruptServiceTest->AbandonAudioFocus(clientID, incomingInterrupt);
137 EXPECT_EQ(retStatus, SUCCESS);
138 }
139
140 class RemoteObjectTestStub : public IRemoteObject {
141 public:
RemoteObjectTestStub()142 RemoteObjectTestStub() : IRemoteObject(u"IRemoteObject") {}
GetObjectRefCount()143 int32_t GetObjectRefCount() { return 0; };
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)144 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
AddDeathRecipient(const sptr<DeathRecipient> & recipient)145 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)146 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
Dump(int fd,const std::vector<std::u16string> & args)147 int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
148
149 DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectTestStub");
150 };
151
152 /**
153 * @tc.name : Test AudioInterruptService.
154 * @tc.number: AudioInterruptService_006
155 * @tc.desc : Test SetAudioInterruptCallback and UnsetAudioInterruptCallback.
156 */
157 HWTEST(AudioInterruptUnitTest, AudioInterruptService_006, TestSize.Level1)
158 {
159 auto interruptServiceTest = GetTnterruptServiceTest();
160 auto retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, nullptr, 0);
161 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
162
163 retStatus = interruptServiceTest->UnsetAudioInterruptCallback(0, 0);
164 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
165
166 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
167 retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, sptr<RemoteObjectTestStub>::MakeSptr(), 0);
168 EXPECT_EQ(retStatus, SUCCESS);
169
170 retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, sptr<RemoteObjectTestStub>::MakeSptr(), 0);
171 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
172
173 retStatus = interruptServiceTest->UnsetAudioInterruptCallback(0, 0);
174 EXPECT_EQ(retStatus, SUCCESS);
175
176 retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, sptr<RemoteObjectTestStub>::MakeSptr(), 0);
177 EXPECT_EQ(retStatus, SUCCESS);
178 interruptServiceTest->zonesMap_[0]->interruptCbsMap.clear();
179 retStatus = interruptServiceTest->UnsetAudioInterruptCallback(0, 0);
180 EXPECT_EQ(retStatus, SUCCESS);
181
182 retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, sptr<RemoteObjectTestStub>::MakeSptr(), 0);
183 EXPECT_EQ(retStatus, SUCCESS);
184 interruptServiceTest->zonesMap_[0] = nullptr;
185 retStatus = interruptServiceTest->UnsetAudioInterruptCallback(0, 0);
186 EXPECT_EQ(retStatus, SUCCESS);
187
188 retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, sptr<RemoteObjectTestStub>::MakeSptr(), 0);
189 EXPECT_EQ(retStatus, SUCCESS);
190 interruptServiceTest->zonesMap_.clear();
191 retStatus = interruptServiceTest->UnsetAudioInterruptCallback(0, 0);
192 EXPECT_EQ(retStatus, SUCCESS);
193 }
194
195 /**
196 * @tc.name : Test AudioInterruptService.
197 * @tc.number: AudioInterruptService_008
198 * @tc.desc : Test ResumeAudioFocusList and SimulateFocusEntry.
199 */
200 HWTEST(AudioInterruptUnitTest, AudioInterruptService_008, TestSize.Level1)
201 {
202 auto interruptServiceTest = GetTnterruptServiceTest();
203 interruptServiceTest->Init(GetPolicyServerTest());
204 interruptServiceTest->zonesMap_.clear();
205 EXPECT_EQ(interruptServiceTest->zonesMap_.size(), 0);
206 auto newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
207 EXPECT_EQ(newAudioFocuInfoList.size(), 0);
208
209 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
210 AudioInterrupt audioInterrupt1;
211 audioInterrupt1.audioFocusType.streamType = STREAM_DEFAULT;
212 audioInterrupt1.audioFocusType.sourceType = SOURCE_TYPE_MIC;
213 audioInterrupt1.audioFocusType.isPlay = false;
214 AudioInterrupt audioInterrupt2;
215 audioInterrupt2.audioFocusType.streamType = STREAM_DEFAULT;
216 audioInterrupt2.audioFocusType.sourceType = SOURCE_TYPE_MIC;
217 audioInterrupt2.audioFocusType.isPlay = false;
218
219 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt1, AudioFocuState{PAUSE});
220 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt2, AudioFocuState{});
221 interruptServiceTest->zonesMap_[0] = audioInterruptZone;
222 newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
223 interruptServiceTest->ResumeAudioFocusList(0, true);
224 interruptServiceTest->ResumeAudioFocusList(0, false);
225 EXPECT_EQ(newAudioFocuInfoList.size(), 2);
226 }
227
228 /**
229 * @tc.name : Test AudioInterruptService.
230 * @tc.number: AudioInterruptService_010
231 * @tc.desc : Test ResumeAudioFocusList and SimulateFocusEntry.
232 */
233 HWTEST(AudioInterruptUnitTest, AudioInterruptService_010, TestSize.Level1)
234 {
235 auto interruptServiceTest = GetTnterruptServiceTest();
236 interruptServiceTest->Init(GetPolicyServerTest());
237 interruptServiceTest->zonesMap_.clear();
238 EXPECT_EQ(interruptServiceTest->zonesMap_.size(), 0);
239 auto newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
240 EXPECT_EQ(newAudioFocuInfoList.size(), 0);
241
242 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
243 AudioInterrupt audioInterrupt1;
244 audioInterrupt1.audioFocusType.streamType = STREAM_DEFAULT;
245 audioInterrupt1.audioFocusType.sourceType = SOURCE_TYPE_MIC;
246 audioInterrupt1.audioFocusType.isPlay = false;
247 AudioInterrupt audioInterrupt2;
248 audioInterrupt2.audioFocusType.streamType = STREAM_DEFAULT;
249 audioInterrupt2.audioFocusType.sourceType = SOURCE_TYPE_MIC;
250 audioInterrupt2.audioFocusType.isPlay = false;
251
252 audioInterruptZone->audioFocusInfoList.clear();
253 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt1, AudioFocuState{PAUSE});
254 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt2, AudioFocuState{DUCK});
255 interruptServiceTest->zonesMap_[0] = audioInterruptZone;
256 newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
257 interruptServiceTest->ResumeAudioFocusList(0, true);
258 interruptServiceTest->ResumeAudioFocusList(0, false);
259 EXPECT_EQ(newAudioFocuInfoList.size(), 2);
260
261 audioInterruptZone->audioFocusInfoList.clear();
262 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt1, AudioFocuState{PAUSE});
263 audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt2, AudioFocuState{STOP});
264 interruptServiceTest->zonesMap_[0] = audioInterruptZone;
265 newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
266 interruptServiceTest->ResumeAudioFocusList(0, true);
267 interruptServiceTest->ResumeAudioFocusList(0, false);
268 EXPECT_EQ(newAudioFocuInfoList.size(), 2);
269 }
270
271 /**
272 * @tc.name : Test AudioInterruptService.
273 * @tc.number: AudioInterruptService_012
274 * @tc.desc : Test ResumeAudioFocusList and SimulateFocusEntry.
275 */
276 HWTEST(AudioInterruptUnitTest, AudioInterruptService_012, TestSize.Level1)
277 {
278 auto interruptServiceTest = GetTnterruptServiceTest();
279 interruptServiceTest->Init(GetPolicyServerTest());
280 interruptServiceTest->zonesMap_.clear();
281 EXPECT_EQ(interruptServiceTest->zonesMap_.size(), 0);
282 auto newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
283 EXPECT_EQ(newAudioFocuInfoList.size(), 0);
284 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
285 audioInterruptZone->audioFocusInfoList.emplace_back(AudioInterrupt(), AudioFocuState{PAUSE});
286 audioInterruptZone->audioFocusInfoList.emplace_back(AudioInterrupt(), AudioFocuState{});
287 interruptServiceTest->zonesMap_[0] = audioInterruptZone;
288 newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
289 interruptServiceTest->ResumeAudioFocusList(0, true);
290 interruptServiceTest->ResumeAudioFocusList(0, false);
291 EXPECT_EQ(newAudioFocuInfoList.size(), 2);
292 }
293
294 /**
295 * @tc.name : Test AudioInterruptService.
296 * @tc.number: AudioInterruptService_013
297 * @tc.desc : Test ResumeAudioFocusList and SimulateFocusEntry.
298 */
299 HWTEST(AudioInterruptUnitTest, AudioInterruptService_013, TestSize.Level1)
300 {
301 auto interruptServiceTest = GetTnterruptServiceTest();
302 interruptServiceTest->Init(GetPolicyServerTest());
303 interruptServiceTest->zonesMap_.clear();
304 EXPECT_EQ(interruptServiceTest->zonesMap_.size(), 0);
305 auto newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
306 EXPECT_EQ(newAudioFocuInfoList.size(), 0);
307 auto audioInterruptZone = std::make_shared<AudioInterruptZone>();
308 audioInterruptZone->audioFocusInfoList.emplace_back(AudioInterrupt(), AudioFocuState{PAUSE});
309 audioInterruptZone->audioFocusInfoList.emplace_back(AudioInterrupt(), AudioFocuState{});
310 interruptServiceTest->zonesMap_[0] = audioInterruptZone;
311 newAudioFocuInfoList = interruptServiceTest->SimulateFocusEntry(0);
312 interruptServiceTest->ResumeAudioFocusList(0, true);
313 interruptServiceTest->ResumeAudioFocusList(0, false);
314 EXPECT_EQ(newAudioFocuInfoList.size(), 2);
315 }
316
317 /**
318 * @tc.name : Test AudioInterruptService.
319 * @tc.number: AudioInterruptService_015
320 * @tc.desc : Test SendInterruptEvent.
321 */
322 HWTEST(AudioInterruptUnitTest, AudioInterruptService_015, TestSize.Level1)
323 {
324 auto interruptServiceTest = GetTnterruptServiceTest();
325 std::list<std::pair<AudioInterrupt, AudioFocuState>> pairList;
326 pairList.emplace_back(AudioInterrupt(), AudioFocuState::ACTIVE);
327 AudioFocuState oldState{};
328 AudioFocuState newState{};
329 auto it = pairList.begin();
330 bool removeFocusInfo = true;
331 interruptServiceTest->SendInterruptEvent(oldState, newState, it, removeFocusInfo);
332 interruptServiceTest->SetCallbackHandler(GetServerHandlerTest());
333 interruptServiceTest->SendInterruptEvent(oldState, newState, it, removeFocusInfo);
334
335 interruptServiceTest->SendInterruptEvent(PAUSE, ACTIVE, it, removeFocusInfo);
336 interruptServiceTest->SendInterruptEvent(DUCK, ACTIVE, it, removeFocusInfo);
337 interruptServiceTest->SendInterruptEvent(PAUSE, DUCK, it, removeFocusInfo);
338 interruptServiceTest->SendInterruptEvent(DUCK, DUCK, it, removeFocusInfo);
339 interruptServiceTest->SendInterruptEvent(DUCK, PAUSE, it, removeFocusInfo);
340 interruptServiceTest->SendInterruptEvent(PAUSE, PAUSE, it, removeFocusInfo);
341 interruptServiceTest->SendInterruptEvent(DUCK, PLACEHOLDER, it, removeFocusInfo);
342 interruptServiceTest->SendInterruptEvent(DUCK, STOP, it, removeFocusInfo);
343 EXPECT_NE(interruptServiceTest->handler_, nullptr);
344 }
345
346 /**
347 * @tc.name : Test AudioInterruptService.
348 * @tc.number: AudioInterruptService_017
349 * @tc.desc : Test IsActiveStreamLowPriority and IsIncomingStreamLowPriority.
350 */
351 HWTEST(AudioInterruptUnitTest, AudioInterruptService_017, TestSize.Level1)
352 {
353 auto interruptServiceTest = GetTnterruptServiceTest();
354 AudioFocusEntry entry;
355 entry.actionOn = INCOMING;
356 bool ret = interruptServiceTest->IsActiveStreamLowPriority(entry);
357 EXPECT_EQ(ret, false);
358
359 entry.actionOn = CURRENT;
360 entry.hintType = INTERRUPT_HINT_PAUSE;
361 ret = interruptServiceTest->IsActiveStreamLowPriority(entry);
362 EXPECT_EQ(ret, true);
363 entry.hintType = INTERRUPT_HINT_STOP;
364 ret = interruptServiceTest->IsActiveStreamLowPriority(entry);
365 EXPECT_EQ(ret, true);
366 entry.hintType = INTERRUPT_HINT_DUCK;
367 ret = interruptServiceTest->IsActiveStreamLowPriority(entry);
368 EXPECT_EQ(ret, true);
369
370 entry.hintType = INTERRUPT_HINT_UNDUCK;
371 ret = interruptServiceTest->IsActiveStreamLowPriority(entry);
372 EXPECT_EQ(ret, false);
373 entry.isReject = true;
374 ret = interruptServiceTest->IsIncomingStreamLowPriority(entry);
375 EXPECT_EQ(ret, true);
376 entry.isReject = false;
377 entry.actionOn = CURRENT;
378 ret = interruptServiceTest->IsIncomingStreamLowPriority(entry);
379 EXPECT_EQ(ret, false);
380
381 entry.actionOn = INCOMING;
382 entry.hintType = INTERRUPT_HINT_PAUSE;
383 ret = interruptServiceTest->IsIncomingStreamLowPriority(entry);
384 EXPECT_EQ(ret, true);
385 entry.hintType = INTERRUPT_HINT_STOP;
386 ret = interruptServiceTest->IsIncomingStreamLowPriority(entry);
387 EXPECT_EQ(ret, true);
388 entry.hintType = INTERRUPT_HINT_DUCK;
389 ret = interruptServiceTest->IsIncomingStreamLowPriority(entry);
390 EXPECT_EQ(ret, true);
391 entry.hintType = INTERRUPT_HINT_NONE;
392 ret = interruptServiceTest->IsIncomingStreamLowPriority(entry);
393 EXPECT_EQ(ret, false);
394 }
395
396 /**
397 * @tc.name : Test AudioInterruptService.
398 * @tc.number: AudioInterruptService_018
399 * @tc.desc : Test WriteServiceStartupError.
400 */
401 HWTEST(AudioInterruptUnitTest, AudioInterruptService_018, TestSize.Level1)
402 {
403 auto interruptServiceTest = GetTnterruptServiceTest();
404 EXPECT_NO_THROW(
405 interruptServiceTest->WriteServiceStartupError();
406 );
407 }
408
409 /**
410 * @tc.name : Test AudioInterruptService.
411 * @tc.number: AudioInterruptService_019
412 * @tc.desc : Test SendFocusChangeEvent.
413 */
414 HWTEST(AudioInterruptUnitTest, AudioInterruptService_019, TestSize.Level1)
415 {
416 auto interruptServiceTest = GetTnterruptServiceTest();
417 AudioInterrupt audioInterrupt;
418 EXPECT_NO_THROW(
419 interruptServiceTest->SendFocusChangeEvent(0, 0, audioInterrupt);
420
421 interruptServiceTest->SetCallbackHandler(GetServerHandlerTest());
422 interruptServiceTest->zonesMap_.clear();
423 interruptServiceTest->SendFocusChangeEvent(0, 0, audioInterrupt);
424
425 interruptServiceTest->zonesMap_[0] = nullptr;
426 interruptServiceTest->SendFocusChangeEvent(0, 0, audioInterrupt);
427
428 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();;
429 interruptServiceTest->SendFocusChangeEvent(0, 0, audioInterrupt);
430 );
431 }
432
433 /**
434 * @tc.name : Test AudioInterruptService.
435 * @tc.number: AudioInterruptService_021
436 * @tc.desc : Test ClearAudioFocusInfoListOnAccountsChanged.
437 */
438 HWTEST(AudioInterruptUnitTest, AudioInterruptService_021, TestSize.Level1)
439 {
440 auto interruptServiceTest = GetTnterruptServiceTest();
441 sptr<AudioPolicyServer> server = nullptr;
442 interruptServiceTest->zonesMap_.clear();
443 interruptServiceTest->ClearAudioFocusInfoListOnAccountsChanged(0);
444 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
445 interruptServiceTest->handler_ = nullptr;
446
447 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.empty(), true);
448 interruptServiceTest->ClearAudioFocusInfoListOnAccountsChanged(0);
449 interruptServiceTest->SetCallbackHandler(GetServerHandlerTest());
450 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.empty(), true);
451 interruptServiceTest->ClearAudioFocusInfoListOnAccountsChanged(0);
452 AudioInterrupt a1, a2, a3;
453 a1.streamUsage = StreamUsage::STREAM_USAGE_VOICE_MODEM_COMMUNICATION;
454 a2.streamUsage = StreamUsage::STREAM_USAGE_VOICE_RINGTONE;
455 a3.streamUsage = StreamUsage::STREAM_USAGE_UNKNOWN;
456 interruptServiceTest->zonesMap_[0]->audioFocusInfoList.push_back({a1, AudioFocuState::ACTIVE});
457 interruptServiceTest->zonesMap_[0]->audioFocusInfoList.push_back({a2, AudioFocuState::ACTIVE});
458 interruptServiceTest->zonesMap_[0]->audioFocusInfoList.push_back({a3, AudioFocuState::ACTIVE});
459 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 3);
460 interruptServiceTest->ClearAudioFocusInfoListOnAccountsChanged(0);
461 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 2);
462 }
463
464 /**
465 * @tc.name : Test AudioInterruptService.
466 * @tc.number: AudioInterruptService_022
467 * @tc.desc : Test ResetNonInterruptControl.
468 */
469 HWTEST(AudioInterruptUnitTest, AudioInterruptService_022, TestSize.Level1)
470 {
471 uint32_t sessionId = CLIENT_TYPE_OTHERS;
472 auto interruptServiceTest = GetTnterruptServiceTest();
473
474 interruptServiceTest->Init(GetPolicyServerTest());
475 EXPECT_NO_THROW(
476 interruptServiceTest->ResetNonInterruptControl(sessionId);
477 );
478
479 sessionId = CLIENT_TYPE_GAME;
480 EXPECT_NO_THROW(
481 interruptServiceTest->ResetNonInterruptControl(sessionId);
482 );
483
484 sessionId = 2;
485 EXPECT_NO_THROW(
486 interruptServiceTest->ResetNonInterruptControl(sessionId);
487 );
488 }
489
490 /**
491 * @tc.name : Test AudioInterruptService.
492 * @tc.number: AudioInterruptService_023
493 * @tc.desc : Test CreateAudioInterruptZone.
494 */
495 HWTEST(AudioInterruptUnitTest, AudioInterruptService_023, TestSize.Level1)
496 {
497 MessageParcel data;
498 auto interruptServiceTest = GetTnterruptServiceTest();
499
500 interruptServiceTest->Init(GetPolicyServerTest());
501 interruptServiceTest->zonesMap_.clear();
502 EXPECT_EQ(interruptServiceTest->zonesMap_.empty(), true);
503 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
504 interruptServiceTest->zonesMap_[0]->interruptCbsMap[0] = nullptr;
505 std::set<int32_t> pids;
506 pids.insert(data.ReadInt32());
507 int32_t zoneId = 1;
508
509 int32_t ret = interruptServiceTest->CreateAudioInterruptZone(zoneId);
510 EXPECT_EQ(ret, VALUE_ERROR);
511
512 zoneId = 0;
513 ret = interruptServiceTest->CreateAudioInterruptZone(zoneId);
514 EXPECT_EQ(ret, VALUE_ERROR);
515 }
516
517 /**
518 * @tc.name : Test AudioInterruptService.
519 * @tc.number: AudioInterruptService_024
520 * @tc.desc : Test ReleaseAudioInterruptZone.
521 */
522 HWTEST(AudioInterruptUnitTest, AudioInterruptService_024, TestSize.Level1)
523 {
524 auto interruptServiceTest = GetTnterruptServiceTest();
525 int32_t zoneId = 1;
526
527 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anonc16f3c580102(int32_t uid, const std::string &deviceTag, const std::string &streamTag)528 const std::string &streamTag)->int32_t {
529 return 0;
530 };
531
532 interruptServiceTest->Init(GetPolicyServerTest());
533 interruptServiceTest->zonesMap_.clear();
534 EXPECT_EQ(interruptServiceTest->zonesMap_.empty(), true);
535 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
536 interruptServiceTest->zonesMap_[0]->interruptCbsMap[0] = nullptr;
537
538 int32_t ret = interruptServiceTest->ReleaseAudioInterruptZone(zoneId, getZoneFunc);
539 EXPECT_EQ(ret, VALUE_ERROR);
540
541 zoneId = 0;
542 ret = interruptServiceTest->ReleaseAudioInterruptZone(zoneId, getZoneFunc);
543 EXPECT_EQ(ret, VALUE_ERROR);
544 }
545
546 /**
547 * @tc.name : Test AudioInterruptService.
548 * @tc.number: AudioInterruptService_025
549 * @tc.desc : Test ReleaseAudioInterruptZone.
550 */
551 HWTEST(AudioInterruptUnitTest, AudioInterruptService_025, TestSize.Level1)
552 {
553 auto interruptServiceTest = GetTnterruptServiceTest();
554 int32_t zoneId = 0;
555
556 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anonc16f3c580202(int32_t uid, const std::string &deviceTag, const std::string &streamTag)557 const std::string &streamTag)->int32_t {
558 return 0;
559 };
560
561 interruptServiceTest->Init(GetPolicyServerTest());
562 MessageParcel data;
563 std::set<int32_t> pids;
564 pids.insert(data.ReadInt32());
565
566 int32_t ret = interruptServiceTest->ReleaseAudioInterruptZone(zoneId, getZoneFunc);
567 EXPECT_EQ(ret, VALUE_ERROR);
568
569 zoneId = 1;
570 ret = interruptServiceTest->ReleaseAudioInterruptZone(zoneId, getZoneFunc);
571 EXPECT_EQ(ret, VALUE_ERROR);
572
573 zoneId = 0;
574 ret = interruptServiceTest->ReleaseAudioInterruptZone(zoneId, getZoneFunc);
575 EXPECT_EQ(ret, VALUE_ERROR);
576 }
577
578 /**
579 * @tc.name : Test AudioInterruptService.
580 * @tc.number: AudioInterruptService_027
581 * @tc.desc : Test GetAudioFocusInfoList.
582 */
583 HWTEST(AudioInterruptUnitTest, AudioInterruptService_027, TestSize.Level1)
584 {
585 auto interruptServiceTest = GetTnterruptServiceTest();
586 int32_t zoneId = 0;
587
588 interruptServiceTest->Init(GetPolicyServerTest());
589 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList = {};
590 std::pair<AudioInterrupt, AudioFocuState> focusInfo = {};
591
592 int32_t ret = interruptServiceTest->GetAudioFocusInfoList(zoneId, focusInfoList);
593 EXPECT_EQ(ret, SUCCESS);
594
595 interruptServiceTest->zonesMap_.clear();
596 EXPECT_EQ(interruptServiceTest->zonesMap_.empty(), true);
597 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
598 interruptServiceTest->zonesMap_[0]->interruptCbsMap[0] = nullptr;
599
600 ret = interruptServiceTest->GetAudioFocusInfoList(zoneId, focusInfoList);
601 EXPECT_EQ(ret, SUCCESS);
602 }
603
604 /**
605 * @tc.name : Test AudioInterruptService.
606 * @tc.number: AudioInterruptService_028
607 * @tc.desc : Test GetStreamInFocus.
608 */
609 HWTEST(AudioInterruptUnitTest, AudioInterruptService_028, TestSize.Level1)
610 {
611 auto interruptServiceTest = GetTnterruptServiceTest();
612 int32_t zoneId = 0;
613
614 interruptServiceTest->Init(GetPolicyServerTest());
615 EXPECT_NO_THROW(
616 interruptServiceTest->GetStreamInFocus(zoneId);
617 );
618
619 interruptServiceTest->zonesMap_.clear();
620 EXPECT_EQ(interruptServiceTest->zonesMap_.empty(), true);
621 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
622 interruptServiceTest->zonesMap_[0]->interruptCbsMap[0] = nullptr;
623 EXPECT_NO_THROW(
624 interruptServiceTest->GetStreamInFocus(zoneId);
625 );
626 }
627
628 /**
629 * @tc.name : Test AudioInterruptService.
630 * @tc.number: AudioInterruptService_029
631 * @tc.desc : Test GetAudioServerProxy.
632 */
633 HWTEST(AudioInterruptUnitTest, AudioInterruptService_029, TestSize.Level1)
634 {
635 auto interruptServiceTest = GetTnterruptServiceTest();
636 const sptr<IStandardAudioService> result = interruptServiceTest->GetAudioServerProxy();
637 EXPECT_EQ(result, nullptr);
638 }
639
640 /**
641 * @tc.name : Test AudioInterruptService.
642 * @tc.number: AudioInterruptService_030
643 * @tc.desc : Test OnSessionTimeout.
644 */
645 HWTEST(AudioInterruptUnitTest, AudioInterruptService_030, TestSize.Level1)
646 {
647 auto interruptServiceTest = GetTnterruptServiceTest();
648 AudioInterrupt audioInterrupt;
649 audioInterrupt.pid = 2;
650 interruptServiceTest->OnSessionTimeout(audioInterrupt.pid);
651 EXPECT_NE(interruptServiceTest, nullptr);
652 }
653
654 /**
655 * @tc.name : Test AudioInterruptService.
656 * @tc.number: AudioInterruptService_031
657 * @tc.desc : Test ActivateAudioSession.
658 */
659 HWTEST(AudioInterruptUnitTest, AudioInterruptService_031, TestSize.Level1)
660 {
661 auto interruptServiceTest = GetTnterruptServiceTest();
662 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
663 AudioSessionStrategy strategy;
664 interruptServiceTest->ActivateAudioSession(CALLER_PID, strategy);
665 EXPECT_NE(interruptServiceTest, nullptr);
666
667 interruptServiceTest->sessionService_ = nullptr;
668 int32_t result = interruptServiceTest->ActivateAudioSession(CALLER_PID, strategy);
669 EXPECT_EQ(result, ERR_UNKNOWN);
670 }
671
672 /**
673 * @tc.name : Test AudioInterruptService.
674 * @tc.number: AudioInterruptService_032
675 * @tc.desc : Test AddActiveInterruptToSession.
676 */
677 HWTEST(AudioInterruptUnitTest, AudioInterruptService_032, TestSize.Level1)
678 {
679 auto interruptServiceTest = std::make_shared<AudioInterruptService>();
680 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
681 interruptServiceTest->AddActiveInterruptToSession(CALLER_PID);
682 EXPECT_NE(interruptServiceTest, nullptr);
683
684 interruptServiceTest->sessionService_ = nullptr;
685 interruptServiceTest->AddActiveInterruptToSession(CALLER_PID);
686 EXPECT_NE(interruptServiceTest, nullptr);
687 }
688
689 /**
690 * @tc.name : Test AudioInterruptService.
691 * @tc.number: AudioInterruptService_033
692 * @tc.desc : Test DeactivateAudioSession.
693 */
694 HWTEST(AudioInterruptUnitTest, AudioInterruptService_033, TestSize.Level1)
695 {
696 auto interruptServiceTest = GetTnterruptServiceTest();
697 int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
698 int32_t result = interruptServiceTest->DeactivateAudioSession(CALLER_PID);
699 EXPECT_NE(interruptServiceTest, nullptr);
700
701 interruptServiceTest->sessionService_ = nullptr;
702 result = interruptServiceTest->DeactivateAudioSession(CALLER_PID);
703 EXPECT_EQ(result, ERR_UNKNOWN);
704 }
705
706 /**
707 * @tc.name : Test AudioInterruptService.
708 * @tc.number: AudioInterruptService_034
709 * @tc.desc : Test CanMixForSession.
710 */
711 HWTEST(AudioInterruptUnitTest, AudioInterruptService_034, TestSize.Level1)
712 {
713 auto interruptServiceTest = std::make_shared<AudioInterruptService>();
714 AudioInterrupt incomingInterrupt;
715 AudioInterrupt activeInterrupt;
716 AudioFocusEntry focusEntry;
717 interruptServiceTest->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
718 EXPECT_NE(interruptServiceTest, nullptr);
719
720 focusEntry.isReject = true;
721 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_VOICE_RECOGNITION;
722 bool result = interruptServiceTest->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
723 EXPECT_EQ(result, false);
724 }
725
726 /**
727 * @tc.name : Test AudioInterruptService.
728 * @tc.number: AudioInterruptService_035
729 * @tc.desc : Test CanMixForIncomingSession.
730 */
731 HWTEST(AudioInterruptUnitTest, AudioInterruptService_035, TestSize.Level1)
732 {
733 auto interruptServiceTest = std::make_shared<AudioInterruptService>();
734 AudioInterrupt incomingInterrupt;
735 AudioInterrupt activeInterrupt;
736 AudioFocusEntry focusEntry;
737 interruptServiceTest->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
738 EXPECT_NE(interruptServiceTest, nullptr);
739
740 interruptServiceTest->sessionService_ = nullptr;
741 bool result = interruptServiceTest->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
742 EXPECT_EQ(result, false);
743 }
744
745 /**
746 * @tc.name : Test AudioInterruptService.
747 * @tc.number: AudioInterruptService_036
748 * @tc.desc : Test CanMixForActiveSession.
749 */
750 HWTEST(AudioInterruptUnitTest, AudioInterruptService_036, TestSize.Level1)
751 {
752 auto interruptServiceTest = std::make_shared<AudioInterruptService>();
753 AudioInterrupt incomingInterrupt;
754 AudioInterrupt activeInterrupt;
755 AudioFocusEntry focusEntry;
756 interruptServiceTest->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
757 EXPECT_NE(interruptServiceTest, nullptr);
758
759 interruptServiceTest->sessionService_ = nullptr;
760 bool result = interruptServiceTest->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
761 EXPECT_EQ(result, false);
762 }
763
764 /**
765 * @tc.name : Test AudioInterruptService.
766 * @tc.number: AudioInterruptService_037
767 * @tc.desc : Test RequestAudioFocus.
768 */
769 HWTEST(AudioInterruptUnitTest, AudioInterruptService_037, TestSize.Level1)
770 {
771 auto interruptServiceTest = GetTnterruptServiceTest();
772 int32_t clientId = interruptServiceTest->clientOnFocus_;
773 AudioInterrupt audioInterrupt;
774 audioInterrupt.contentType = ContentType::CONTENT_TYPE_RINGTONE;
775 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_VOICE_RINGTONE;
776 audioInterrupt.audioFocusType.streamType = STREAM_RING;
777 int32_t result = interruptServiceTest->RequestAudioFocus(clientId, audioInterrupt);
778 EXPECT_EQ(result, SUCCESS);
779 }
780
781 /**
782 * @tc.name : Test AudioInterruptService.
783 * @tc.number: AudioInterruptService_038
784 * @tc.desc : Test AbandonAudioFocus.
785 */
786 HWTEST(AudioInterruptUnitTest, AudioInterruptService_038, TestSize.Level1)
787 {
788 auto interruptServiceTest = GetTnterruptServiceTest();
789 int32_t clientId = interruptServiceTest->clientOnFocus_;
790 AudioInterrupt audioInterrupt;
791 audioInterrupt.contentType = ContentType::CONTENT_TYPE_RINGTONE;
792 audioInterrupt.streamUsage = StreamUsage::STREAM_USAGE_VOICE_RINGTONE;
793 audioInterrupt.audioFocusType.streamType = STREAM_RING;
794 int32_t result = interruptServiceTest->AbandonAudioFocus(clientId, audioInterrupt);
795 EXPECT_EQ(result, SUCCESS);
796 }
797
798 /**
799 * @tc.name : Test AudioInterruptService.
800 * @tc.number: AudioInterruptService_039
801 * @tc.desc : Test AudioInterruptIsActiveInFocusList.
802 */
803 HWTEST(AudioInterruptUnitTest, AudioInterruptService_039, TestSize.Level1)
804 {
805 auto interruptServiceTest = GetTnterruptServiceTest();
806 int32_t zoneId = 0;
807 uint32_t incomingSessionId = 0;
808 bool result = interruptServiceTest->AudioInterruptIsActiveInFocusList(zoneId, incomingSessionId);
809 EXPECT_EQ(result, 0);
810 zoneId = 1;
811 incomingSessionId = 1;
812 result = interruptServiceTest->AudioInterruptIsActiveInFocusList(zoneId, incomingSessionId);
813 EXPECT_EQ(result, 0);
814 zoneId = 0;
815 incomingSessionId = 2;
816 result = interruptServiceTest->AudioInterruptIsActiveInFocusList(zoneId, incomingSessionId);
817 EXPECT_EQ(result, 0);
818 }
819
820 /**
821 * @tc.name : Test AudioInterruptService.
822 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_001
823 * @tc.desc : Test CanMixForIncomingSession. sessionService_ is nullptr.
824 */
825 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_001, TestSize.Level1)
826 {
827 auto interruptService = GetTnterruptServiceTest();
828 interruptService->sessionService_ = nullptr;
829 AudioInterrupt incomingInterrupt;
830 AudioInterrupt activeInterrupt;
831 AudioFocusEntry focusEntry;
832 auto ret = interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
833 EXPECT_FALSE(ret);
834 }
835
836 /**
837 * @tc.name : Test AudioInterruptService.
838 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_002
839 * @tc.desc : Test CanMixForIncomingSession. incomingInterrupt.pid is -1
840 */
841 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_002, TestSize.Level1)
842 {
843 auto interruptService = GetTnterruptServiceTest();
844 auto server = GetPolicyServerTest();
845 interruptService->Init(server);
846 AudioInterrupt incomingInterrupt;
847 AudioInterrupt activeInterrupt;
848 AudioFocusEntry focusEntry;
849 auto ret = interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
850 EXPECT_FALSE(ret);
851 }
852
853 /**
854 * @tc.name : Test AudioInterruptService.
855 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_003
856 * @tc.desc : Test CanMixForIncomingSession. incomingSession is nullptr.
857 */
858 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_003, TestSize.Level1)
859 {
860 auto interruptService = GetTnterruptServiceTest();
861 auto server = GetPolicyServerTest();
862 interruptService->Init(server);
863 AudioInterrupt incomingInterrupt;
864 AudioInterrupt activeInterrupt;
865 AudioFocusEntry focusEntry;
866 int32_t ret = interruptService->ActivateAudioSession(incomingInterrupt.pid, strategyTest);
867 EXPECT_EQ(SUCCESS, ret);
868
869 EXPECT_FALSE(interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry));
870 }
871
872 /**
873 * @tc.name : Test AudioInterruptService.
874 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_004
875 * @tc.desc : Test CanMixForIncomingSession. IsIncomingStreamLowPriority(focusEntry) is true.
876 */
877 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_004, TestSize.Level1)
878 {
879 auto interruptService = GetTnterruptServiceTest();
880 auto server = GetPolicyServerTest();
881 interruptService->Init(server);
882 AudioInterrupt incomingInterrupt;
883 AudioInterrupt activeInterrupt;
884 AudioFocusEntry focusEntry;
885 strategyTest.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
886 int32_t ret = interruptService->ActivateAudioSession(incomingInterrupt.pid, strategyTest);
887 EXPECT_EQ(SUCCESS, ret);
888
889 focusEntry.isReject = true;
890 EXPECT_FALSE(interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry));
891 }
892
893 /**
894 * @tc.name : Test AudioInterruptService.
895 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_005
896 * @tc.desc : Test CanMixForIncomingSession. IsIncomingStreamLowPriority(focusEntry) is false.
897 */
898 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_005, TestSize.Level1)
899 {
900 auto interruptService = GetTnterruptServiceTest();
901 auto server = GetPolicyServerTest();
902 interruptService->Init(server);
903 AudioInterrupt incomingInterrupt;
904 AudioInterrupt activeInterrupt;
905 AudioFocusEntry focusEntry;
906 strategyTest.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
907 int32_t ret = interruptService->ActivateAudioSession(incomingInterrupt.pid, strategyTest);
908 EXPECT_EQ(SUCCESS, ret);
909
910 focusEntry.isReject = false;
911 focusEntry.actionOn = CURRENT;
912 EXPECT_TRUE(interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry));
913 }
914
915 /**
916 * @tc.name : Test AudioInterruptService.
917 * @tc.number: AudioInterruptServiceCanMixForSession_001
918 * @tc.desc : Test CanMixForSession.
919 */
920 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_001, TestSize.Level1)
921 {
922 auto interruptService = GetTnterruptServiceTest();
923 auto server = GetPolicyServerTest();
924 interruptService->Init(server);
925 AudioInterrupt incomingInterrupt;
926 AudioInterrupt activeInterrupt;
927 AudioFocusEntry focusEntry;
928 focusEntry.isReject = true;
929 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
930
931 auto ret = interruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
932 EXPECT_FALSE(ret);
933 }
934
935 /**
936 * @tc.name : Test AudioInterruptService.
937 * @tc.number: AudioInterruptServiceCanMixForSession_002
938 * @tc.desc : Test CanMixForSession.
939 */
940 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_002, TestSize.Level1)
941 {
942 auto interruptService = GetTnterruptServiceTest();
943 auto server = GetPolicyServerTest();
944 interruptService->Init(server);
945 AudioInterrupt incomingInterrupt;
946 AudioInterrupt activeInterrupt;
947 AudioFocusEntry focusEntry;
948 focusEntry.isReject = false;
949 focusEntry.actionOn = CURRENT;
950 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
951 strategyTest.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
952 int32_t ret = interruptService->ActivateAudioSession(incomingInterrupt.pid, strategyTest);
953 EXPECT_EQ(SUCCESS, ret);
954
955 ret = interruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
956 EXPECT_TRUE(ret);
957 }
958
959 /**
960 * @tc.name : Test AudioInterruptService.
961 * @tc.number: AudioInterruptServiceCanMixForSession_003
962 * @tc.desc : Test CanMixForSession.
963 */
964 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_003, TestSize.Level1)
965 {
966 auto interruptService = GetTnterruptServiceTest();
967 auto server = GetPolicyServerTest();
968 interruptService->Init(server);
969 AudioInterrupt incomingInterrupt;
970 AudioInterrupt activeInterrupt;
971 AudioFocusEntry focusEntry;
972 focusEntry.isReject = false;
973 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
974 int32_t ret = interruptService->ActivateAudioSession(incomingInterrupt.pid, strategyTest);
975 EXPECT_EQ(SUCCESS, ret);
976
977 focusEntry.actionOn = CURRENT;
978 strategyTest.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
979 ret = interruptService->ActivateAudioSession(activeInterrupt.pid, strategyTest);
980 EXPECT_EQ(SUCCESS, ret);
981
982 ret = interruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
983 EXPECT_TRUE(ret);
984 }
985
986 /**
987 * @tc.name : Test AudioInterruptService.
988 * @tc.number: AudioInterruptServiceCanMixForSession_004
989 * @tc.desc : Test CanMixForSession.
990 */
991 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_004, TestSize.Level1)
992 {
993 auto interruptService = GetTnterruptServiceTest();
994 interruptService->SetCallbackHandler(GetServerHandlerTest());
995 auto server = GetPolicyServerTest();
996 interruptService->Init(server);
997 AudioFocusType audioFocusTypeTest;
998 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
999 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1000 activeInterrupt.pid = { -1 };
1001 AudioFocusEntry focusEntry;
1002 focusEntry.isReject = true;
1003 incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
1004
1005 auto ret = interruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
1006 EXPECT_FALSE(ret);
1007 }
1008
1009 /**
1010 * @tc.name : Test AudioInterruptService.
1011 * @tc.number: AudioInterruptServiceRemovePlaceholderInterruptForSession_001
1012 * @tc.desc : Test RemovePlaceholderInterruptForSession. sessionService_ is nullptr.
1013 */
1014 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptForSession_001, TestSize.Level1)
1015 {
1016 auto interruptService = GetTnterruptServiceTest();
1017 interruptService->sessionService_ = nullptr;
1018 int32_t pid = CALLER_PID;
1019 bool timeOut = IS_SESSION_TIMEOUT;
1020 interruptService->RemovePlaceholderInterruptForSession(pid, timeOut);
1021 EXPECT_EQ(nullptr, interruptService->sessionService_);
1022
1023 auto server = GetPolicyServerTest();
1024 interruptService->Init(server);
1025 int32_t ret = interruptService->ActivateAudioSession(pid, strategyTest);
1026 EXPECT_EQ(SUCCESS, ret);
1027 interruptService->RemovePlaceholderInterruptForSession(pid, timeOut);
1028 EXPECT_TRUE(interruptService->sessionService_->IsAudioSessionActivated(pid));
1029 }
1030
1031 /**
1032 * @tc.name : Test AudioInterruptService.
1033 * @tc.number: AudioInterruptServiceRemovePlaceholderInterruptForSession_002
1034 * @tc.desc : Test RemovePlaceholderInterruptForSession. About itZone.
1035 */
1036 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptForSession_002, TestSize.Level1)
1037 {
1038 auto interruptService = GetTnterruptServiceTest();
1039 auto server = GetPolicyServerTest();
1040 interruptService->Init(server);
1041 int32_t pid = CALLER_PID;
1042 bool timeOut = IS_SESSION_TIMEOUT;
1043 interruptService->zonesMap_.find(DEFAULT_ZONE_ID)->second = nullptr;
1044 interruptService->RemovePlaceholderInterruptForSession(pid, timeOut);
1045 EXPECT_EQ(nullptr, interruptService->zonesMap_.find(DEFAULT_ZONE_ID)->second);
1046
1047 AudioInterrupt audioInterrupt;
1048 audioInterrupt.streamId = 2;
1049 audioInterrupt.pid = 2;
1050 interruptService->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1051 interruptService->zonesMap_[0]->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, ACTIVE));
1052 interruptService->RemovePlaceholderInterruptForSession(pid, timeOut);
1053 EXPECT_FALSE(interruptService->zonesMap_.empty());
1054 }
1055
1056 /**
1057 * @tc.name : Test AudioInterruptService.
1058 * @tc.number: AudioInterruptServiceRemovePlaceholderInterruptForSession_003
1059 * @tc.desc : Test RemovePlaceholderInterruptForSession. About itZone.
1060 */
1061 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptForSession_003, TestSize.Level1)
1062 {
1063 auto interruptService = GetTnterruptServiceTest();
1064 auto server = GetPolicyServerTest();
1065 interruptService->Init(server);
1066
1067 bool timeOut = IS_SESSION_TIMEOUT;
1068 AudioInterrupt audioInterrupt;
1069 audioInterrupt.streamId = 2;
1070 audioInterrupt.pid = 2;
1071 int32_t pid = audioInterrupt.pid;
1072 interruptService->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1073 interruptService->zonesMap_[0]->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, PLACEHOLDER));
1074 interruptService->RemovePlaceholderInterruptForSession(pid, timeOut);
1075 EXPECT_FALSE(interruptService->zonesMap_.empty());
1076 }
1077
1078 /**
1079 * @tc.name : Test AudioInterruptService.
1080 * @tc.number: AudioInterruptServiceDeactivateAudioSession_001
1081 * @tc.desc : Test DeactivateAudioSession.
1082 */
1083 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceDeactivateAudioSession_001, TestSize.Level1)
1084 {
1085 auto interruptService = GetTnterruptServiceTest();
1086 interruptService->sessionService_ = nullptr;
1087 int32_t pid = CALLER_PID;
1088 int32_t ret = interruptService->DeactivateAudioSession(pid);
1089 EXPECT_EQ(ERR_UNKNOWN, ret);
1090
1091 auto server = GetPolicyServerTest();
1092 interruptService->Init(server);
1093 ret = interruptService->DeactivateAudioSession(pid);
1094 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
1095
1096 strategyTest.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
1097 ret = interruptService->ActivateAudioSession(pid, strategyTest);
1098 EXPECT_EQ(SUCCESS, ret);
1099 ret = interruptService->DeactivateAudioSession(pid);
1100 EXPECT_EQ(SUCCESS, ret);
1101 }
1102
1103 /**
1104 * @tc.name : Test AudioInterruptService.
1105 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_001
1106 * @tc.desc : Test AddActiveInterruptToSession. sessionService_ is nullptr.
1107 */
1108 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_001, TestSize.Level1)
1109 {
1110 auto interruptService = GetTnterruptServiceTest();
1111 interruptService->sessionService_ = nullptr;
1112 int32_t pid = CALLER_PID;
1113 interruptService->AddActiveInterruptToSession(pid);
1114 EXPECT_EQ(nullptr, interruptService->sessionService_);
1115
1116 auto server = GetPolicyServerTest();
1117 interruptService->Init(server);
1118 interruptService->AddActiveInterruptToSession(pid);
1119 EXPECT_FALSE(interruptService->sessionService_->IsAudioSessionActivated(pid));
1120 }
1121
1122 /**
1123 * @tc.name : Test AudioInterruptService.
1124 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_002
1125 * @tc.desc : Test AddActiveInterruptToSession. About itZone.
1126 */
1127 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_002, TestSize.Level1)
1128 {
1129 auto interruptService = GetTnterruptServiceTest();
1130 auto server = GetPolicyServerTest();
1131 interruptService->Init(server);
1132 int32_t pid = CALLER_PID;
1133 int32_t ret = interruptService->ActivateAudioSession(pid, strategyTest);
1134 EXPECT_EQ(SUCCESS, ret);
1135 interruptService->zonesMap_.find(DEFAULT_ZONE_ID)->second = nullptr;
1136 interruptService->AddActiveInterruptToSession(pid);
1137 EXPECT_EQ(nullptr, interruptService->zonesMap_.find(DEFAULT_ZONE_ID)->second);
1138
1139 AudioInterrupt audioInterrupt;
1140 audioInterrupt.streamId = 2;
1141 audioInterrupt.pid = 2;
1142 interruptService->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1143 interruptService->zonesMap_[0]->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, ACTIVE));
1144 interruptService->AddActiveInterruptToSession(pid);
1145 EXPECT_FALSE(interruptService->zonesMap_.empty());
1146 }
1147
1148 /**
1149 * @tc.name : Test AudioInterruptService.
1150 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_003
1151 * @tc.desc : Test AddActiveInterruptToSession. About itZone.
1152 */
1153 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_003, TestSize.Level1)
1154 {
1155 auto interruptService = GetTnterruptServiceTest();
1156 auto server = GetPolicyServerTest();
1157 interruptService->Init(server);
1158 int32_t pid = CALLER_PID;
1159 int32_t ret = interruptService->ActivateAudioSession(pid, strategyTest);
1160 EXPECT_EQ(SUCCESS, ret);
1161
1162 AudioInterrupt audioInterrupt;
1163 audioInterrupt.streamId = CALLER_PID;
1164 audioInterrupt.pid = CALLER_PID;
1165 interruptService->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1166 interruptService->zonesMap_[0]->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, ACTIVE));
1167 interruptService->AddActiveInterruptToSession(pid);
1168 EXPECT_FALSE(interruptService->zonesMap_.empty());
1169 }
1170
1171 /**
1172 * @tc.name : Test AudioInterruptService.
1173 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_004
1174 * @tc.desc : Test AddActiveInterruptToSession. About itZone.
1175 */
1176 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_004, TestSize.Level1)
1177 {
1178 auto interruptService = GetTnterruptServiceTest();
1179 auto server = GetPolicyServerTest();
1180 interruptService->Init(server);
1181 interruptService->zonesMap_.clear();
1182 int32_t pid = CALLER_PID;
1183 AudioInterrupt audioInterrupt;
1184 audioInterrupt.streamId = CALLER_PID;
1185 audioInterrupt.pid = CALLER_PID;
1186 interruptService->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1187 interruptService->zonesMap_[0]->audioFocusInfoList.push_back(std::make_pair(audioInterrupt, ACTIVE));
1188 int32_t ret = interruptService->ActivateAudioSession(pid, strategyTest);
1189 EXPECT_EQ(SUCCESS, ret);
1190 interruptService->AddActiveInterruptToSession(pid);
1191 EXPECT_FALSE(interruptService->zonesMap_.empty());
1192 interruptService->zonesMap_.clear();
1193 }
1194
1195 /**
1196 * @tc.name : Test AudioInterruptService.
1197 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_005
1198 * @tc.desc : Test AddActiveInterruptToSession. About itZone. itZone->second != nullptr.
1199 */
1200 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_005, TestSize.Level1)
1201 {
1202 auto interruptService = GetTnterruptServiceTest();
1203 auto server = GetPolicyServerTest();
1204 interruptService->Init(server);
1205 interruptService->zonesMap_.clear();
1206 int32_t pid = CALLER_PID;
1207 AudioInterrupt audioInterrupt;
1208 audioInterrupt.streamId = CALLER_PID;
1209 audioInterrupt.pid = CALLER_PID;
1210 std::shared_ptr<AudioInterruptZone> audioInterruptZone = nullptr;
1211 interruptService->zonesMap_[0] = audioInterruptZone;
1212 int32_t ret = interruptService->ActivateAudioSession(pid, strategyTest);
1213 EXPECT_EQ(SUCCESS, ret);
1214 interruptService->AddActiveInterruptToSession(pid);
1215 EXPECT_FALSE(interruptService->zonesMap_.empty());
1216 interruptService->zonesMap_.clear();
1217 audioInterruptZone.reset();
1218 }
1219
1220 /**
1221 * @tc.name : Test GetAudioServerProxy API.
1222 * @tc.number: AudioInterruptServiceGetAudioServerProxy_001
1223 * @tc.desc : Test OnSessionTimeout when g_adProxy is nullptr.
1224 */
1225 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceGetAudioServerProxy_001, TestSize.Level1)
1226 {
1227 audioInterruptService = GetTnterruptServiceTest();
1228 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1229 EXPECT_NE(nullptr, audioInterruptService);
1230
1231 sptr<IStandardAudioService> ret = audioInterruptService->GetAudioServerProxy();
1232 EXPECT_EQ(nullptr, ret);
1233 }
1234
1235 /**
1236 * @tc.name : Test GetAudioServerProxy API.
1237 * @tc.number: AudioInterruptServiceGetAudioServerProxy_002
1238 * @tc.desc : Test OnSessionTimeout when g_adProxy is not nullptr.
1239 */
1240 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceGetAudioServerProxy_002, TestSize.Level1)
1241 {
1242 audioInterruptService = GetTnterruptServiceTest();
1243 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1244 EXPECT_NE(nullptr, audioInterruptService);
1245
1246 sptr<IStandardAudioService> ret = audioInterruptService->GetAudioServerProxy();
1247 ret = audioInterruptService->GetAudioServerProxy();
1248 EXPECT_EQ(nullptr, ret);
1249 }
1250
1251 /**
1252 * @tc.name : Test OnSessionTimeout API.
1253 * @tc.number: AudioInterruptServiceOnSessionTimeout_001
1254 * @tc.desc : Test normal OnSessionTimeout.
1255 * Test normal HandleSessionTimeOutEvent.
1256 */
1257 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceOnSessionTimeout_001, TestSize.Level1)
1258 {
1259 audioInterruptService = GetTnterruptServiceTest();
1260 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1261 EXPECT_NE(nullptr, audioInterruptService);
1262
1263 audioInterruptService->Init(serverTest);
1264 audioInterruptService->OnSessionTimeout(PIT_TEST);
1265 EXPECT_NE(nullptr, audioInterruptService->handler_);
1266 }
1267
1268 /**
1269 * @tc.name : Test OnSessionTimeout API.
1270 * @tc.number: AudioInterruptServiceOnSessionTimeout_002
1271 * @tc.desc : Test normal OnSessionTimeout.
1272 * Test normal HandleSessionTimeOutEvent.
1273 */
1274 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceOnSessionTimeout_002, TestSize.Level1)
1275 {
1276 audioInterruptService = GetTnterruptServiceTest();
1277 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1278 EXPECT_NE(nullptr, audioInterruptService);
1279
1280 audioInterruptService->Init(serverTest);
1281 audioInterruptService->handler_ = nullptr;
1282 audioInterruptService->OnSessionTimeout(PIT_TEST);
1283 EXPECT_EQ(nullptr, audioInterruptService->handler_);
1284 }
1285
1286 /**
1287 * @tc.name : Test ActivateAudioSession API.
1288 * @tc.number: AudioInterruptServiceActivateAudioSession_001
1289 * @tc.desc : Test ActivateAudioSession when sessionService_ is nullptr.
1290 */
1291 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceActivateAudioSession_001, TestSize.Level1)
1292 {
1293 audioInterruptService = GetTnterruptServiceTest();
1294 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1295 EXPECT_NE(nullptr, audioInterruptService);
1296
1297 audioInterruptService->Init(serverTest);
1298 audioInterruptService->sessionService_ = nullptr;
1299 int32_t ret = audioInterruptService->ActivateAudioSession(CALLER_PID_TEST, strategyTest);
1300 EXPECT_EQ(ERR_UNKNOWN, ret);
1301 }
1302
1303 /**
1304 * @tc.name : Test ActivateAudioSession API.
1305 * @tc.number: AudioInterruptServiceActivateAudioSession_002
1306 * @tc.desc : Test normal ActivateAudioSession.
1307 */
1308 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceActivateAudioSession_002, TestSize.Level1)
1309 {
1310 audioInterruptService = GetTnterruptServiceTest();
1311 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1312 EXPECT_NE(nullptr, audioInterruptService);
1313
1314 audioInterruptService->Init(serverTest);
1315 int32_t ret = audioInterruptService->ActivateAudioSession(CALLER_PID_TEST, strategyTest);
1316 EXPECT_EQ(SUCCESS, ret);
1317 }
1318
1319 /**
1320 * @tc.name : Test AudioInterruptService.
1321 * @tc.number: AudioInterruptServiceUnsetAudioManagerInterruptCallback_001
1322 * @tc.desc : Test UnsetAudioManagerInterruptCallback.
1323 */
1324 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceUnsetAudioManagerInterruptCallback_001, TestSize.Level1)
1325 {
1326 sptr<AudioPolicyServer> server = nullptr;
1327 auto interruptServiceTest = GetTnterruptServiceTest();
1328 interruptServiceTest->Init(server);
1329
1330 auto retStatus = interruptServiceTest->UnsetAudioManagerInterruptCallback();
1331 EXPECT_EQ(retStatus, SUCCESS);
1332
1333 interruptServiceTest->handler_ = GetServerHandlerTest();
1334 retStatus = interruptServiceTest->UnsetAudioManagerInterruptCallback();
1335 EXPECT_EQ(retStatus, -62980100);
1336 }
1337
1338 /**
1339 * @tc.name : Test IsAudioSessionActivated API.
1340 * @tc.number: AudioInterruptServiceIsAudioSessionActivated_001
1341 * @tc.desc : Test IsAudioSessionActivated when sessionService_ is not nullptr.
1342 */
1343 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceIsAudioSessionActivated_001, TestSize.Level1)
1344 {
1345 audioInterruptService = GetTnterruptServiceTest();
1346 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1347 EXPECT_NE(nullptr, audioInterruptService);
1348
1349 audioInterruptService->Init(serverTest);
1350 EXPECT_NE(nullptr, audioInterruptService->sessionService_);
1351 int32_t PIT_TEST { -1 };
1352 bool ret = audioInterruptService->IsAudioSessionActivated(PIT_TEST);
1353 EXPECT_FALSE(ret);
1354 }
1355
1356 /**
1357 * @tc.name : Test IsAudioSessionActivated API.
1358 * @tc.number: AudioInterruptServiceIsAudioSessionActivated_002
1359 * @tc.desc : Test IsAudioSessionActivated when sessionService_ is nullptr.
1360 */
1361 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceIsAudioSessionActivated_002, TestSize.Level1)
1362 {
1363 audioInterruptService = GetTnterruptServiceTest();
1364 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1365 EXPECT_NE(nullptr, audioInterruptService);
1366
1367 audioInterruptService->Init(serverTest);
1368 audioInterruptService->sessionService_ = nullptr;
1369 int32_t PIT_TEST { -1 };
1370 bool ret = audioInterruptService->IsAudioSessionActivated(PIT_TEST);
1371 EXPECT_FALSE(ret);
1372 }
1373
1374 /**
1375 * @tc.name : Test CanMixForActiveSession API.
1376 * @tc.number: AudioInterruptServiceCanMixForActiveSession_001
1377 * @tc.desc : Test CanMixForActiveSession when return true.
1378 */
1379 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_001, TestSize.Level1)
1380 {
1381 audioInterruptService = GetTnterruptServiceTest();
1382 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1383 EXPECT_NE(nullptr, audioInterruptService);
1384
1385 audioInterruptService->Init(serverTest);
1386 AudioFocusType audioFocusTypeTest;
1387 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1388 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1389 AudioFocusEntry focusEntry;
1390 AudioSessionStrategy strategy;
1391 strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
1392 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, nullptr);
1393 activeInterrupt.pid = { 0 };
1394 audioInterruptService->sessionService_->sessionMap_.insert({0, audioSession});
1395 focusEntry.actionOn = INCOMING;
1396 bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1397 EXPECT_TRUE(ret);
1398 }
1399
1400 /**
1401 * @tc.name : Test CanMixForActiveSession API.
1402 * @tc.number: AudioInterruptServiceCanMixForActiveSession_002
1403 * @tc.desc : Test CanMixForActiveSession when sessionService_ is nullptr.
1404 */
1405 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_002, TestSize.Level1)
1406 {
1407 audioInterruptService = GetTnterruptServiceTest();
1408 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1409 EXPECT_NE(nullptr, audioInterruptService);
1410
1411 audioInterruptService->Init(serverTest);
1412 AudioFocusType audioFocusTypeTest;
1413 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1414 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1415 AudioFocusEntry focusEntry;
1416 audioInterruptService->sessionService_ = nullptr;
1417 bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1418 EXPECT_FALSE(ret);
1419 }
1420
1421 /**
1422 * @tc.name : Test CanMixForActiveSession API.
1423 * @tc.number: AudioInterruptServiceCanMixForActiveSession_003
1424 * @tc.desc : Test CanMixForActiveSession when IsAudioSessionActivated is true.
1425 */
1426 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_003, TestSize.Level1)
1427 {
1428 audioInterruptService = GetTnterruptServiceTest();
1429 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1430 EXPECT_NE(nullptr, audioInterruptService);
1431
1432 audioInterruptService->Init(serverTest);
1433 AudioFocusType audioFocusTypeTest;
1434 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1435 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1436 activeInterrupt.pid = { -1 };
1437 AudioFocusEntry focusEntry;
1438 bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1439 EXPECT_FALSE(ret);
1440 }
1441
1442 /**
1443 * @tc.name : Test CanMixForActiveSession API.
1444 * @tc.number: AudioInterruptServiceCanMixForActiveSession_004
1445 * @tc.desc : Test CanMixForActiveSession when concurrencyMode is not MIX_WITH_OTHERS.
1446 */
1447 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_004, TestSize.Level1)
1448 {
1449 audioInterruptService = GetTnterruptServiceTest();
1450 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1451 EXPECT_NE(nullptr, audioInterruptService);
1452
1453 audioInterruptService->Init(serverTest);
1454 AudioFocusType audioFocusTypeTest;
1455 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1456 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1457 AudioFocusEntry focusEntry;
1458 AudioSessionStrategy strategy;
1459 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, nullptr);
1460 activeInterrupt.pid = { 0 };
1461 audioInterruptService->sessionService_->sessionMap_.insert({0, audioSession});
1462 std::shared_ptr<AudioSession> activeSession =
1463 audioInterruptService->sessionService_->sessionMap_[activeInterrupt.pid];
1464 activeSession->strategy_.concurrencyMode = AudioConcurrencyMode::DEFAULT;
1465 bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1466 EXPECT_FALSE(ret);
1467 }
1468
1469 /**
1470 * @tc.name : Test CanMixForActiveSession API.
1471 * @tc.number: AudioInterruptServiceCanMixForActiveSession_005
1472 * @tc.desc : Test CanMixForActiveSession when IsActiveStreamLowPriority is true and return false.
1473 */
1474 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_005, TestSize.Level1)
1475 {
1476 audioInterruptService = GetTnterruptServiceTest();
1477 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1478 EXPECT_NE(nullptr, audioInterruptService);
1479
1480 audioInterruptService->Init(serverTest);
1481 AudioFocusType audioFocusTypeTest;
1482 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1483 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1484 AudioFocusEntry focusEntry;
1485 focusEntry.actionOn = CURRENT;
1486 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
1487 AudioSessionStrategy strategy;
1488 strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
1489 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, nullptr);
1490 activeInterrupt.pid = { 0 };
1491 audioInterruptService->sessionService_->sessionMap_.insert({0, audioSession});
1492 incomingInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
1493 activeInterrupt.audioFocusType.streamType = STREAM_MUSIC;
1494 bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1495 EXPECT_FALSE(ret);
1496 }
1497
1498 /**
1499 * @tc.name : Test CanMixForActiveSession API.
1500 * @tc.number: AudioInterruptServiceCanMixForActiveSession_006
1501 * @tc.desc : Test CanMixForActiveSession when IsActiveStreamLowPriority is true and return true.
1502 */
1503 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_006, TestSize.Level1)
1504 {
1505 audioInterruptService = GetTnterruptServiceTest();
1506 audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
1507 EXPECT_NE(nullptr, audioInterruptService);
1508
1509 audioInterruptService->Init(serverTest);
1510 AudioFocusType audioFocusTypeTest;
1511 AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1512 AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
1513 AudioFocusEntry focusEntry;
1514 focusEntry.actionOn = CURRENT;
1515 focusEntry.hintType = INTERRUPT_HINT_PAUSE;
1516 AudioSessionStrategy strategy;
1517 strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
1518 std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, nullptr);
1519 activeInterrupt.pid = { 0 };
1520 audioInterruptService->sessionService_->sessionMap_.insert({0, audioSession});
1521 incomingInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
1522 activeInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
1523 bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1524 EXPECT_TRUE(ret);
1525 }
1526
1527 /**
1528 * @tc.name : Test SendSessionTimeOutStopEvent
1529 * @tc.number: SendSessionTimeOutStopEvent_001
1530 * @tc.desc : Test SendSessionTimeOutStopEvent
1531 */
1532 HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_001, TestSize.Level1)
1533 {
1534 auto interruptServiceTest = GetTnterruptServiceTest();
1535
1536 interruptServiceTest->zonesMap_.clear();
1537 std::shared_ptr<AudioPolicyServerHandler> handler = std::make_shared<AudioPolicyServerHandler>();
1538 interruptServiceTest->SetCallbackHandler(handler);
1539 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1540 AudioFocusType audioFocusTypeTest;
1541 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1542 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
1543 interruptServiceTest->SendSessionTimeOutStopEvent(0, audioInterrupt, audioFocusInfoList);
1544 EXPECT_NE(nullptr, interruptServiceTest->handler_);
1545 }
1546
1547 /**
1548 * @tc.name : Test SendSessionTimeOutStopEvent
1549 * @tc.number: SendSessionTimeOutStopEvent_002
1550 * @tc.desc : Test SendSessionTimeOutStopEvent
1551 */
1552 HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_002, TestSize.Level1)
1553 {
1554 auto interruptServiceTest = GetTnterruptServiceTest();
1555
1556 interruptServiceTest->zonesMap_.clear();
1557 AudioFocusType audioFocusTypeTest;
1558 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1559 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
1560 interruptServiceTest->SendSessionTimeOutStopEvent(0, audioInterrupt, audioFocusInfoList);
1561 EXPECT_EQ(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
1562 }
1563
1564 /**
1565 * @tc.name : Test SendSessionTimeOutStopEvent
1566 * @tc.number: SendSessionTimeOutStopEvent_003
1567 * @tc.desc : Test SendSessionTimeOutStopEvent
1568 */
1569 HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_003, TestSize.Level1)
1570 {
1571 auto interruptServiceTest = GetTnterruptServiceTest();
1572
1573 interruptServiceTest->zonesMap_.clear();
1574 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1575 interruptServiceTest->zonesMap_[1] = nullptr;
1576 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
1577 AudioFocusType audioFocusTypeTest;
1578 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1579 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
1580 interruptServiceTest->SendSessionTimeOutStopEvent(1, audioInterrupt, audioFocusInfoList);
1581 auto it = interruptServiceTest->zonesMap_.find(1);
1582 EXPECT_EQ(nullptr, it->second);
1583 }
1584
1585 /**
1586 * @tc.name : Test SendSessionTimeOutStopEvent
1587 * @tc.number: SendSessionTimeOutStopEvent_004
1588 * @tc.desc : Test SendSessionTimeOutStopEvent
1589 */
1590 HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_004, TestSize.Level1)
1591 {
1592 auto interruptServiceTest = GetTnterruptServiceTest();
1593 std::set<int32_t> pids = {100, 200, 300};
1594
1595 interruptServiceTest->zonesMap_.clear();
1596 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1597 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
1598 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
1599 interruptServiceTest->zonesMap_.find(0)->second->pids = pids;
1600 AudioFocusType audioFocusTypeTest;
1601 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1602 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
1603 interruptServiceTest->SendSessionTimeOutStopEvent(1, audioInterrupt, audioFocusInfoList);
1604 auto it = interruptServiceTest->zonesMap_.find(1);
1605 EXPECT_EQ(it->second->pids.find(100), it->second->pids.end());
1606 }
1607
1608 /**
1609 * @tc.name : Test SendSessionTimeOutStopEvent
1610 * @tc.number: SendSessionTimeOutStopEvent_005
1611 * @tc.desc : Test SendSessionTimeOutStopEvent
1612 */
1613 HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_005, TestSize.Level1)
1614 {
1615 auto interruptServiceTest = GetTnterruptServiceTest();
1616
1617 interruptServiceTest->zonesMap_.clear();
1618 std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
1619 audioInterruptZone->pids = {1, 2, 3};
1620 interruptServiceTest->zonesMap_[0] = audioInterruptZone;
1621 interruptServiceTest->zonesMap_[1] = audioInterruptZone;
1622 AudioFocusType audioFocusTypeTest;
1623 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1624 audioInterrupt.pid = 1;
1625 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
1626 interruptServiceTest->SendSessionTimeOutStopEvent(1, audioInterrupt, audioFocusInfoList);
1627 auto it = interruptServiceTest->zonesMap_.find(1);
1628 EXPECT_EQ(it->second->pids.find(1), it->second->pids.end());
1629 }
1630
1631 /**
1632 * @tc.name : Test AudioInterruptService.
1633 * @tc.number: AudioInterruptService_DeactivateAudioInterruptInternal_001
1634 * @tc.desc : Test DeactivateAudioInterruptInternal.
1635 */
1636 HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInternal_001, TestSize.Level1)
1637 {
1638 auto interruptServiceTest = GetTnterruptServiceTest();
1639 interruptServiceTest->zonesMap_.clear();
1640 AudioInterrupt audioInterrupt;
1641 AudioSessionService audioSessionService;
1642 AudioInterruptService audioInterruptService;
1643 AudioSessionStrategy strategy;
1644
1645 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
1646 EXPECT_EQ(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
1647 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1648 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
1649 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
1650 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
1651 EXPECT_NE(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
1652
1653 bool IS_SESSION_TIMEOUT = true;
1654 interruptServiceTest->sessionService_ = nullptr;
1655 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, IS_SESSION_TIMEOUT);
1656
1657 interruptServiceTest->Init(GetPolicyServerTest());
1658 int32_t ret = interruptServiceTest->ActivateAudioSession(0, strategy);
1659 EXPECT_EQ(SUCCESS, ret);
1660 audioInterrupt.pid = 3;
1661 audioInterrupt.streamId = 3;
1662 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, IS_SESSION_TIMEOUT);
1663 audioInterrupt.pid = 0;
1664 audioInterrupt.streamId = 0;
1665 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, IS_SESSION_TIMEOUT);
1666
1667 audioInterrupt.streamId = 0;
1668 std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, ACTIVE);
1669 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
1670 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
1671 EXPECT_EQ(VALUE_SUCCESS, interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.back().second);
1672
1673 interruptServiceTest->zonesMap_.clear();
1674 }
1675
1676 /**
1677 * @tc.name : Test AudioInterruptService.
1678 * @tc.number: AudioInterruptService_DeactivateAudioInterruptInternal_002
1679 * @tc.desc : Test DeactivateAudioInterruptInternal.
1680 */
1681 HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInternal_002, TestSize.Level1)
1682 {
1683 auto interruptServiceTest = GetTnterruptServiceTest();
1684 interruptServiceTest->zonesMap_.clear();
1685 AudioInterrupt audioInterrupt;
1686 AudioSessionStrategy strategy;
1687
1688 audioInterrupt.pid = 0;
1689 audioInterrupt.streamId = 0;
1690 interruptServiceTest->Init(GetPolicyServerTest());
1691 interruptServiceTest->ActivateAudioSession(0, strategy);
1692 interruptServiceTest->sessionService_ = nullptr;
1693 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1694 std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, ACTIVE);
1695 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
1696 interruptServiceTest->zonesMap_.find(0)->second->pids.insert(1);
1697
1698 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
1699 EXPECT_FALSE(interruptServiceTest->zonesMap_.find(0)->second->pids.find(0) !=
1700 interruptServiceTest->zonesMap_.find(0)->second->pids.end());
1701 interruptServiceTest->zonesMap_.find(0)->second->pids.insert(0);
1702 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
1703 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->pids.find(0) !=
1704 interruptServiceTest->zonesMap_.find(0)->second->pids.end());
1705
1706 interruptServiceTest->zonesMap_.clear();
1707 }
1708
1709 /**
1710 * @tc.name : Test AudioInterruptService.
1711 * @tc.number: AudioInterruptService_UpdateAudioSceneFromInterrupt_002
1712 * @tc.desc : Test UpdateAudioSceneFromInterrupt.
1713 */
1714 HWTEST(AudioInterruptUnitTest, AudioInterruptService_UpdateAudioSceneFromInterrupt_002, TestSize.Level1)
1715 {
1716 auto interruptServiceTest = GetTnterruptServiceTest();
1717 interruptServiceTest->zonesMap_.clear();
1718
1719 interruptServiceTest->Init(GetPolicyServerTest());
1720 AudioInterruptChangeType changeType = DEACTIVATE_AUDIO_INTERRUPT;
1721 interruptServiceTest->UpdateAudioSceneFromInterrupt(AUDIO_SCENE_INVALID, changeType);
1722 EXPECT_EQ(DEACTIVATE_AUDIO_INTERRUPT, changeType);
1723
1724 interruptServiceTest->zonesMap_.clear();
1725 }
1726
1727 /**
1728 * @tc.name : Test AudioInterruptService.
1729 * @tc.number: AudioInterruptService_SendInterruptEvent_001
1730 * @tc.desc : Test SendInterruptEvent.
1731 */
1732 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SendInterruptEvent_001, TestSize.Level1)
1733 {
1734 auto interruptServiceTest = GetTnterruptServiceTest();
1735 interruptServiceTest->zonesMap_.clear();
1736 std::list<std::pair<AudioInterrupt, AudioFocuState>> pairList;
1737 pairList.emplace_back(AudioInterrupt(), AudioFocuState::ACTIVE);
1738 auto it = pairList.begin();
1739 interruptServiceTest->SetCallbackHandler(GetServerHandlerTest());
1740
1741 bool removeFocusInfo;
1742 interruptServiceTest->SendInterruptEvent(ACTIVE, DUCK, it, removeFocusInfo);
1743 EXPECT_NE(interruptServiceTest->handler_, nullptr);
1744
1745 interruptServiceTest->zonesMap_.clear();
1746 }
1747
1748 /**
1749 * @tc.name : Test SendFocusChangeEvent
1750 * @tc.number: SendFocusChangeEvent_001
1751 * @tc.desc : Test SendFocusChangeEvent
1752 */
1753 HWTEST(AudioInterruptUnitTest, SendFocusChangeEvent_001, TestSize.Level1)
1754 {
1755 auto interruptServiceTest = GetTnterruptServiceTest();
1756 AudioFocusType audioFocusTypeTest;
1757 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1758 int32_t callbackCategory = 0;
1759
1760 interruptServiceTest->zonesMap_.clear();
1761 interruptServiceTest->SendFocusChangeEvent(0, callbackCategory, audioInterrupt);
1762 EXPECT_EQ(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
1763 }
1764
1765 /**
1766 * @tc.name : Test SendFocusChangeEvent
1767 * @tc.number: SendFocusChangeEvent_002
1768 * @tc.desc : Test SendFocusChangeEvent
1769 */
1770 HWTEST(AudioInterruptUnitTest, SendFocusChangeEvent_002, TestSize.Level1)
1771 {
1772 auto interruptServiceTest = GetTnterruptServiceTest();
1773 AudioFocusType audioFocusTypeTest;
1774 AudioInterrupt audioInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, 0);
1775 int32_t callbackCategory = 0;
1776
1777 interruptServiceTest->zonesMap_.clear();
1778 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1779 interruptServiceTest->zonesMap_[1] = nullptr;
1780 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
1781 interruptServiceTest->SendFocusChangeEvent(1, callbackCategory, audioInterrupt);
1782 auto it = interruptServiceTest->zonesMap_.find(1);
1783 EXPECT_EQ(nullptr, it->second);
1784 EXPECT_NE(interruptServiceTest->zonesMap_.find(1), interruptServiceTest->zonesMap_.end());
1785 }
1786
1787 /**
1788 * @tc.name : Test AudioInterruptService.
1789 * @tc.number: AudioInterruptServiceCreateAudioInterruptZone_001
1790 * @tc.desc : Test RCreateAudioInterruptZone.
1791 */
1792 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCreateAudioInterruptZone_001, TestSize.Level1)
1793 {
1794 sptr<AudioPolicyServer> server = nullptr;
1795 auto interruptServiceTest = GetTnterruptServiceTest();
1796 interruptServiceTest->Init(server);
1797
1798 SetUid1041();
1799 auto retStatus = interruptServiceTest->CreateAudioInterruptZone(-1);
1800 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
1801
1802 SetUid1041();
1803 retStatus = interruptServiceTest->CreateAudioInterruptZone(0);
1804 EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
1805
1806 SetUid1041();
1807 retStatus = interruptServiceTest->CreateAudioInterruptZone(2);
1808 EXPECT_EQ(retStatus, SUCCESS);
1809 }
1810
1811 /**
1812 * @tc.name : Test MigrateAudioInterruptZone
1813 * @tc.number: MigrateAudioInterruptZone_001
1814 * @tc.desc : Test MigrateAudioInterruptZone
1815 */
1816 HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_001, TestSize.Level1)
1817 {
1818 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
1819 server->interruptService_ = std::make_shared<AudioInterruptService>();
1820 server->interruptService_->Init(server);
1821 auto interruptServiceTest = server->interruptService_;
1822
1823 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anonc16f3c580302(int32_t uid, const std::string &deviceTag, const std::string &streamTag)1824 const std::string &streamTag)->int32_t {
1825 return 1;
1826 };
1827
1828 SetUid1041();
1829 interruptServiceTest->zonesMap_.clear();
1830 int32_t signal = interruptServiceTest->MigrateAudioInterruptZone(0, getZoneFunc);
1831 EXPECT_EQ(ERR_INVALID_PARAM, signal);
1832 signal = interruptServiceTest->MigrateAudioInterruptZone(0, nullptr);
1833 EXPECT_EQ(ERR_INVALID_PARAM, signal);
1834 }
1835
1836 /**
1837 * @tc.name : Test MigrateAudioInterruptZone
1838 * @tc.number: MigrateAudioInterruptZone_003
1839 * @tc.desc : Test MigrateAudioInterruptZone
1840 */
1841 HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_003, TestSize.Level1)
1842 {
1843 auto interruptServiceTest = GetTnterruptServiceTest();
1844
1845 auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
__anonc16f3c580402(int32_t uid, const std::string &deviceTag, const std::string &streamTag)1846 const std::string &streamTag)->int32_t {
1847 return 1;
1848 };
1849
1850 SetUid1041();
1851 interruptServiceTest->zonesMap_.clear();
1852 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1853 interruptServiceTest->zonesMap_[1] = nullptr;
1854 interruptServiceTest->zonesMap_[2] = std::make_shared<AudioInterruptZone>();
1855 auto signal = interruptServiceTest->MigrateAudioInterruptZone(1, getZoneFunc);
1856 EXPECT_NE(interruptServiceTest->zonesMap_.find(1), interruptServiceTest->zonesMap_.end());
1857 EXPECT_EQ(ERR_INVALID_PARAM, signal);
1858 }
1859
AddMovieInterruptToList(AudioFocusList & list,int32_t streamId,int32_t uid,AudioFocuState state,const std::string & deviceTag="")1860 static void AddMovieInterruptToList(AudioFocusList &list, int32_t streamId, int32_t uid,
1861 AudioFocuState state, const std::string &deviceTag = "")
1862 {
1863 AudioInterrupt interrupt;
1864 interrupt.streamUsage = STREAM_USAGE_MOVIE;
1865 interrupt.audioFocusType.streamType = STREAM_MOVIE;
1866 interrupt.streamId = streamId;
1867 interrupt.uid = uid;
1868 interrupt.deviceTag = deviceTag;
1869 list.emplace_back(std::make_pair(interrupt, state));
1870 }
1871
AddMusicInterruptToList(AudioFocusList & list,int32_t streamId,int32_t uid,AudioFocuState state,const std::string & deviceTag="")1872 static void AddMusicInterruptToList(AudioFocusList &list, int32_t streamId, int32_t uid,
1873 AudioFocuState state, const std::string &deviceTag = "")
1874 {
1875 AudioInterrupt interrupt;
1876 interrupt.streamUsage = STREAM_USAGE_MUSIC;
1877 interrupt.audioFocusType.streamType = STREAM_MUSIC;
1878 interrupt.streamId = streamId;
1879 interrupt.uid = uid;
1880 interrupt.deviceTag = deviceTag;
1881 list.emplace_back(std::make_pair(interrupt, state));
1882 }
1883
AddVoipInterruptToList(AudioFocusList & list,int32_t streamId,int32_t uid,AudioFocuState state,const std::string & deviceTag="")1884 static void AddVoipInterruptToList(AudioFocusList &list, int32_t streamId, int32_t uid,
1885 AudioFocuState state, const std::string &deviceTag = "")
1886 {
1887 AudioInterrupt interrupt;
1888 interrupt.streamUsage = STREAM_USAGE_VOICE_COMMUNICATION;
1889 interrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
1890 interrupt.streamId = streamId;
1891 interrupt.uid = uid;
1892 interrupt.deviceTag = deviceTag;
1893 list.emplace_back(std::make_pair(interrupt, state));
1894 }
1895
1896 /**
1897 * @tc.name : Test InjectInterruptToAudiotZone
1898 * @tc.number: InjectInterruptToAudiotZone_001
1899 * @tc.desc : Test InjectInterruptToAudiotZone
1900 */
1901 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudiotZone_001, TestSize.Level1)
1902 {
1903 auto interruptServiceTest = GetTnterruptServiceTest();
1904 AudioFocusList interrupts;
1905 interruptServiceTest->zonesMap_.clear();
1906 auto ret = interruptServiceTest->InjectInterruptToAudiotZone(0, interrupts);
1907 EXPECT_EQ(ERR_INVALID_PARAM, ret);
1908 }
1909
1910 /**
1911 * @tc.name : Test InjectInterruptToAudiotZone
1912 * @tc.number: InjectInterruptToAudiotZone_002
1913 * @tc.desc : Test InjectInterruptToAudiotZone
1914 */
1915 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudiotZone_002, TestSize.Level1)
1916 {
1917 auto interruptServiceTest = GetTnterruptServiceTest();
1918 AudioFocusList interrupts;
1919
1920 interruptServiceTest->zonesMap_.clear();
1921 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1922 interruptServiceTest->zonesMap_[1] = nullptr;
1923
1924 SetUid1041();
1925 auto ret = interruptServiceTest->InjectInterruptToAudiotZone(2, interrupts);
1926 EXPECT_EQ(ERR_INVALID_PARAM, ret);
1927 SetUid1041();
1928 ret = interruptServiceTest->InjectInterruptToAudiotZone(1, interrupts);
1929 EXPECT_EQ(ERR_INVALID_PARAM, ret);
1930 }
1931
1932 /**
1933 * @tc.name : Test InjectInterruptToAudiotZone
1934 * @tc.number: InjectInterruptToAudiotZone_004
1935 * @tc.desc : Test InjectInterruptToAudiotZone
1936 */
1937 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudiotZone_004, TestSize.Level1)
1938 {
1939 auto interruptServiceTest = GetTnterruptServiceTest();
1940 AudioFocusList interrupts;
1941 interruptServiceTest->zonesMap_.clear();
1942 auto ret = interruptServiceTest->InjectInterruptToAudiotZone(0, "", interrupts);
1943 EXPECT_EQ(ERR_INVALID_PARAM, ret);
1944 }
1945
1946 /**
1947 * @tc.name : Test InjectInterruptToAudiotZone
1948 * @tc.number: InjectInterruptToAudiotZone_005
1949 * @tc.desc : Test InjectInterruptToAudiotZone
1950 */
1951 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudiotZone_005, TestSize.Level1)
1952 {
1953 auto interruptServiceTest = GetTnterruptServiceTest();
1954 AudioFocusList interrupts;
1955
1956 interruptServiceTest->zonesMap_.clear();
1957 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1958 interruptServiceTest->zonesMap_[1] = nullptr;
1959
1960 SetUid1041();
1961 auto ret = interruptServiceTest->InjectInterruptToAudiotZone(2, "", interrupts);
1962 EXPECT_EQ(ERR_INVALID_PARAM, ret);
1963 SetUid1041();
1964 ret = interruptServiceTest->InjectInterruptToAudiotZone(1, "", interrupts);
1965 EXPECT_EQ(ERR_INVALID_PARAM, ret);
1966 }
1967
1968 /**
1969 * @tc.name : Test InjectInterruptToAudiotZone
1970 * @tc.number: InjectInterruptToAudiotZone_006
1971 * @tc.desc : Test InjectInterruptToAudiotZone
1972 */
1973 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudiotZone_006, TestSize.Level1)
1974 {
1975 auto interruptServiceTest = GetTnterruptServiceTest();
1976 AudioFocusList interrupts;
1977
1978 interruptServiceTest->zonesMap_.clear();
1979 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
1980 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
1981
1982 SetUid1041();
1983 auto ret = interruptServiceTest->InjectInterruptToAudiotZone(1, "", interrupts);
1984 EXPECT_EQ(ERR_INVALID_PARAM, ret);
1985 }
1986
1987 /**
1988 * @tc.name : Test InjectInterruptToAudiotZone
1989 * @tc.number: InjectInterruptToAudiotZone_008
1990 * @tc.desc : Test InjectInterruptToAudiotZone
1991 */
1992 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudiotZone_008, TestSize.Level1)
1993 {
1994 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
1995 server->interruptService_ = std::make_shared<AudioInterruptService>();
1996 server->interruptService_->Init(server);
1997 auto interruptServiceTest = server->interruptService_;
1998 AudioFocusList interrupts;
1999
2000 SetUid1041();
2001 interruptServiceTest->zonesMap_.clear();
2002 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2003 auto &focusList = interruptServiceTest->zonesMap_[0]->audioFocusInfoList;
2004 AddMovieInterruptToList(focusList, 0, 1, AudioFocuState::PAUSE);
2005 AddVoipInterruptToList(focusList, 1, 2, AudioFocuState::ACTIVE);
2006 AddMusicInterruptToList(focusList, 2, 3, AudioFocuState::DUCK);
2007
2008 AddMovieInterruptToList(interrupts, 0, 1, AudioFocuState::PAUSE);
2009 AddMusicInterruptToList(interrupts, 2, 3, AudioFocuState::ACTIVE);
2010
2011 EXPECT_NO_THROW(
2012 interruptServiceTest->InjectInterruptToAudiotZone(0, interrupts);
2013 );
2014 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 2);
2015 }
2016
2017 /**
2018 * @tc.name : Test InjectInterruptToAudiotZone
2019 * @tc.number: InjectInterruptToAudiotZone_009
2020 * @tc.desc : Test InjectInterruptToAudiotZone
2021 */
2022 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudiotZone_009, TestSize.Level1)
2023 {
2024 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
2025 server->interruptService_ = std::make_shared<AudioInterruptService>();
2026 server->interruptService_->Init(server);
2027 auto interruptServiceTest = server->interruptService_;
2028 AudioFocusList interrupts;
2029
2030 interruptServiceTest->zonesMap_.clear();
2031 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2032 auto &focusList = interruptServiceTest->zonesMap_[0]->audioFocusInfoList;
2033 AddMovieInterruptToList(focusList, 0, 1, AudioFocuState::PAUSE);
2034 AddVoipInterruptToList(focusList, 1, 2, AudioFocuState::ACTIVE, "test");
2035 AddMusicInterruptToList(focusList, 2, 3, AudioFocuState::DUCK, "test");
2036
2037 AddMusicInterruptToList(interrupts, 2, 3, AudioFocuState::ACTIVE, "test");
2038
2039 SetUid1041();
2040 EXPECT_NO_THROW(
2041 interruptServiceTest->InjectInterruptToAudiotZone(0, "test", interrupts);
2042 );
2043 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 2);
2044 }
2045
2046 /**
2047 * @tc.name : Test InjectInterruptToAudiotZone
2048 * @tc.number: InjectInterruptToAudiotZone_010
2049 * @tc.desc : Test InjectInterruptToAudiotZone
2050 */
2051 HWTEST(AudioInterruptUnitTest, InjectInterruptToAudiotZone_010, TestSize.Level1)
2052 {
2053 sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
2054 server->interruptService_ = std::make_shared<AudioInterruptService>();
2055 server->interruptService_->Init(server);
2056 auto interruptServiceTest = server->interruptService_;
2057 AudioFocusList interrupts;
2058
2059 interruptServiceTest->zonesMap_.clear();
2060 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2061 auto &focusList = interruptServiceTest->zonesMap_[0]->audioFocusInfoList;
2062 AddMovieInterruptToList(focusList, 0, 1, AudioFocuState::PAUSE);
2063 AddVoipInterruptToList(focusList, 1, 2, AudioFocuState::ACTIVE, "test");
2064 AddMusicInterruptToList(focusList, 2, 3, AudioFocuState::DUCK, "test");
2065
2066 AddMusicInterruptToList(interrupts, 2, 3, AudioFocuState::PLACEHOLDER, "test");
2067 AddMovieInterruptToList(interrupts, 3, 4, AudioFocuState::ACTIVE, "test");
2068
2069 SetUid1041();
2070 EXPECT_NO_THROW(
2071 interruptServiceTest->InjectInterruptToAudiotZone(0, "test", interrupts);
2072 );
2073 EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 1);
2074 }
2075
2076 /**
2077 * @tc.name : Test AudioInterruptService.
2078 * @tc.number: AudioInterruptService_SimulateFocusEntry_001
2079 * @tc.desc : Test SimulateFocusEntry.
2080 */
2081 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_001, TestSize.Level1)
2082 {
2083 auto interruptServiceTest = GetTnterruptServiceTest();
2084 interruptServiceTest->zonesMap_.clear();
2085 AudioInterrupt audioInterrupt;
2086
2087 interruptServiceTest->SimulateFocusEntry(0);
2088 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0) == interruptServiceTest->zonesMap_.end());
2089
2090 interruptServiceTest->zonesMap_[0] = nullptr;
2091 interruptServiceTest->SimulateFocusEntry(0);
2092 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second == nullptr);
2093
2094 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2095 std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, ACTIVE);
2096 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
2097 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->first.mode = SHARE_MODE;
2098 interruptServiceTest->SimulateFocusEntry(0);
2099 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.back().first.mode == SHARE_MODE);
2100
2101 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->first.mode = INDEPENDENT_MODE;
2102 interruptServiceTest->SimulateFocusEntry(0);
2103 EXPECT_FALSE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.back().first.mode == SHARE_MODE);
2104
2105 interruptServiceTest->zonesMap_.clear();
2106 }
2107
2108 /**
2109 * @tc.name : Test AudioInterruptService.
2110 * @tc.number: AudioInterruptService_SimulateFocusEntry_002
2111 * @tc.desc : Test SimulateFocusEntry.
2112 */
2113 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_002, TestSize.Level1)
2114 {
2115 auto interruptServiceTest = GetTnterruptServiceTest();
2116 interruptServiceTest->zonesMap_.clear();
2117 AudioInterrupt audioInterrupt;
2118 AudioInterruptService audioInterruptService;
2119
2120 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2121 std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, PAUSE);
2122 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
2123 interruptServiceTest->SimulateFocusEntry(0);
2124 EXPECT_FALSE(interruptServiceTest->zonesMap_.find(0)->second == nullptr);
2125
2126 interruptServiceTest->zonesMap_.clear();
2127 }
2128
2129 /**
2130 * @tc.name : Test AudioInterruptService.
2131 * @tc.number: AudioInterruptService_SimulateFocusEntry_003
2132 * @tc.desc : Test SimulateFocusEntry.
2133 */
2134 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_003, TestSize.Level1)
2135 {
2136 auto interruptServiceTest = GetTnterruptServiceTest();
2137 interruptServiceTest->zonesMap_.clear();
2138 AudioInterrupt audioInterrupt;
2139 AudioInterruptService audioInterruptService;
2140
2141 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2142 std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, PLACEHOLDER);
2143 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
2144 interruptServiceTest->SimulateFocusEntry(0);
2145 EXPECT_FALSE(interruptServiceTest->zonesMap_.find(0)->second == nullptr);
2146
2147 interruptServiceTest->zonesMap_.clear();
2148 }
2149
2150 /**
2151 * @tc.name : Test AudioInterruptService.
2152 * @tc.number: AudioInterruptService_SimulateFocusEntry_004
2153 * @tc.desc : Test SimulateFocusEntry.
2154 */
2155 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_004, TestSize.Level1)
2156 {
2157 auto interruptServiceTest = GetTnterruptServiceTest();
2158 interruptServiceTest->zonesMap_.clear();
2159 AudioInterrupt audioInterrupt;
2160
2161 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2162 std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, PAUSE);
2163 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
2164
2165 std::pair<AudioFocusType, AudioFocusType> audioFocusTypePair = std::make_pair(
2166 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->first.audioFocusType,
2167 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->first.audioFocusType
2168 );
2169 interruptServiceTest->focusCfgMap_[audioFocusTypePair] = {};
2170
2171 interruptServiceTest->SimulateFocusEntry(0);
2172 EXPECT_FALSE(interruptServiceTest->zonesMap_.find(0)->second == nullptr);
2173
2174 interruptServiceTest->zonesMap_.clear();
2175 interruptServiceTest->focusCfgMap_.clear();
2176 }
2177
2178 /**
2179 * @tc.name : Test AudioInterruptService.
2180 * @tc.number: AudioInterruptService_SimulateFocusEntry_005
2181 * @tc.desc : Test SimulateFocusEntry.
2182 */
2183 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_005, TestSize.Level1)
2184 {
2185 auto interruptServiceTest = GetTnterruptServiceTest();
2186 interruptServiceTest->zonesMap_.clear();
2187
2188 interruptServiceTest->zonesMap_[0] = nullptr;
2189 interruptServiceTest->SimulateFocusEntry(1);
2190 EXPECT_EQ(interruptServiceTest->zonesMap_.find(1), interruptServiceTest->zonesMap_.end());
2191
2192 interruptServiceTest->SimulateFocusEntry(0);
2193 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second == nullptr);
2194
2195 interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
2196 interruptServiceTest->SimulateFocusEntry(1);
2197 AudioInterrupt interrupt;
2198 interruptServiceTest->zonesMap_.find(1)->second->audioFocusInfoList.emplace_back(
2199 std::make_pair(interrupt, STOP));
2200 EXPECT_FALSE(interruptServiceTest->zonesMap_.find(1)->second->audioFocusInfoList.empty());
2201
2202 interruptServiceTest->zonesMap_.clear();
2203 }
2204
2205 /**
2206 * @tc.name : Test AudioInterruptService.
2207 * @tc.number: AudioInterruptService_SimulateFocusEntry_006
2208 * @tc.desc : Test SimulateFocusEntry.
2209 */
2210 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_006, TestSize.Level1)
2211 {
2212 auto interruptServiceTest = GetTnterruptServiceTest();
2213 interruptServiceTest->zonesMap_.clear();
2214
2215 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2216 AudioInterrupt interrupt_1;
2217 AudioInterrupt interrupt_2;
2218
2219 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2220 std::make_pair(interrupt_1, PLACEHOLDER));
2221 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2222 std::make_pair(interrupt_2, PLACEHOLDER));
2223 interruptServiceTest->SimulateFocusEntry(0);
2224 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2225
2226 interruptServiceTest->zonesMap_.clear();
2227 }
2228
2229 /**
2230 * @tc.name : Test AudioInterruptService.
2231 * @tc.number: AudioInterruptService_SimulateFocusEntry_007
2232 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is true.
2233 */
2234 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_007, TestSize.Level1)
2235 {
2236 auto interruptServiceTest = GetTnterruptServiceTest();
2237 interruptServiceTest->zonesMap_.clear();
2238
2239 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2240 AudioInterrupt interrupt_1;
2241 AudioInterrupt interrupt_2;
2242
2243 interrupt_1.mode = SHARE_MODE;
2244 interrupt_1.pid = 0;
2245 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2246 std::make_pair(interrupt_1, ACTIVE));
2247
2248 interrupt_2.mode = SHARE_MODE;
2249 interrupt_2.pid = 0;
2250 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2251 std::make_pair(interrupt_2, PLACEHOLDER));
2252
2253 interruptServiceTest->SimulateFocusEntry(0);
2254 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2255 interruptServiceTest->zonesMap_.clear();
2256 }
2257
2258 /**
2259 * @tc.name : Test AudioInterruptService.
2260 * @tc.number: AudioInterruptService_SimulateFocusEntry_008
2261 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is true.
2262 */
2263 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_008, TestSize.Level1)
2264 {
2265 auto interruptServiceTest = GetTnterruptServiceTest();
2266 interruptServiceTest->zonesMap_.clear();
2267 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2268 AudioInterrupt interrupt_1;
2269 AudioInterrupt interrupt_2;
2270
2271 interrupt_1.mode = SHARE_MODE;
2272 interrupt_1.pid = 0;
2273 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2274 std::make_pair(interrupt_1, PLACEHOLDER));
2275
2276 interrupt_2.mode = SHARE_MODE;
2277 interrupt_2.pid = 0;
2278 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2279 std::make_pair(interrupt_2, PLACEHOLDER));
2280
2281 interruptServiceTest->SimulateFocusEntry(0);
2282 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2283 interruptServiceTest->zonesMap_.clear();
2284 }
2285
2286 /**
2287 * @tc.name : Test AudioInterruptService.
2288 * @tc.number: AudioInterruptService_SimulateFocusEntry_009
2289 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2290 */
2291 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_009, TestSize.Level1)
2292 {
2293 auto interruptServiceTest = GetTnterruptServiceTest();
2294 interruptServiceTest->zonesMap_.clear();
2295 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2296 AudioInterrupt interrupt_1;
2297 AudioInterrupt interrupt_2;
2298
2299 interrupt_1.mode = SHARE_MODE;
2300 interrupt_1.pid = 0;
2301 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2302 std::make_pair(interrupt_1, PLACEHOLDER));
2303
2304 interrupt_2.mode = SHARE_MODE;
2305 interrupt_2.pid = 1;
2306 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2307 std::make_pair(interrupt_2, PLACEHOLDER));
2308
2309 interruptServiceTest->SimulateFocusEntry(0);
2310 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2311 interruptServiceTest->zonesMap_.clear();
2312 }
2313
2314 /**
2315 * @tc.name : Test AudioInterruptService.
2316 * @tc.number: AudioInterruptService_SimulateFocusEntry_010
2317 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2318 */
2319 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_010, TestSize.Level1)
2320 {
2321 auto interruptServiceTest = GetTnterruptServiceTest();
2322 interruptServiceTest->zonesMap_.clear();
2323 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2324 AudioInterrupt interrupt_1;
2325 AudioInterrupt interrupt_2;
2326
2327 interrupt_1.mode = SHARE_MODE;
2328 interrupt_1.pid = 0;
2329 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2330 std::make_pair(interrupt_1, ACTIVE));
2331
2332 interrupt_2.mode = SHARE_MODE;
2333 interrupt_2.pid = 1;
2334 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2335 std::make_pair(interrupt_2, PLACEHOLDER));
2336
2337 interruptServiceTest->SimulateFocusEntry(0);
2338 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2339 interruptServiceTest->zonesMap_.clear();
2340 }
2341
2342 /**
2343 * @tc.name : Test AudioInterruptService.
2344 * @tc.number: AudioInterruptService_SimulateFocusEntry_011
2345 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2346 */
2347 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_011, TestSize.Level1)
2348 {
2349 auto interruptServiceTest = GetTnterruptServiceTest();
2350 interruptServiceTest->zonesMap_.clear();
2351 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2352 AudioInterrupt interrupt_1;
2353 AudioInterrupt interrupt_2;
2354
2355 interrupt_1.mode = SHARE_MODE;
2356 interrupt_1.pid = -1;
2357 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2358 std::make_pair(interrupt_1, PLACEHOLDER));
2359
2360 interrupt_2.mode = SHARE_MODE;
2361 interrupt_2.pid = 1;
2362 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2363 std::make_pair(interrupt_2, PLACEHOLDER));
2364
2365 interruptServiceTest->SimulateFocusEntry(0);
2366 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2367 interruptServiceTest->zonesMap_.clear();
2368 }
2369
2370 /**
2371 * @tc.name : Test AudioInterruptService.
2372 * @tc.number: AudioInterruptService_SimulateFocusEntry_012
2373 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2374 */
2375 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_012, TestSize.Level1)
2376 {
2377 auto interruptServiceTest = GetTnterruptServiceTest();
2378 interruptServiceTest->zonesMap_.clear();
2379 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2380 AudioInterrupt interrupt_1;
2381 AudioInterrupt interrupt_2;
2382
2383 interrupt_1.mode = SHARE_MODE;
2384 interrupt_1.pid = -1;
2385 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2386 std::make_pair(interrupt_1, ACTIVE));
2387
2388 interrupt_2.mode = SHARE_MODE;
2389 interrupt_2.pid = 1;
2390 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2391 std::make_pair(interrupt_2, PLACEHOLDER));
2392
2393 interruptServiceTest->SimulateFocusEntry(0);
2394 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2395 interruptServiceTest->zonesMap_.clear();
2396 }
2397
2398 /**
2399 * @tc.name : Test AudioInterruptService.
2400 * @tc.number: AudioInterruptService_SimulateFocusEntry_013
2401 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2402 */
2403 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_013, TestSize.Level1)
2404 {
2405 auto interruptServiceTest = GetTnterruptServiceTest();
2406 interruptServiceTest->zonesMap_.clear();
2407 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2408 AudioInterrupt interrupt_1;
2409 AudioInterrupt interrupt_2;
2410
2411 interrupt_1.mode = SHARE_MODE;
2412 interrupt_1.pid = 1;
2413 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2414 std::make_pair(interrupt_1, PLACEHOLDER));
2415
2416 interrupt_2.mode = SHARE_MODE;
2417 interrupt_2.pid = -1;
2418 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2419 std::make_pair(interrupt_2, PLACEHOLDER));
2420
2421 interruptServiceTest->SimulateFocusEntry(0);
2422 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2423 interruptServiceTest->zonesMap_.clear();
2424 }
2425
2426 /**
2427 * @tc.name : Test AudioInterruptService.
2428 * @tc.number: AudioInterruptService_SimulateFocusEntry_014
2429 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2430 */
2431 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_014, TestSize.Level1)
2432 {
2433 auto interruptServiceTest = GetTnterruptServiceTest();
2434 interruptServiceTest->zonesMap_.clear();
2435 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2436 AudioInterrupt interrupt_1;
2437 AudioInterrupt interrupt_2;
2438
2439 interrupt_1.mode = SHARE_MODE;
2440 interrupt_1.pid = 1;
2441 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2442 std::make_pair(interrupt_1, ACTIVE));
2443
2444 interrupt_2.mode = SHARE_MODE;
2445 interrupt_2.pid = -1;
2446 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2447 std::make_pair(interrupt_2, PLACEHOLDER));
2448
2449 interruptServiceTest->SimulateFocusEntry(0);
2450 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2451 interruptServiceTest->zonesMap_.clear();
2452 }
2453
2454 /**
2455 * @tc.name : Test AudioInterruptService.
2456 * @tc.number: AudioInterruptService_SimulateFocusEntry_015
2457 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2458 */
2459 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_015, TestSize.Level1)
2460 {
2461 auto interruptServiceTest = GetTnterruptServiceTest();
2462 interruptServiceTest->zonesMap_.clear();
2463 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2464 AudioInterrupt interrupt_1;
2465 AudioInterrupt interrupt_2;
2466
2467 interrupt_1.mode = INDEPENDENT_MODE;
2468 interrupt_1.pid = 1;
2469 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2470 std::make_pair(interrupt_1, ACTIVE));
2471
2472 interrupt_2.mode = SHARE_MODE;
2473 interrupt_2.pid = 1;
2474 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2475 std::make_pair(interrupt_2, PLACEHOLDER));
2476
2477 interruptServiceTest->SimulateFocusEntry(0);
2478 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2479 interruptServiceTest->zonesMap_.clear();
2480 }
2481
2482 /**
2483 * @tc.name : Test AudioInterruptService.
2484 * @tc.number: AudioInterruptService_SimulateFocusEntry_016
2485 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2486 */
2487 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_016, TestSize.Level1)
2488 {
2489 auto interruptServiceTest = GetTnterruptServiceTest();
2490 interruptServiceTest->zonesMap_.clear();
2491 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2492 AudioInterrupt interrupt_1;
2493 AudioInterrupt interrupt_2;
2494
2495 interrupt_1.mode = INDEPENDENT_MODE;
2496 interrupt_1.pid = 1;
2497 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2498 std::make_pair(interrupt_1, PLACEHOLDER));
2499
2500 interrupt_2.mode = SHARE_MODE;
2501 interrupt_2.pid = 1;
2502 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2503 std::make_pair(interrupt_2, PLACEHOLDER));
2504
2505 interruptServiceTest->SimulateFocusEntry(0);
2506 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2507 interruptServiceTest->zonesMap_.clear();
2508 }
2509
2510 /**
2511 * @tc.name : Test AudioInterruptService.
2512 * @tc.number: AudioInterruptService_SimulateFocusEntry_017
2513 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2514 */
2515 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_017, TestSize.Level1)
2516 {
2517 auto interruptServiceTest = GetTnterruptServiceTest();
2518 interruptServiceTest->zonesMap_.clear();
2519 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2520 AudioInterrupt interrupt_1;
2521 AudioInterrupt interrupt_2;
2522
2523 interrupt_1.mode = SHARE_MODE;
2524 interrupt_1.pid = 1;
2525 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2526 std::make_pair(interrupt_1, ACTIVE));
2527
2528 interrupt_2.mode = INDEPENDENT_MODE;
2529 interrupt_2.pid = 1;
2530 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2531 std::make_pair(interrupt_2, PLACEHOLDER));
2532
2533 interruptServiceTest->SimulateFocusEntry(0);
2534 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2535 interruptServiceTest->zonesMap_.clear();
2536 }
2537
2538 /**
2539 * @tc.name : Test AudioInterruptService.
2540 * @tc.number: AudioInterruptService_SimulateFocusEntry_018
2541 * @tc.desc : Test SimulateFocusEntry and IsSameAppInShareMode is false.
2542 */
2543 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_018, TestSize.Level1)
2544 {
2545 auto interruptServiceTest = GetTnterruptServiceTest();
2546 interruptServiceTest->zonesMap_.clear();
2547 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2548 AudioInterrupt interrupt_1;
2549 AudioInterrupt interrupt_2;
2550
2551 interrupt_1.mode = SHARE_MODE;
2552 interrupt_1.pid = 1;
2553 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2554 std::make_pair(interrupt_1, PLACEHOLDER));
2555
2556 interrupt_2.mode = INDEPENDENT_MODE;
2557 interrupt_2.pid = 1;
2558 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2559 std::make_pair(interrupt_2, PLACEHOLDER));
2560
2561 interruptServiceTest->SimulateFocusEntry(0);
2562 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == PLACEHOLDER);
2563 interruptServiceTest->zonesMap_.clear();
2564 }
2565
2566 /**
2567 * @tc.name : Test AudioInterruptService.
2568 * @tc.number: AudioInterruptService_SimulateFocusEntry_019
2569 * @tc.desc : Test SimulateFocusEntry.
2570 */
2571 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_019, TestSize.Level1)
2572 {
2573 auto interruptServiceTest = GetTnterruptServiceTest();
2574 interruptServiceTest->zonesMap_.clear();
2575 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2576 AudioInterrupt interrupt_1;
2577 AudioInterrupt interrupt_2;
2578
2579 interrupt_1.mode = SHARE_MODE;
2580 interrupt_1.pid = 0;
2581 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2582 std::make_pair(interrupt_1, ACTIVE));
2583
2584 interrupt_2.mode = SHARE_MODE;
2585 interrupt_2.pid = 1;
2586 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(
2587 std::make_pair(interrupt_2, PLACEHOLDER));
2588
2589 interruptServiceTest->SimulateFocusEntry(0);
2590 EXPECT_TRUE(interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.begin()->second == ACTIVE);
2591 interruptServiceTest->zonesMap_.clear();
2592 }
2593
2594 /**
2595 * @tc.name : Test SimulateFocusEntry
2596 * @tc.number: AudioInterruptService_SimulateFocusEntry_020
2597 * @tc.desc : Test SimulateFocusEntry
2598 */
2599 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_020, TestSize.Level1)
2600 {
2601 auto interruptServiceTest = GetTnterruptServiceTest();
2602 interruptServiceTest->zonesMap_.clear();
2603
2604 AudioInterrupt interruptTest;
2605 interruptTest.mode = INDEPENDENT_MODE;
2606 interruptTest.pid = 0;
2607 std::pair<AudioInterrupt, AudioFocuState> audioFocusTypePair;
2608 audioFocusTypePair.first = interruptTest;
2609 audioFocusTypePair.second = PLACEHOLDER;
2610 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2611 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2612 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2613
2614 auto ret = interruptServiceTest->SimulateFocusEntry(0);
2615 EXPECT_EQ(PLACEHOLDER, ret.begin()->second);
2616 }
2617
2618 /**
2619 * @tc.name : Test SimulateFocusEntry
2620 * @tc.number: AudioInterruptService_SimulateFocusEntry_021
2621 * @tc.desc : Test SimulateFocusEntry
2622 */
2623 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_021, TestSize.Level1)
2624 {
2625 auto interruptServiceTest = GetTnterruptServiceTest();
2626 interruptServiceTest->zonesMap_.clear();
2627
2628 AudioInterrupt interruptTest;
2629 interruptTest.mode = SHARE_MODE;
2630 interruptTest.pid = 0;
2631 std::pair<AudioInterrupt, AudioFocuState> audioFocusTypePair;
2632 audioFocusTypePair.first = interruptTest;
2633 audioFocusTypePair.second = ACTIVE;
2634 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2635 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2636 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2637
2638 auto ret = interruptServiceTest->SimulateFocusEntry(0);
2639 auto it = ret.begin();
2640 EXPECT_EQ(SHARE_MODE, it->first.mode);
2641 EXPECT_NE(-1, it->first.pid);
2642 std::advance(it, 1);
2643 EXPECT_EQ(SHARE_MODE, it->first.mode);
2644 EXPECT_NE(-1, it->first.pid);
2645 EXPECT_EQ(ret.begin()->first.pid, it->first.pid);
2646 }
2647
2648 /**
2649 * @tc.name : Test SimulateFocusEntry
2650 * @tc.number: AudioInterruptService_SimulateFocusEntry_022
2651 * @tc.desc : Test SimulateFocusEntry
2652 */
2653 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_022, TestSize.Level1)
2654 {
2655 auto interruptServiceTest = GetTnterruptServiceTest();
2656 interruptServiceTest->zonesMap_.clear();
2657 interruptServiceTest->focusCfgMap_.clear();
2658
2659
2660 AudioInterrupt interruptTest;
2661 interruptTest.mode = SHARE_MODE;
2662 interruptTest.pid = 0;
2663 std::pair<AudioInterrupt, AudioFocuState> audioFocusTypePair;
2664 audioFocusTypePair.first = interruptTest;
2665 audioFocusTypePair.second = ACTIVE;
2666 audioFocusTypePair.first.audioFocusType.streamType = STREAM_VOICE_CALL;
2667 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2668 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2669
2670 std::pair<AudioFocusType, AudioFocusType> focusTypePair;
2671 AudioFocusEntry FocusEntryTest;
2672 FocusEntryTest.isReject = false;
2673 FocusEntryTest.hintType = static_cast<InterruptHint>(INTERRUPT_HINT_ERROR);
2674 focusTypePair.first.streamType = STREAM_VOICE_CALL;
2675 focusTypePair.second.streamType = STREAM_MUSIC;
2676 interruptServiceTest->focusCfgMap_[focusTypePair] = FocusEntryTest;
2677 audioFocusTypePair.first.pid = 1;
2678 audioFocusTypePair.second = PAUSE;
2679 audioFocusTypePair.first.audioFocusType.streamType = STREAM_VOICE_CALL;
2680 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2681
2682 audioFocusTypePair.first.audioFocusType.streamType = STREAM_MUSIC;
2683 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2684
2685 auto ret = interruptServiceTest->SimulateFocusEntry(0);
2686 auto it = ret.begin();
2687 std::advance(it, 1);
2688 EXPECT_EQ(PAUSE, it->second);
2689 }
2690
2691 /**
2692 * @tc.name : Test SimulateFocusEntry
2693 * @tc.number: AudioInterruptService_SimulateFocusEntry_023
2694 * @tc.desc : Test SimulateFocusEntry
2695 */
2696 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_023, TestSize.Level1)
2697 {
2698 auto interruptServiceTest = GetTnterruptServiceTest();
2699 interruptServiceTest->zonesMap_.clear();
2700 interruptServiceTest->focusCfgMap_.clear();
2701
2702 AudioInterrupt interruptTest;
2703 interruptTest.mode = SHARE_MODE;
2704 interruptTest.pid = 0;
2705 std::pair<AudioInterrupt, AudioFocuState> audioFocusTypePair;
2706 audioFocusTypePair.first = interruptTest;
2707 audioFocusTypePair.second = ACTIVE;
2708 audioFocusTypePair.first.audioFocusType.streamType = STREAM_VOICE_CALL;
2709 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2710 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2711
2712 std::pair<AudioFocusType, AudioFocusType> focusTypePair;
2713 AudioFocusEntry FocusEntryTest;
2714 FocusEntryTest.isReject = false;
2715 FocusEntryTest.hintType = static_cast<InterruptHint>(INTERRUPT_HINT_ERROR);
2716 focusTypePair.first.streamType = STREAM_VOICE_CALL;
2717 focusTypePair.second.streamType = STREAM_MUSIC;
2718 interruptServiceTest->focusCfgMap_[focusTypePair] = FocusEntryTest;
2719 audioFocusTypePair.first.pid = 1;
2720 audioFocusTypePair.second = ACTIVE;
2721 audioFocusTypePair.first.audioFocusType.streamType = STREAM_VOICE_CALL;
2722 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2723
2724 interruptTest.mode = INDEPENDENT_MODE;
2725 audioFocusTypePair.first.audioFocusType.streamType = STREAM_MUSIC;
2726 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2727
2728 auto ret = interruptServiceTest->SimulateFocusEntry(0);
2729 auto it = ret.begin();
2730 std::advance(it, 1);
2731 EXPECT_NE(PAUSE, it->second);
2732 EXPECT_EQ(STREAM_VOICE_CALL, it->first.audioFocusType.streamType);
2733 }
2734
2735 /**
2736 * @tc.name : Test SimulateFocusEntry
2737 * @tc.number: AudioInterruptService_SimulateFocusEntry_024
2738 * @tc.desc : Test SimulateFocusEntry
2739 */
2740 HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_024, TestSize.Level1)
2741 {
2742 auto interruptServiceTest = GetTnterruptServiceTest();
2743 interruptServiceTest->zonesMap_.clear();
2744 interruptServiceTest->focusCfgMap_.clear();
2745
2746
2747 AudioInterrupt interruptTest;
2748 interruptTest.mode = SHARE_MODE;
2749 interruptTest.pid = 0;
2750 std::pair<AudioInterrupt, AudioFocuState> audioFocusTypePair;
2751 audioFocusTypePair.first = interruptTest;
2752 audioFocusTypePair.second = ACTIVE;
2753 audioFocusTypePair.first.audioFocusType.streamType = STREAM_VOICE_CALL;
2754 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2755 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2756
2757 std::pair<AudioFocusType, AudioFocusType> focusTypePair;
2758 AudioFocusEntry FocusEntryTest;
2759 FocusEntryTest.isReject = false;
2760 FocusEntryTest.hintType = static_cast<InterruptHint>(INTERRUPT_HINT_ERROR);
2761 focusTypePair.first.streamType = STREAM_VOICE_CALL;
2762 focusTypePair.second.streamType = STREAM_MUSIC;
2763 interruptServiceTest->focusCfgMap_[focusTypePair] = FocusEntryTest;
2764 audioFocusTypePair.first.pid = 1;
2765 audioFocusTypePair.second = PLACEHOLDER;
2766 audioFocusTypePair.first.audioFocusType.streamType = STREAM_VOICE_CALL;
2767 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2768
2769 interruptTest.mode = INDEPENDENT_MODE;
2770 audioFocusTypePair.first.audioFocusType.streamType = STREAM_MUSIC;
2771 interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.emplace_back(audioFocusTypePair);
2772
2773 auto ret = interruptServiceTest->SimulateFocusEntry(0);
2774 auto it = ret.begin();
2775 std::advance(it, 1);
2776 EXPECT_EQ(PLACEHOLDER, it->second);
2777 std::advance(it, 2);
2778 EXPECT_NE(SHARE_MODE, it->first.mode);
2779 }
2780
2781 /**
2782 * @tc.name : Test AudioInterruptService.
2783 * @tc.number: AudioInterruptServiceRequestAudioFocus_001
2784 * @tc.desc : Test RequestAudioFocus.
2785 */
2786 HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRequestAudioFocus_001, TestSize.Level1)
2787 {
2788 sptr<AudioPolicyServer> server = nullptr;
2789 auto interruptServiceTest = GetTnterruptServiceTest();
2790 EXPECT_EQ(interruptServiceTest->sessionService_, nullptr);
2791 interruptServiceTest->Init(server);
2792 AudioInterrupt incomingInterrupt;
2793
2794 interruptServiceTest->clientOnFocus_ = 0;
2795 auto retStatus = interruptServiceTest->RequestAudioFocus(0, incomingInterrupt);
2796 EXPECT_EQ(retStatus, SUCCESS);
2797
2798 interruptServiceTest->clientOnFocus_ = 0;
2799 retStatus = interruptServiceTest->RequestAudioFocus(1, incomingInterrupt);
2800 EXPECT_EQ(retStatus, SUCCESS);
2801
2802 interruptServiceTest->focussedAudioInterruptInfo_ = std::make_unique<AudioInterrupt>();
2803 interruptServiceTest->clientOnFocus_ = 0;
2804 retStatus = interruptServiceTest->RequestAudioFocus(1, incomingInterrupt);
2805 EXPECT_EQ(retStatus, SUCCESS);
2806 }
2807
2808 /**
2809 * @tc.name : Test AudioInterruptService.
2810 * @tc.number: AudioInterruptService_DeactivateAudioInterruptInternal_004
2811 * @tc.desc : Test DeactivateAudioInterruptInternal.
2812 */
2813 HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInternal_004, TestSize.Level1)
2814 {
2815 auto interruptServiceTest = GetTnterruptServiceTest();
2816 interruptServiceTest->zonesMap_.clear();
2817 AudioInterrupt audioInterrupt;
2818 AudioSessionService audioSessionService;
2819 AudioInterruptService audioInterruptService;
2820
2821 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
2822 EXPECT_EQ(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
2823 audioInterrupt.pid = 0;
2824 interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
2825 interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
2826 EXPECT_NE(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
2827
2828 interruptServiceTest->zonesMap_.clear();
2829 }
2830 } // namespace AudioStandard
2831 } // namespace OHOS