1 /*
2 * Copyright (c) 2022-2023 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 <gtest/gtest.h>
17 #include "audio_resource_service.h"
18 #include "audio_workgroup.h"
19 #include "audio_errors.h"
20 #include "iipc_stream.h"
21 #include "message_parcel.h"
22 #include "parcel.h"
23
24 using namespace testing::ext;
25 namespace OHOS {
26 namespace AudioStandard {
27 class AudioResourceServiceUnitTest : public testing::Test {
28 public:
29 static void SetUpTestCase(void);
30 static void TearDownTestCase(void);
31 void SetUp();
32 void TearDown();
33 };
34
SetUpTestCase(void)35 void AudioResourceServiceUnitTest::SetUpTestCase(void)
36 {
37 // input testsuit setup step，setup invoked before all testcases
38 }
39
TearDownTestCase(void)40 void AudioResourceServiceUnitTest::TearDownTestCase(void)
41 {
42 // input testsuit teardown step，teardown invoked after all testcases
43 }
44
SetUp(void)45 void AudioResourceServiceUnitTest::SetUp(void)
46 {
47 // input testcase setup step，setup invoked before each testcases
48 }
49
TearDown(void)50 void AudioResourceServiceUnitTest::TearDown(void)
51 {
52 // input testcase teardown step，teardown invoked after each testcases
53 }
54
55 AudioResourceService::AudioWorkgroupDeathRecipient deathRecipient;
56 AudioResourceService audioResourceService;
57 const int32_t testRtgId = 2;
58 static constexpr int32_t AUDIO_MAX_PROCESS = 2;
59
60 class RemoteObjectTestStub : public IRemoteObject {
61 public:
RemoteObjectTestStub()62 RemoteObjectTestStub() : IRemoteObject(u"IRemoteObject") {}
GetObjectRefCount()63 int32_t GetObjectRefCount() { return 0; };
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)64 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
AddDeathRecipient(const sptr<DeathRecipient> & recipient)65 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)66 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
Dump(int fd,const std::vector<std::u16string> & args)67 int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
68 DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectTestStub");
69 };
70
71 /**
72 * @tc.name : Test deathRecipient
73 * @tc.type : FUNC
74 * @tc.number: DeathRecipient_001
75 * @tc.desc : Test OnRemoteDied when param is nullptr
76 */
77 HWTEST(AudioResourceServiceUnitTest, DeathRecipient_001, TestSize.Level0)
78 {
__anonb1fc46530102() 79 std::function<void()> diedCb = []() {
80 };
81
82 deathRecipient.diedCb_ = diedCb;
83 deathRecipient.OnRemoteDied(nullptr);
84 EXPECT_TRUE(deathRecipient.diedCb_ != nullptr);
85 }
86
87 /**
88 * @tc.name : Test deathRecipient
89 * @tc.type : FUNC
90 * @tc.number: DeathRecipient_002
91 * @tc.desc : Test OnRemoteDied SetNotifyCb called
92 */
93 HWTEST(AudioResourceServiceUnitTest, DeathRecipient_002, TestSize.Level0)
94 {
__anonb1fc46530202() 95 std::function<void()> func = []() {
96 };
97
98 deathRecipient.diedCb_ = func;
99 deathRecipient.SetNotifyCb(func);
100 EXPECT_TRUE(deathRecipient.diedCb_);
101 }
102
103 /**
104 * @tc.name : Test deathRecipient
105 * @tc.type : FUNC
106 * @tc.number: DeathRecipient_003
107 * @tc.desc : Test OnWorkgroupRemoteDied when called
108 */
109 HWTEST(AudioResourceServiceUnitTest, DeathRecipient_003, TestSize.Level0)
110 {
111 std::shared_ptr<AudioWorkgroup> workgroup = std::make_shared<AudioWorkgroup>(testRtgId);
112 sptr<IRemoteObject> remoteObj = nullptr;
113
114 audioResourceService.audioWorkgroupMap_[1].groups[testRtgId] = {workgroup};
115 audioResourceService.OnWorkgroupRemoteDied(workgroup, remoteObj);
116 EXPECT_EQ(audioResourceService.audioWorkgroupMap_[1].groups.size(), 0);
117 EXPECT_EQ(audioResourceService.audioWorkgroupMap_[1].groups[testRtgId], nullptr);
118 }
119
120 /**
121 * @tc.name : Test deathRecipient
122 * @tc.type : FUNC
123 * @tc.number: DeathRecipient_004
124 * @tc.desc : Test OnWorkgroupRemoteDied when audioWorkgroupMap_ zero
125 */
126 HWTEST(AudioResourceServiceUnitTest, DeathRecipient_004, TestSize.Level0)
127 {
128 std::shared_ptr<AudioWorkgroup> workgroup = std::make_shared<AudioWorkgroup>(testRtgId);
129 sptr<IRemoteObject> remoteObj = nullptr;
130
131 audioResourceService.audioWorkgroupMap_[1].groups[testRtgId] = {workgroup};
132 audioResourceService.OnWorkgroupRemoteDied(workgroup, remoteObj);
133 EXPECT_EQ(audioResourceService.audioWorkgroupMap_.count(1), 0);
134 }
135
136 /**
137 * @tc.name : Test deathRecipient
138 * @tc.type : FUNC
139 * @tc.number: DeathRecipient_005
140 * @tc.desc : Test OnWorkgroupRemoteDied when audioWorkgroupMap_ empty
141 */
142 HWTEST(AudioResourceServiceUnitTest, DeathRecipient_005, TestSize.Level0)
143 {
144 std::shared_ptr<AudioWorkgroup> workgroup = std::make_shared<AudioWorkgroup>(testRtgId);
145 sptr<IRemoteObject> remoteObj = nullptr;
146
147 audioResourceService.OnWorkgroupRemoteDied(workgroup, remoteObj);
148 EXPECT_TRUE(audioResourceService.audioWorkgroupMap_.empty());
149 }
150
151 /**
152 * @tc.name : Test deathRecipient OnWorkgroupRemoteDied
153 * @tc.type : FUNC
154 * @tc.number: DeathRecipient_006
155 * @tc.desc : Test OnWorkgroupRemoteDied find audioWorkgroupMap_
156 */
157 HWTEST(AudioResourceServiceUnitTest, DeathRecipient_006, TestSize.Level0)
158 {
159 std::shared_ptr<AudioWorkgroup> workgroup = std::make_shared<AudioWorkgroup>(testRtgId);
160 sptr<IRemoteObject> remoteObj = new RemoteObjectTestStub();
161
162 audioResourceService.ReleaseWorkgroupDeathRecipient(workgroup, remoteObj);
163 EXPECT_EQ(audioResourceService.deathRecipientMap_.find(workgroup), audioResourceService.deathRecipientMap_.end());
164 }
165
166 /**
167 * @tc.name : Test deathRecipient
168 * @tc.type : FUNC
169 * @tc.number: DeathRecipient_007
170 * @tc.desc : Test ReleaseWorkgroupDeathRecipient when different remote object
171 */
172 HWTEST(AudioResourceServiceUnitTest, DeathRecipient_007, TestSize.Level0)
173 {
174 std::shared_ptr<AudioWorkgroup> workgroup = std::make_shared<AudioWorkgroup>(testRtgId);
175 sptr<IRemoteObject> remoteObj1 = new RemoteObjectTestStub();
176 sptr<IRemoteObject> remoteObj2 = new RemoteObjectTestStub();
177
178 audioResourceService.deathRecipientMap_[workgroup] = std::make_pair(remoteObj1, nullptr);
179 audioResourceService.ReleaseWorkgroupDeathRecipient(workgroup, remoteObj2);
180 EXPECT_EQ(audioResourceService.deathRecipientMap_[workgroup].first, remoteObj1);
181 }
182
183 /**
184 * @tc.name : Test deathRecipient
185 * @tc.type : FUNC
186 * @tc.number: DeathRecipient_008
187 * @tc.desc : Test ReleaseWorkgroupDeathRecipient when find workgroup
188 */
189 HWTEST(AudioResourceServiceUnitTest, DeathRecipient_008, TestSize.Level0)
190 {
191 std::shared_ptr<AudioWorkgroup> workgroup = std::make_shared<AudioWorkgroup>(testRtgId);
192 sptr<IRemoteObject> remoteObj = new RemoteObjectTestStub();
193
194 audioResourceService.deathRecipientMap_[workgroup] = std::make_pair(remoteObj, nullptr);
195 audioResourceService.ReleaseWorkgroupDeathRecipient(workgroup, remoteObj);
196 EXPECT_EQ(audioResourceService.deathRecipientMap_.find(workgroup), audioResourceService.deathRecipientMap_.end());
197 }
198
199 /**
200 * @tc.name : Test ImproveAudioWorkgroupPrio
201 * @tc.type : FUNC
202 * @tc.number: ImproveAudioWorkgroupPrio_001
203 * @tc.desc : Test ImproveAudioWorkgroupPrio when threads map is not empty
204 */
205 HWTEST(AudioResourceServiceUnitTest, ImproveAudioWorkgroupPrio_001, TestSize.Level0)
206 {
207 AudioResourceService audioResourceService;
208 pid_t pid = 1234;
209 std::unordered_map<int32_t, bool> threads = {{1, true}, {2, false}};
210 int32_t result = audioResourceService.ImproveAudioWorkgroupPrio(pid, threads);
211 EXPECT_EQ(result, AUDIO_OK);
212 }
213
214 /**
215 * @tc.name : Test ImproveAudioWorkgroupPrio
216 * @tc.type : FUNC
217 * @tc.number: ImproveAudioWorkgroupPrio_002
218 * @tc.desc : Test ImproveAudioWorkgroupPrio when threads map is empty
219 */
220 HWTEST(AudioResourceServiceUnitTest, ImproveAudioWorkgroupPrio_002, TestSize.Level0)
221 {
222 AudioResourceService audioResourceService;
223 pid_t pid = 1234;
224 std::unordered_map<int32_t, bool> threads = {};
225 int32_t result = audioResourceService.ImproveAudioWorkgroupPrio(pid, threads);
226 EXPECT_EQ(result, AUDIO_OK);
227 }
228
229 /**
230 * @tc.name : Test RestoreAudioWorkgroupPrio
231 * @tc.type : FUNC
232 * @tc.number: RestoreAudioWorkgroupPrio_001
233 * @tc.desc : Test RestoreAudioWorkgroupPrio when threads map is empty
234 */
235 HWTEST(AudioResourceServiceUnitTest, RestoreAudioWorkgroupPrio_001, TestSize.Level0)
236 {
237 AudioResourceService audioResourceService;
238 pid_t pid = 1234;
239 std::unordered_map<int32_t, int32_t> threads = {{1, 2}, {3, 4}};
240 int32_t result = audioResourceService.RestoreAudioWorkgroupPrio(pid, threads);
241 EXPECT_EQ(result, AUDIO_OK);
242 }
243
244 /**
245 * @tc.name : Test RestoreAudioWorkgroupPrio
246 * @tc.type : FUNC
247 * @tc.number: RestoreAudioWorkgroupPrio_002
248 * @tc.desc : Test RestoreAudioWorkgroupPrio when threads map is empty
249 */
250 HWTEST(AudioResourceServiceUnitTest, RestoreAudioWorkgroupPrio_002, TestSize.Level0)
251 {
252 AudioResourceService audioResourceService;
253 pid_t pid = 1234;
254 std::unordered_map<int32_t, int32_t> threads = {};
255 int32_t result = audioResourceService.RestoreAudioWorkgroupPrio(pid, threads);
256 EXPECT_EQ(result, AUDIO_OK);
257 }
258
259 /**
260 * @tc.name : Test AudioWorkgroupCheck
261 * @tc.type : FUNC
262 * @tc.number: AudioWorkgroupCheck
263 * @tc.desc : Test ReleaseWorkgroupDeathRecipient when find workgroup
264 */
265 HWTEST(AudioResourceServiceUnitTest, AudioWorkgroupCheck_001, TestSize.Level0)
266 {
267 int32_t pid = 123;
268 int32_t result = audioResourceService.AudioWorkgroupCheck(pid);
269 EXPECT_EQ(result, SUCCESS);
270
271 pid = -111;
272 result = audioResourceService.AudioWorkgroupCheck(pid);
273 EXPECT_EQ(result, false);
274 }
275
276 /**
277 * @tc.name : Test ReleaseAudioWorkgroup
278 * @tc.type : FUNC
279 * @tc.number: ReleaseAudioWorkgroup
280 * @tc.desc : Test ReleaseWorkgroupDeathRecipient when find workgroup
281 */
282 HWTEST(AudioResourceServiceUnitTest, ReleaseAudioWorkgroup_001, TestSize.Level0)
283 {
284 int32_t invalidPid = -1;
285 int32_t workgroupId = 1;
286 EXPECT_EQ(audioResourceService.ReleaseAudioWorkgroup(invalidPid, workgroupId), ERR_OPERATION_FAILED);
287
288 int32_t pid = 123;
289 int32_t nonExistentWorkgroupId = 999;
290 EXPECT_EQ(audioResourceService.ReleaseAudioWorkgroup(pid, nonExistentWorkgroupId), ERR_INVALID_PARAM);
291
292 std::shared_ptr<AudioWorkgroup> workgroup = std::make_shared<AudioWorkgroup>(testRtgId);
293 audioResourceService.audioWorkgroupMap_[1].groups[testRtgId] = {workgroup};
294 EXPECT_NE(audioResourceService.ReleaseAudioWorkgroup(1, 1), ERR_OPERATION_FAILED);
295 }
296
297 /**
298 * @tc.name : Test GetThreadsNumPerProcess
299 * @tc.type : FUNC
300 * @tc.number: GetThreadsNumPerProcess
301 * @tc.desc : Test GetThreadsNumPerProcess when find workgroup
302 */
303 HWTEST(AudioResourceServiceUnitTest, GetThreadsNumPerProcess_001, TestSize.Level0)
304 {
305 int32_t nonExistPid = 9999;
306 EXPECT_EQ(audioResourceService.GetThreadsNumPerProcess(nonExistPid), 0);
307
308 int32_t pid = 1234;
309 audioResourceService.audioWorkgroupMap_[pid].groups.clear();
310 EXPECT_EQ(audioResourceService.GetThreadsNumPerProcess(pid), 0);
311
312 int32_t ExistPid = 1;
313 EXPECT_EQ(audioResourceService.GetThreadsNumPerProcess(ExistPid), 0);
314 }
315
316 /**
317 * @tc.name : Test RegisterAudioWorkgroupMonitor
318 * @tc.type : FUNC
319 * @tc.number: RegisterAudioWorkgroupMonitor
320 * @tc.desc : Test RegisterAudioWorkgroupMonitor when find workgroup
321 */
322 HWTEST(AudioResourceServiceUnitTest, RegisterAudioWorkgroupMonitor_001, TestSize.Level0)
323 {
324 int32_t pid = 123;
325 int32_t groupId = 1;
326 sptr<IRemoteObject> remoteObj = new RemoteObjectTestStub();
327 int32_t ret = audioResourceService.RegisterAudioWorkgroupMonitor(pid, groupId, remoteObj);
328 EXPECT_EQ(ret, 0);
329
330 groupId = -1;
331 ret = audioResourceService.RegisterAudioWorkgroupMonitor(pid, groupId, remoteObj);
332 EXPECT_EQ(ret, 0);
333
334 pid = 1;
335 ret = audioResourceService.RegisterAudioWorkgroupMonitor(pid, groupId, remoteObj);
336
337 EXPECT_EQ(ret, SUCCESS);
338 }
339
340 /**
341 * @tc.name : Test CreateAudioWorkgroup
342 * @tc.type : FUNC
343 * @tc.number: CreateAudioWorkgroup
344 * @tc.desc : Test ReleaseWorkgroupDeathRecipient when find workgroup
345 */
346 HWTEST(AudioResourceServiceUnitTest, CreateAudioWorkgroup_001, TestSize.Level0)
347 {
348 sptr<IRemoteObject> remoteObj = nullptr;
349 EXPECT_EQ(audioResourceService.CreateAudioWorkgroup(-1, remoteObj), ERR_INVALID_PARAM);
350
351 EXPECT_EQ(audioResourceService.CreateAudioWorkgroup(1, nullptr), ERR_OPERATION_FAILED);
352
353 remoteObj = new RemoteObjectTestStub();
354 EXPECT_NE(audioResourceService.CreateAudioWorkgroup(1, remoteObj), ERR_INVALID_PARAM);
355 }
356
357 /**
358 * @tc.name : Test AddThreadToGroup
359 * @tc.type : FUNC
360 * @tc.number: AddThreadToGroup
361 * @tc.desc : Test AddThreadToGroup when find workgroup
362 */
363 HWTEST(AudioResourceServiceUnitTest, AddThreadToGroup_001, TestSize.Level0)
364 {
365 int32_t pid = 123;
366 int32_t workgroupId = 1;
367 int32_t tokenId = pid;
368
369 int32_t ret = audioResourceService.AddThreadToGroup(pid, workgroupId, tokenId);
370 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
371
372 tokenId = 3;
373 ret = audioResourceService.AddThreadToGroup(pid, workgroupId, tokenId);
374 EXPECT_NE(ret, 0);
375 }
376
377 /**
378 * @tc.name : Test WorkgroupRendererMonitor
379 * @tc.type : FUNC
380 * @tc.number: WorkgroupRendererMonitor
381 * @tc.desc : Test WorkgroupRendererMonitor when find workgroup
382 */
383 HWTEST(AudioResourceServiceUnitTest, WorkgroupRendererMonitor_001, TestSize.Level0)
384 {
385 int32_t testPid = -111;
386 audioResourceService.WorkgroupRendererMonitor(testPid, true);
387 EXPECT_FALSE(audioResourceService.audioWorkgroupMap_[testPid].permission);
388
389 testPid = 123;
390 audioResourceService.audioWorkgroupMap_[testPid].permission = true;
391 audioResourceService.WorkgroupRendererMonitor(testPid, true);
392
393 EXPECT_TRUE(audioResourceService.audioWorkgroupMap_[testPid].permission);
394 }
395
396 /**
397 * @tc.name : Test DumpAudioWorkgroupMap
398 * @tc.type : FUNC
399 * @tc.number: DumpAudioWorkgroupMap
400 * @tc.desc : Test DumpAudioWorkgroupMap when find workgroup
401 */
402 HWTEST(AudioResourceServiceUnitTest, DumpAudioWorkgroupMap_001, TestSize.Level0)
403 {
404 sptr<IRemoteObject> remoteObj = nullptr;
405 audioResourceService.DumpAudioWorkgroupMap();
406 EXPECT_TRUE(remoteObj == nullptr);
407 }
408
409 /**
410 * @tc.name : Test StopGroup
411 * @tc.type : FUNC
412 * @tc.number: StopGroup
413 * @tc.desc : Test StopGroup when find workgroup
414 */
415 HWTEST(AudioResourceServiceUnitTest, StopGroup_001, TestSize.Level0)
416 {
417 int32_t ret = audioResourceService.StopGroup(123, 456);
418 EXPECT_NE(ret, 0);
419 }
420
421 /**
422 * @tc.name : Test IsProcessHasSystemPermission
423 * @tc.type : FUNC
424 * @tc.number: IsProcessHasSystemPermission_001
425 * @tc.desc : Test IsProcessHasSystemPermission when find workgroup
426 */
427 HWTEST(AudioResourceServiceUnitTest, IsProcessHasSystemPermission_001, TestSize.Level0)
428 {
429 int32_t pid = 123;
430 audioResourceService.audioWorkgroupMap_[pid].hasSystemPermission = true;
431 EXPECT_TRUE(audioResourceService.IsProcessHasSystemPermission(pid));
432 }
433
434 /**
435 * @tc.name : Test IsProcessHasSystemPermission
436 * @tc.type : FUNC
437 * @tc.number: IsProcessHasSystemPermission_002
438 * @tc.desc : Test IsProcessHasSystemPermission when find workgroup
439 */
440 HWTEST(AudioResourceServiceUnitTest, IsProcessHasSystemPermission_002, TestSize.Level0)
441 {
442 int32_t pid = 123;
443 audioResourceService.audioWorkgroupMap_[pid].hasSystemPermission = false;
444 EXPECT_FALSE(audioResourceService.IsProcessHasSystemPermission(pid));
445 }
446
447 /**
448 * @tc.name : Test RegisterAudioWorkgroupMonitor
449 * @tc.type : FUNC
450 * @tc.number: RegisterAudioWorkgroupMonitor_002
451 * @tc.desc : Test RegisterAudioWorkgroupMonitor when find workgroup
452 */
453 HWTEST(AudioResourceServiceUnitTest, RegisterAudioWorkgroupMonitor_002, TestSize.Level0)
454 {
455 int32_t pid = 1;
456 int32_t groupId = 1;
457 sptr<IRemoteObject> remoteObj = new RemoteObjectTestStub();
458 EXPECT_EQ(audioResourceService.RegisterAudioWorkgroupMonitor(pid, groupId, remoteObj), SUCCESS);
459 }
460
461 /**
462 * @tc.name : Test RegisterAudioWorkgroupMonitor
463 * @tc.type : FUNC
464 * @tc.number: RegisterAudioWorkgroupMonitor_003
465 * @tc.desc : Test RegisterAudioWorkgroupMonitor when find workgroup
466 */
467 HWTEST(AudioResourceServiceUnitTest, RegisterAudioWorkgroupMonitor_003, TestSize.Level0)
468 {
469 int32_t pid = 1;
470 int32_t groupId = 1;
471 sptr<IRemoteObject> object = nullptr;
472 EXPECT_EQ(audioResourceService.RegisterAudioWorkgroupMonitor(pid, groupId, object), SUCCESS);
473 }
474
475 /**
476 * @tc.name : Test RegisterAudioWorkgroupMonitor
477 * @tc.type : FUNC
478 * @tc.number: RegisterAudioWorkgroupMonitor_004
479 * @tc.desc : Test RegisterAudioWorkgroupMonitor when find workgroup
480 */
481 HWTEST(AudioResourceServiceUnitTest, RegisterAudioWorkgroupMonitor_004, TestSize.Level0)
482 {
483 int32_t pid = 1;
484 int32_t groupId = 1;
485 sptr<IRemoteObject> remoteObj = new RemoteObjectTestStub();
486 audioResourceService.audioWorkgroupMap_[pid].hasSystemPermission = false;
487 EXPECT_EQ(audioResourceService.RegisterAudioWorkgroupMonitor(pid, groupId, remoteObj), SUCCESS);
488 }
489
490 /**
491 * @tc.name : Test RegisterAudioWorkgroupMonitor
492 * @tc.type : FUNC
493 * @tc.number: RegisterAudioWorkgroupMonitor_005
494 * @tc.desc : Test RegisterAudioWorkgroupMonitor when find workgroup
495 */
496 HWTEST(AudioResourceServiceUnitTest, RegisterAudioWorkgroupMonitor_005, TestSize.Level0)
497 {
498 int32_t pid = 1;
499 int32_t groupId = 1;
500 sptr<IRemoteObject> remoteObj = new RemoteObjectTestStub();
501 std::shared_ptr<AudioWorkgroup> workgroup = std::make_shared<AudioWorkgroup>(testRtgId);
502 audioResourceService.audioWorkgroupMap_[pid].hasSystemPermission = false;
503 audioResourceService.audioWorkgroupMap_[1].groups[testRtgId] = {workgroup};
504 EXPECT_EQ(audioResourceService.RegisterAudioWorkgroupMonitor(pid, groupId, remoteObj), SUCCESS);
505 }
506
507 /**
508 * @tc.name : Test StartGroup
509 * @tc.type : FUNC
510 * @tc.number: StartGroup_001
511 * @tc.desc : Test StartGroup when find workgroup
512 */
513 HWTEST(AudioResourceServiceUnitTest, StartGroup_001, TestSize.Level0)
514 {
515 int32_t pid = 1;
516 int32_t workgroupId = 1;
517 uint64_t startTime = 1000;
518 uint64_t deadlineTime = 2000;
519
520 int32_t ret = audioResourceService.StartGroup(pid, workgroupId, startTime, deadlineTime);
521
522 EXPECT_EQ(ret, ERR_INVALID_PARAM);
523 }
524
525 /**
526 * @tc.name : Test RemoveThreadFromGroup
527 * @tc.type : FUNC
528 * @tc.number: RemoveThreadFromGroup_001
529 * @tc.desc : Test RemoveThreadFromGroup when find workgroup
530 */
531 HWTEST(AudioResourceServiceUnitTest, RemoveThreadFromGroup_001, TestSize.Level0)
532 {
533 int32_t pid = 1;
534 int32_t workgroupId = 1;
535 int32_t tokenId = 1;
536
537 int32_t ret = audioResourceService.RemoveThreadFromGroup(pid, workgroupId, tokenId);
538
539 EXPECT_EQ(ret, ERR_INVALID_PARAM);
540 }
541
542 /**
543 * @tc.name : Test AddThreadToGroup
544 * @tc.type : FUNC
545 * @tc.number: AddThreadToGroup_002
546 * @tc.desc : Test AddThreadToGroup when find workgroup
547 */
548 HWTEST(AudioResourceServiceUnitTest, AddThreadToGroup_002, TestSize.Level0)
549 {
550 int32_t pid = 1;
551 int32_t workgroupId = 1;
552 int32_t tokenId = 1;
553 int32_t ret = audioResourceService.AddThreadToGroup(pid, workgroupId, tokenId);
554 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
555 }
556
557 /**
558 * @tc.name : Test AddThreadToGroup
559 * @tc.type : FUNC
560 * @tc.number: AddThreadToGroup_003
561 * @tc.desc : Test AddThreadToGroup when find workgroup
562 */
563 HWTEST(AudioResourceServiceUnitTest, AddThreadToGroup_003, TestSize.Level0)
564 {
565 int32_t pid = 2;
566 int32_t workgroupId = 2;
567 int32_t tokenId = 2;
568 int32_t ret = audioResourceService.AddThreadToGroup(pid, workgroupId, tokenId);
569 EXPECT_NE(ret, ERR_INVALID_PARAM);
570 }
571
572 /**
573 * @tc.name : Test AddThreadToGroup
574 * @tc.type : FUNC
575 * @tc.number: AddThreadToGroup_004
576 * @tc.desc : Test AddThreadToGroup when find workgroup
577 */
578 HWTEST(AudioResourceServiceUnitTest, AddThreadToGroup_004, TestSize.Level0)
579 {
580 int32_t pid = 3;
581 int32_t workgroupId = 3;
582 int32_t tokenId = 3;
583 int32_t ret = audioResourceService.AddThreadToGroup(pid, workgroupId, tokenId);
584 EXPECT_NE(ret, ERR_NOT_SUPPORTED);
585 }
586
587 /**
588 * @tc.name : Test AddThreadToGroup
589 * @tc.type : FUNC
590 * @tc.number: AddThreadToGroup_005
591 * @tc.desc : Test AddThreadToGroup when find workgroup
592 */
593 HWTEST(AudioResourceServiceUnitTest, AddThreadToGroup_005, TestSize.Level0)
594 {
595 int32_t pid = 4;
596 int32_t workgroupId = 4;
597 int32_t tokenId = 4;
598 int32_t ret = audioResourceService.AddThreadToGroup(pid, workgroupId, tokenId);
599 EXPECT_NE(ret, SUCCESS);
600 }
601
602 /**
603 * @tc.name : Test ReleaseAudioWorkgroup
604 * @tc.type : FUNC
605 * @tc.number: ReleaseAudioWorkgroup_002
606 * @tc.desc : Test ReleaseAudioWorkgroup when find workgroup
607 */
608 HWTEST(AudioResourceServiceUnitTest, ReleaseAudioWorkgroup_002, TestSize.Level0)
609 {
610 int32_t pid = -1;
611 int32_t workgroupId = 1;
612 int32_t ret = audioResourceService.ReleaseAudioWorkgroup(pid, workgroupId);
613 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
614 }
615
616 /**
617 * @tc.name : Test ReleaseAudioWorkgroup
618 * @tc.type : FUNC
619 * @tc.number: ReleaseAudioWorkgroup_003
620 * @tc.desc : Test ReleaseAudioWorkgroup when find workgroup
621 */
622 HWTEST(AudioResourceServiceUnitTest, ReleaseAudioWorkgroup_003, TestSize.Level0)
623 {
624 int32_t pid = 1;
625 int32_t workgroupId = 1;
626 int32_t ret = audioResourceService.ReleaseAudioWorkgroup(pid, workgroupId);
627 EXPECT_NE(ret, SUCCESS);
628 }
629
630 /**
631 * @tc.name : Test ReleaseAudioWorkgroup
632 * @tc.type : FUNC
633 * @tc.number: ReleaseAudioWorkgroup_004
634 * @tc.desc : Test ReleaseAudioWorkgroup when find workgroup
635 */
636 HWTEST(AudioResourceServiceUnitTest, ReleaseAudioWorkgroup_004, TestSize.Level0)
637 {
638 int32_t pid = 1;
639 int32_t workgroupId = -1;
640 int32_t ret = audioResourceService.ReleaseAudioWorkgroup(pid, workgroupId);
641 EXPECT_NE(ret, ERR_OPERATION_FAILED);
642 }
643
644 /**
645 * @tc.name : Test ReleaseAudioWorkgroup
646 * @tc.type : FUNC
647 * @tc.number: ReleaseAudioWorkgroup_005
648 * @tc.desc : Test ReleaseAudioWorkgroup when find workgroup
649 */
650 HWTEST(AudioResourceServiceUnitTest, ReleaseAudioWorkgroup_005, TestSize.Level0)
651 {
652 int32_t pid = 1;
653 int32_t workgroupId = 1;
654 int32_t ret = audioResourceService.ReleaseAudioWorkgroup(pid, workgroupId);
655 EXPECT_NE(ret, SUCCESS);
656 }
657
658 /**
659 * @tc.name : Test AudioWorkgroupCheck
660 * @tc.type : FUNC
661 * @tc.number: AudioWorkgroupCheck_003
662 * @tc.desc : Test AudioWorkgroupCheck when find workgroup
663 */
664 HWTEST(AudioResourceServiceUnitTest, AudioWorkgroupCheck_003, TestSize.Level0)
665 {
666 int32_t pid = 1234;
667 for (int i = 0; i < AUDIO_MAX_PROCESS; i++) {
668 audioResourceService.audioWorkgroupMap_[AUDIO_MAX_PROCESS].hasSystemPermission = false;
669 }
670 EXPECT_NE(audioResourceService.AudioWorkgroupCheck(pid), ERR_NOT_SUPPORTED);
671 }
672
673 /**
674 * @tc.name : Test AudioWorkgroupCheck
675 * @tc.type : FUNC
676 * @tc.number: AudioWorkgroupCheck_004
677 * @tc.desc : Test AudioWorkgroupCheck when find workgroup
678 */
679 HWTEST(AudioResourceServiceUnitTest, AudioWorkgroupCheck_004, TestSize.Level0)
680 {
681 int32_t pid = 1234;
682 EXPECT_EQ(audioResourceService.AudioWorkgroupCheck(pid), SUCCESS);
683 }
684
685 } // namespace AudioStandard
686 } // namespace OHOS