1 /*
2 * Copyright (c) 2025 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_errors.h"
18 #include "policy_provider_stub.h"
19 #include "audio_service.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace AudioStandard {
25
26 class MockPolicyProvider : public IPolicyProvider {
27 public:
MockPolicyProvider()28 MockPolicyProvider() {};
~MockPolicyProvider()29 ~MockPolicyProvider() {};
30
31 int32_t GetProcessDeviceInfo(const AudioProcessConfig &config, bool lockFlag,
32 AudioDeviceDescriptor &deviceInfo) override;
33
34 int32_t InitSharedVolume(std::shared_ptr<AudioSharedMemory> &buffer) override;
35
36 int32_t SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig &config) override;
37
38 int32_t NotifyCapturerAdded(AudioCapturerInfo capturerInfo, AudioStreamInfo streamInfo,
39 uint32_t sessionId) override;
40
41 int32_t NotifyWakeUpCapturerRemoved() override;
42
43 bool IsAbsVolumeSupported() override;
44
45 int32_t OffloadGetRenderPosition(uint32_t &delayValue, uint64_t &sendDataSize, uint32_t &timeStamp) override;
46
47 int32_t GetAndSaveClientType(uint32_t uid, const std::string &bundleName) override;
48
49 int32_t GetMaxRendererInstances() override;
50
51 int32_t ActivateConcurrencyFromServer(AudioPipeType incomingPipe) override;
52
53 int32_t NotifyCapturerRemoved(uint64_t sessionId) override;
54
55 int32_t SetDefaultOutputDevice(const DeviceType defaultOutputDevice, const uint32_t sessionID,
56 const StreamUsage streamUsage, bool isRunning) override;
57
58 int32_t LoadModernInnerCapSink(int32_t innerCapId) override;
59
60 int32_t UnloadModernInnerCapSink(int32_t innerCapId) override;
61
62 std::shared_ptr<AudioSharedMemory> policyVolumeMap_ = nullptr;
63 };
64
GetProcessDeviceInfo(const AudioProcessConfig & config,bool lockFlag,AudioDeviceDescriptor & deviceInfo)65 int32_t MockPolicyProvider::GetProcessDeviceInfo(const AudioProcessConfig &config, bool lockFlag,
66 AudioDeviceDescriptor &deviceInfo)
67 {
68 return SUCCESS;
69 }
70
InitSharedVolume(std::shared_ptr<AudioSharedMemory> & buffer)71 int32_t MockPolicyProvider::InitSharedVolume(std::shared_ptr<AudioSharedMemory> &buffer)
72 {
73 return SUCCESS;
74 }
75
SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig & config)76 int32_t MockPolicyProvider::SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig &config)
77 {
78 return SUCCESS;
79 }
80
NotifyCapturerAdded(AudioCapturerInfo capturerInfo,AudioStreamInfo streamInfo,uint32_t sessionId)81 int32_t MockPolicyProvider::NotifyCapturerAdded(AudioCapturerInfo capturerInfo, AudioStreamInfo streamInfo,
82 uint32_t sessionId)
83 {
84 return SUCCESS;
85 }
86
NotifyWakeUpCapturerRemoved()87 int32_t MockPolicyProvider::NotifyWakeUpCapturerRemoved()
88 {
89 return SUCCESS;
90 }
91
IsAbsVolumeSupported()92 bool MockPolicyProvider::IsAbsVolumeSupported()
93 {
94 return SUCCESS;
95 }
96
OffloadGetRenderPosition(uint32_t & delayValue,uint64_t & sendDataSize,uint32_t & timeStamp)97 int32_t MockPolicyProvider::OffloadGetRenderPosition(uint32_t &delayValue, uint64_t &sendDataSize, uint32_t &timeStamp)
98 {
99 return SUCCESS;
100 }
101
GetAndSaveClientType(uint32_t uid,const std::string & bundleName)102 int32_t MockPolicyProvider::GetAndSaveClientType(uint32_t uid, const std::string &bundleName)
103 {
104 return SUCCESS;
105 }
106
GetMaxRendererInstances()107 int32_t MockPolicyProvider::GetMaxRendererInstances()
108 {
109 return SUCCESS;
110 }
111
ActivateConcurrencyFromServer(AudioPipeType incomingPipe)112 int32_t MockPolicyProvider::ActivateConcurrencyFromServer(AudioPipeType incomingPipe)
113 {
114 return SUCCESS;
115 }
116
NotifyCapturerRemoved(uint64_t sessionId)117 int32_t MockPolicyProvider::NotifyCapturerRemoved(uint64_t sessionId)
118 {
119 return SUCCESS;
120 }
121
SetDefaultOutputDevice(const DeviceType defaultOutputDevice,const uint32_t sessionID,const StreamUsage streamUsage,bool isRunning)122 int32_t MockPolicyProvider::SetDefaultOutputDevice(const DeviceType defaultOutputDevice, const uint32_t sessionID,
123 const StreamUsage streamUsage, bool isRunning)
124 {
125 return SUCCESS;
126 }
LoadModernInnerCapSink(int32_t innerCapId)127 int32_t MockPolicyProvider::LoadModernInnerCapSink(int32_t innerCapId)
128 {
129 return SUCCESS;
130 }
131
UnloadModernInnerCapSink(int32_t innerCapId)132 int32_t MockPolicyProvider::UnloadModernInnerCapSink(int32_t innerCapId)
133 {
134 return SUCCESS;
135 }
136
137 class PolicyProviderStubUnitTest : public ::testing::Test {
138 public:
139 void SetUp();
140 void TearDown();
141 };
142
SetUp(void)143 void PolicyProviderStubUnitTest::SetUp(void)
144 {
145 // input testcase setup step，setup invoked before each testcases
146 }
147
TearDown(void)148 void PolicyProviderStubUnitTest::TearDown(void)
149 {
150 // input testcase teardown step，teardown invoked after each testcases
151 }
152
153 /**
154 * @tc.name : Test PolicyProviderStub.
155 * @tc.type : FUNC
156 * @tc.number: PolicyProviderStub_001
157 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
158 */
159 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_001, TestSize.Level1)
160 {
161 MockPolicyProvider mockProvider;
162 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
163 EXPECT_NE(policyProviderStub, nullptr);
164
165 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::GET_DEVICE_INFO;
166 MessageParcel data;
167 MessageParcel reply;
168 MessageOption option;
169
170 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
171
172 bool ret = policyProviderStub->CheckInterfaceToken(data);
173
174 EXPECT_EQ(ret, true);
175
176 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
177 EXPECT_EQ(ret, true);
178 }
179
180 /**
181 * @tc.name : Test PolicyProviderStub.
182 * @tc.type : FUNC
183 * @tc.number: PolicyProviderStub_002
184 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
185 */
186 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_002, TestSize.Level1)
187 {
188 MockPolicyProvider mockProvider;
189 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
190 EXPECT_NE(policyProviderStub, nullptr);
191
192 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::INIT_VOLUME_MAP;
193 MessageParcel data;
194 MessageParcel reply;
195 MessageOption option;
196
197 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
198
199 bool ret = policyProviderStub->CheckInterfaceToken(data);
200
201 EXPECT_EQ(ret, true);
202
203 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
204 EXPECT_EQ(ret, true);
205 }
206
207 /**
208 * @tc.name : Test PolicyProviderStub.
209 * @tc.type : FUNC
210 * @tc.number: PolicyProviderStub_003
211 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
212 */
213 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_003, TestSize.Level1)
214 {
215 MockPolicyProvider mockProvider;
216 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
217 EXPECT_NE(policyProviderStub, nullptr);
218
219 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::SET_WAKEUP_ADUIO_CAPTURER;
220 MessageParcel data;
221 MessageParcel reply;
222 MessageOption option;
223
224 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
225
226 bool ret = policyProviderStub->CheckInterfaceToken(data);
227
228 EXPECT_EQ(ret, true);
229
230 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
231 EXPECT_EQ(ret, true);
232 }
233
234 /**
235 * @tc.name : Test PolicyProviderStub.
236 * @tc.type : FUNC
237 * @tc.number: PolicyProviderStub_004
238 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
239 */
240 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_004, TestSize.Level1)
241 {
242 MockPolicyProvider mockProvider;
243 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
244 EXPECT_NE(policyProviderStub, nullptr);
245
246 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::SET_AUDIO_CAPTURER;
247 MessageParcel data;
248 MessageParcel reply;
249 MessageOption option;
250
251 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
252
253 bool ret = policyProviderStub->CheckInterfaceToken(data);
254
255 EXPECT_EQ(ret, true);
256
257 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
258 EXPECT_EQ(ret, true);
259 }
260
261 /**
262 * @tc.name : Test PolicyProviderStub.
263 * @tc.type : FUNC
264 * @tc.number: PolicyProviderStub_005
265 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
266 */
267 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_005, TestSize.Level1)
268 {
269 MockPolicyProvider mockProvider;
270 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
271 EXPECT_NE(policyProviderStub, nullptr);
272
273 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::REMOVE_WAKEUP_CAPUTER;
274 MessageParcel data;
275 MessageParcel reply;
276 MessageOption option;
277
278 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
279
280 bool ret = policyProviderStub->CheckInterfaceToken(data);
281
282 EXPECT_EQ(ret, true);
283
284 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
285 EXPECT_EQ(ret, true);
286 }
287
288 /**
289 * @tc.name : Test PolicyProviderStub.
290 * @tc.type : FUNC
291 * @tc.number: PolicyProviderStub_006
292 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
293 */
294 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_006, TestSize.Level1)
295 {
296 MockPolicyProvider mockProvider;
297 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
298 EXPECT_NE(policyProviderStub, nullptr);
299
300 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::IS_ABS_VOLUME_SUPPORTED;
301 MessageParcel data;
302 MessageParcel reply;
303 MessageOption option;
304
305 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
306
307 bool ret = policyProviderStub->CheckInterfaceToken(data);
308
309 EXPECT_EQ(ret, true);
310
311 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
312 EXPECT_EQ(ret, true);
313 }
314
315 /**
316 * @tc.name : Test PolicyProviderStub.
317 * @tc.type : FUNC
318 * @tc.number: PolicyProviderStub_007
319 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
320 */
321 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_007, TestSize.Level1)
322 {
323 MockPolicyProvider mockProvider;
324 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
325 EXPECT_NE(policyProviderStub, nullptr);
326
327 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::OFFLOAD_GET_RENDER_POSITION;
328 MessageParcel data;
329 MessageParcel reply;
330 MessageOption option;
331
332 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
333
334 bool ret = policyProviderStub->CheckInterfaceToken(data);
335
336 EXPECT_EQ(ret, true);
337
338 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
339 EXPECT_EQ(ret, true);
340 }
341
342 /**
343 * @tc.name : Test PolicyProviderStub.
344 * @tc.type : FUNC
345 * @tc.number: PolicyProviderStub_008
346 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
347 */
348 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_008, TestSize.Level1)
349 {
350 MockPolicyProvider mockProvider;
351 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
352 EXPECT_NE(policyProviderStub, nullptr);
353
354 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::GET_AND_SAVE_CLIENT_TYPE;
355 MessageParcel data;
356 MessageParcel reply;
357 MessageOption option;
358
359 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
360
361 bool ret = policyProviderStub->CheckInterfaceToken(data);
362
363 EXPECT_EQ(ret, true);
364
365 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
366 EXPECT_EQ(ret, true);
367 }
368
369 /**
370 * @tc.name : Test PolicyProviderStub.
371 * @tc.type : FUNC
372 * @tc.number: PolicyProviderStub_009
373 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
374 */
375 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_009, TestSize.Level1)
376 {
377 MockPolicyProvider mockProvider;
378 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
379 EXPECT_NE(policyProviderStub, nullptr);
380
381 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::GET_MAX_RENDERER_INSTANCES;
382 MessageParcel data;
383 MessageParcel reply;
384 MessageOption option;
385
386 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
387
388 bool ret = policyProviderStub->CheckInterfaceToken(data);
389
390 EXPECT_EQ(ret, true);
391
392 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
393 EXPECT_EQ(ret, true);
394 }
395
396 /**
397 * @tc.name : Test PolicyProviderStub.
398 * @tc.type : FUNC
399 * @tc.number: PolicyProviderStub_010
400 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
401 */
402 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_010, TestSize.Level1)
403 {
404 MockPolicyProvider mockProvider;
405 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
406 EXPECT_NE(policyProviderStub, nullptr);
407
408 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::ACTIVATE_CONCURRENCY_FROM_SERVER;
409 MessageParcel data;
410 MessageParcel reply;
411 MessageOption option;
412
413 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
414
415 bool ret = policyProviderStub->CheckInterfaceToken(data);
416
417 EXPECT_EQ(ret, true);
418
419 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
420 EXPECT_EQ(ret, true);
421 }
422
423 /**
424 * @tc.name : Test PolicyProviderStub.
425 * @tc.type : FUNC
426 * @tc.number: PolicyProviderStub_011
427 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
428 */
429 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_011, TestSize.Level1)
430 {
431 MockPolicyProvider mockProvider;
432 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
433 EXPECT_NE(policyProviderStub, nullptr);
434
435 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::REMOVE_AUDIO_CAPTURER;
436 MessageParcel data;
437 MessageParcel reply;
438 MessageOption option;
439
440 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
441
442 bool ret = policyProviderStub->CheckInterfaceToken(data);
443
444 EXPECT_EQ(ret, true);
445
446 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
447 EXPECT_EQ(ret, true);
448 }
449
450 /**
451 * @tc.name : Test PolicyProviderStub.
452 * @tc.type : FUNC
453 * @tc.number: PolicyProviderStub_012
454 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
455 */
456 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_012, TestSize.Level1)
457 {
458 MockPolicyProvider mockProvider;
459 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
460 EXPECT_NE(policyProviderStub, nullptr);
461
462 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::SET_DEFAULT_OUTPUT_DEVICE;
463 MessageParcel data;
464 MessageParcel reply;
465 MessageOption option;
466
467 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
468
469 bool ret = policyProviderStub->CheckInterfaceToken(data);
470
471 EXPECT_EQ(ret, true);
472
473 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
474 EXPECT_EQ(ret, true);
475 }
476
477 /**
478 * @tc.name : Test PolicyProviderStub.
479 * @tc.type : FUNC
480 * @tc.number: PolicyProviderStub_013
481 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
482 */
483 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_013, TestSize.Level1)
484 {
485 MockPolicyProvider mockProvider;
486 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
487 EXPECT_NE(policyProviderStub, nullptr);
488
489 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::LOAD_MODERN_INNER_CAPTURE_SINK;
490 MessageParcel data;
491 MessageParcel reply;
492 MessageOption option;
493
494 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
495
496 bool ret = policyProviderStub->CheckInterfaceToken(data);
497
498 EXPECT_EQ(ret, true);
499
500 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
501 EXPECT_EQ(ret, true);
502 }
503
504 /**
505 * @tc.name : Test PolicyProviderStub.
506 * @tc.type : FUNC
507 * @tc.number: PolicyProviderStub_014
508 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
509 */
510 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_014, TestSize.Level1)
511 {
512 MockPolicyProvider mockProvider;
513 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
514 EXPECT_NE(policyProviderStub, nullptr);
515
516 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::UNLOAD_MODERN_INNER_CAPTURE_SINK;
517 MessageParcel data;
518 MessageParcel reply;
519 MessageOption option;
520
521 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
522
523 bool ret = policyProviderStub->CheckInterfaceToken(data);
524
525 EXPECT_EQ(ret, true);
526
527 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
528 EXPECT_EQ(ret, true);
529 }
530
531 /**
532 * @tc.name : Test PolicyProviderStub.
533 * @tc.type : FUNC
534 * @tc.number: PolicyProviderStub_015
535 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
536 */
537 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_015, TestSize.Level1)
538 {
539 MockPolicyProvider mockProvider;
540 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
541 EXPECT_NE(policyProviderStub, nullptr);
542
543 uint32_t code = IPolicyProviderIpc::IPolicyProviderMsg::POLICY_PROVIDER_MAX_MSG;
544 MessageParcel data;
545 MessageParcel reply;
546 MessageOption option;
547
548 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
549
550 bool ret = policyProviderStub->CheckInterfaceToken(data);
551
552 EXPECT_EQ(ret, true);
553
554 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
555 EXPECT_EQ(ret, true);
556 }
557
558 /**
559 * @tc.name : Test PolicyProviderStub.
560 * @tc.type : FUNC
561 * @tc.number: PolicyProviderStub_016
562 * @tc.desc : Test PolicyProviderStub::OnRemoteRequest().
563 */
564 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_016, TestSize.Level1)
565 {
566 MockPolicyProvider mockProvider;
567 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
568 EXPECT_NE(policyProviderStub, nullptr);
569
570 uint32_t code = (IPolicyProviderIpc::IPolicyProviderMsg)20;
571 MessageParcel data;
572 MessageParcel reply;
573 MessageOption option;
574
575 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
576
577 bool ret = policyProviderStub->CheckInterfaceToken(data);
578
579 EXPECT_EQ(ret, true);
580
581 ret = policyProviderStub->OnRemoteRequest(code, data, reply, option);
582 EXPECT_EQ(ret, true);
583 }
584
585 /**
586 * @tc.name : Test PolicyProviderStub.
587 * @tc.type : FUNC
588 * @tc.number: PolicyProviderStub_017
589 * @tc.desc : Test PolicyProviderStub::HandleInitSharedVolume().
590 */
591 HWTEST_F(PolicyProviderStubUnitTest, PolicyProviderStub_017, TestSize.Level1)
592 {
593 MockPolicyProvider mockProvider;
594 auto policyProviderStub = std::make_shared<PolicyProviderWrapper>(&mockProvider);
595 EXPECT_NE(policyProviderStub, nullptr);
596
597 MessageParcel data;
598 MessageParcel reply;
599
600 data.WriteInterfaceToken(IPolicyProviderIpc::GetDescriptor());
601
602 bool ret = policyProviderStub->CheckInterfaceToken(data);
603 EXPECT_EQ(ret, true);
604
605 ret = policyProviderStub->HandleInitSharedVolume(data, reply);
606 EXPECT_EQ(ret, true);
607 }
608 }
609 }