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_handler.h"
19 #include "policy_provider_ipc_proxy.h"
20
21 using namespace testing::ext;
22 class PolicyProviderIpcProxy;
23
24 namespace OHOS {
25 namespace AudioStandard {
26 class PolicyHandlerUnitTest : public testing::Test {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp();
31 void TearDown();
32 };
33
34 class AudioSharedMemoryTest : public AudioSharedMemory {
35 public:
GetBase()36 uint8_t *GetBase() override { return nullptr; };
GetSize()37 size_t GetSize() override { return 0; };
GetFd()38 int GetFd() override { return 0; };
GetName()39 std::string GetName() override { return "abc"; };
Marshalling(Parcel & parcel) const40 bool Marshalling(Parcel &parcel) const override { return true; };
41 };
42
SetUpTestCase(void)43 void PolicyHandlerUnitTest::SetUpTestCase(void) {}
44
TearDownTestCase(void)45 void PolicyHandlerUnitTest::TearDownTestCase(void) {}
46
SetUp(void)47 void PolicyHandlerUnitTest::SetUp(void) {}
48
TearDown(void)49 void PolicyHandlerUnitTest::TearDown(void) {}
50
51 /**
52 * @tc.name : Test PolicyHandler API
53 * @tc.type : FUNC
54 * @tc.number: PolicyHandler_001
55 * @tc.desc : Test PolicyHandler interface.
56 */
57 HWTEST_F(PolicyHandlerUnitTest, PolicyHandler_001, TestSize.Level1)
58 {
59 auto policyHandler = std::make_shared<PolicyHandler>();
60 EXPECT_NE(policyHandler, nullptr);
61
62 std::string dumpString = "";
63 policyHandler->iPolicyProvider_ = nullptr;
64 policyHandler->policyVolumeMap_ = nullptr;
65 policyHandler->volumeVector_ = nullptr;
66
67 policyHandler->Dump(dumpString);
68 EXPECT_EQ(dumpString, "PolicyHandler is null...\n");
69 }
70
71 /**
72 * @tc.name : Test PolicyHandler API
73 * @tc.type : FUNC
74 * @tc.number: PolicyHandler_002
75 * @tc.desc : Test PolicyHandler interface.
76 */
77 HWTEST_F(PolicyHandlerUnitTest, PolicyHandler_002, TestSize.Level1)
78 {
79 auto policyHandler = std::make_shared<PolicyHandler>();
80 EXPECT_NE(policyHandler, nullptr);
81
82 std::string dumpString = "";
83 sptr<IRemoteObject> impl = nullptr;
84 policyHandler->iPolicyProvider_ = new PolicyProviderIpcProxy(impl);
85 EXPECT_NE(policyHandler->iPolicyProvider_, nullptr);
86 policyHandler->policyVolumeMap_ = nullptr;
87 policyHandler->volumeVector_ = nullptr;
88
89 policyHandler->Dump(dumpString);
90 EXPECT_EQ(dumpString, "PolicyHandler is null...\n");
91 }
92
93 /**
94 * @tc.name : Test PolicyHandler API
95 * @tc.type : FUNC
96 * @tc.number: PolicyHandler_003
97 * @tc.desc : Test PolicyHandler interface.
98 */
99 HWTEST_F(PolicyHandlerUnitTest, PolicyHandler_003, TestSize.Level1)
100 {
101 auto policyHandler = std::make_shared<PolicyHandler>();
102 EXPECT_NE(policyHandler, nullptr);
103
104 std::string dumpString = "";
105 sptr<IRemoteObject> impl = nullptr;
106 policyHandler->iPolicyProvider_ = new PolicyProviderIpcProxy(impl);
107 EXPECT_NE(policyHandler->iPolicyProvider_, nullptr);
108
109 policyHandler->policyVolumeMap_ = std::make_shared<AudioSharedMemoryTest>();
110 EXPECT_NE(policyHandler->policyVolumeMap_, nullptr);
111
112 policyHandler->volumeVector_ = nullptr;
113
114 policyHandler->Dump(dumpString);
115 EXPECT_EQ(dumpString, "PolicyHandler is null...\n");
116 }
117
118 /**
119 * @tc.name : Test PolicyHandler API
120 * @tc.type : FUNC
121 * @tc.number: PolicyHandler_004
122 * @tc.desc : Test PolicyHandler interface.
123 */
124 HWTEST_F(PolicyHandlerUnitTest, PolicyHandler_004, TestSize.Level1)
125 {
126 auto policyHandler = std::make_shared<PolicyHandler>();
127 EXPECT_NE(policyHandler, nullptr);
128
129 std::string dumpString = "";
130 sptr<IRemoteObject> impl = nullptr;
131 policyHandler->iPolicyProvider_ = new PolicyProviderIpcProxy(impl);
132 EXPECT_NE(policyHandler->iPolicyProvider_, nullptr);
133
134 policyHandler->policyVolumeMap_ = std::make_shared<AudioSharedMemoryTest>();
135 EXPECT_NE(policyHandler->policyVolumeMap_, nullptr);
136
137 Volume volume[IPolicyProvider::GetVolumeVectorSize()];
138 policyHandler->volumeVector_ = volume;
139
140 bool sharedAbsVolumeScene = true;
141 policyHandler->sharedAbsVolumeScene_ = &sharedAbsVolumeScene;
142 policyHandler->Dump(dumpString);
143 }
144
145 /**
146 * @tc.name : Test PolicyHandler API
147 * @tc.type : FUNC
148 * @tc.number: PolicyHandler_005
149 * @tc.desc : Test PolicyHandler interface.
150 */
151 HWTEST_F(PolicyHandlerUnitTest, PolicyHandler_005, TestSize.Level1)
152 {
153 auto policyHandler = std::make_shared<PolicyHandler>();
154 EXPECT_NE(policyHandler, nullptr);
155
156 std::string dumpString = "";
157 sptr<IRemoteObject> impl = nullptr;
158 policyHandler->iPolicyProvider_ = new PolicyProviderIpcProxy(impl);
159 EXPECT_NE(policyHandler->iPolicyProvider_, nullptr);
160
161 policyHandler->policyVolumeMap_ = std::make_shared<AudioSharedMemoryTest>();
162 EXPECT_NE(policyHandler->policyVolumeMap_, nullptr);
163
164 Volume volume[IPolicyProvider::GetVolumeVectorSize()];
165 policyHandler->volumeVector_ = volume;
166 policyHandler->sharedAbsVolumeScene_ = nullptr;
167 policyHandler->Dump(dumpString);
168 }
169
170 /**
171 * @tc.name : Test PolicyHandler API
172 * @tc.type : FUNC
173 * @tc.number: PolicyHandler_006
174 * @tc.desc : Test PolicyHandler interface.
175 */
176 HWTEST_F(PolicyHandlerUnitTest, PolicyHandler_006, TestSize.Level1)
177 {
178 auto policyHandler = std::make_shared<PolicyHandler>();
179 EXPECT_NE(policyHandler, nullptr);
180
181 sptr<IRemoteObject> impl = nullptr;
182 policyHandler->iPolicyProvider_ = new PolicyProviderIpcProxy(impl);
183 EXPECT_NE(policyHandler->iPolicyProvider_, nullptr);
184
185 sptr<IPolicyProviderIpc> policyProvider = new PolicyProviderIpcProxy(impl);
186 EXPECT_NE(policyProvider, nullptr);
187
188 auto ret = policyHandler->ConfigPolicyProvider(policyProvider);
189 EXPECT_EQ(ret, false);
190 }
191
192 /**
193 * @tc.name : Test PolicyHandler API
194 * @tc.type : FUNC
195 * @tc.number: PolicyHandler_007
196 * @tc.desc : Test PolicyHandler interface.
197 */
198 HWTEST_F(PolicyHandlerUnitTest, PolicyHandler_007, TestSize.Level1)
199 {
200 auto policyHandler = std::make_shared<PolicyHandler>();
201 EXPECT_NE(policyHandler, nullptr);
202
203 sptr<IRemoteObject> impl = nullptr;
204 policyHandler->iPolicyProvider_ = new PolicyProviderIpcProxy(impl);
205 EXPECT_NE(policyHandler->iPolicyProvider_, nullptr);
206
207 Volume volume[IPolicyProvider::GetVolumeVectorSize()];
208 policyHandler->volumeVector_ = volume;
209
210 AudioVolumeType streamType = AudioStreamType::STREAM_VOICE_CALL;
211 DeviceType deviceType = DeviceType::DEVICE_TYPE_INVALID;
212 Volume vol;
213
214 auto ret = policyHandler->GetSharedVolume(streamType, deviceType, vol);
215 EXPECT_EQ(ret, false);
216 }
217 } // namespace OHOS::AudioStandard
218 } // namespace OHOS