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