1 /*
2 * Copyright (c) 2022-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 "hdf_operate.h"
17
18 #include <gtest/gtest.h>
19 #include "iremote_stub.h"
20
21 #include "component_loader.h"
22 #include "distributed_hardware_errno.h"
23 #include "distributed_hardware_log.h"
24 #include "publisher_listener_stub.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace DistributedHardware {
31 class HdfOperateTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37
38 class TestPublisherListenerStub : public OHOS::DistributedHardware::PublisherListenerStub {
39 public:
40 TestPublisherListenerStub() = default;
41 virtual ~TestPublisherListenerStub() = default;
OnMessage(const DHTopic topic,const std::string & message)42 void OnMessage(const DHTopic topic, const std::string& message)
43 {
44 (void)topic;
45 (void)message;
46 }
47 };
48 };
49
50 constexpr int32_t TEST_COMP_SINK_SA_ID = 4804;
51 constexpr int32_t TEST_SINK_SA_ID = 12345;
52 constexpr int32_t TEST_SOURCE_SA_ID = 12345;
53
SetUpTestCase(void)54 void HdfOperateTest::SetUpTestCase(void)
55 {
56 DHLOGI("HdfOperateTest::SetUpTestCase");
57 }
58
TearDownTestCase(void)59 void HdfOperateTest::TearDownTestCase(void)
60 {
61 DHLOGI("HdfOperateTest::TearDownTestCase");
62 }
63
SetUp(void)64 void HdfOperateTest::SetUp(void)
65 {
66 DHLOGI("HdfOperateTest::SetUp");
67 }
68
TearDown(void)69 void HdfOperateTest::TearDown(void)
70 {
71 DHLOGI("HdfOperateTest::TearDown");
72 }
73
SetUpComponentLoaderConfig()74 static void SetUpComponentLoaderConfig()
75 {
76 if (ComponentLoader::GetInstance().compHandlerMap_.find(DHType::AUDIO)
77 == ComponentLoader::GetInstance().compHandlerMap_.end()) {
78 CompHandler handler;
79 handler.compConfig.name = "distributed_audio";
80 handler.compConfig.type = DHType::AUDIO;
81 handler.compConfig.compHandlerLoc = "libdistributed_camera_handler.z.so";
82 handler.compConfig.compHandlerVersion = "1.0";
83 handler.compConfig.compSourceLoc = "libdistributed_camera_source_sdk.z.so";
84 handler.compConfig.compSourceVersion = "1.0";
85 handler.compConfig.compSinkLoc = "libdistributed_camera_sink_sdk.z.so";
86 handler.compConfig.compSinkVersion = "2.0";
87 handler.compConfig.compSinkSaId = TEST_COMP_SINK_SA_ID;
88 handler.compConfig.haveFeature = false;
89 handler.hardwareHandler = nullptr;
90 handler.sourceHandler = nullptr;
91 handler.sinkHandler = nullptr;
92 handler.type = DHType::AUDIO;
93 handler.sinkSaId = TEST_SINK_SA_ID;
94 handler.sourceSaId = TEST_SOURCE_SA_ID;
95 ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = handler;
96 }
97 }
98
SetDownComponentLoaderConfig()99 static void SetDownComponentLoaderConfig()
100 {
101 auto itHandler = ComponentLoader::GetInstance().compHandlerMap_.find(DHType::AUDIO);
102 if (itHandler != ComponentLoader::GetInstance().compHandlerMap_.end()) {
103 CompHandler &handler = itHandler->second;
104 if (handler.sinkSaId == TEST_SINK_SA_ID && handler.sourceSaId == TEST_SOURCE_SA_ID) {
105 ComponentLoader::GetInstance().compHandlerMap_.erase(itHandler);
106 }
107 }
108 }
109
110 /**
111 * @tc.name: LoadDistributedHDF_001
112 * @tc.desc: Verify LoadDistributedHDF func
113 * @tc.type: FUNC
114 * @tc.require: AR000GHSJM
115 */
116 HWTEST_F(HdfOperateTest, LoadDistributedHDF_001, TestSize.Level1)
117 {
118 DHLOGI("HdfOperateTest::LoadDistributedHDF_001");
119 SetUpComponentLoaderConfig();
120 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().LoadDistributedHDF(DHType::AUDIO));
121 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().LoadDistributedHDF(DHType::AUDIO));
122 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().UnLoadDistributedHDF(DHType::AUDIO));
123 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().UnLoadDistributedHDF(DHType::AUDIO));
124 SetDownComponentLoaderConfig();
125 }
126
127 #ifndef DHARDWARE_CLOSE_UT
128 /**
129 * @tc.name: LoadDistributedHDF_002
130 * @tc.desc: Verify LoadDistributedHDF func
131 * @tc.type: FUNC
132 * @tc.require: AR000GHSJM
133 */
134 HWTEST_F(HdfOperateTest, LoadDistributedHDF_002, TestSize.Level1)
135 {
136 DHLOGI("HdfOperateTest::LoadDistributedHDF_002");
137 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().LoadDistributedHDF(DHType::AUDIO));
138 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().UnLoadDistributedHDF(DHType::AUDIO));
139 }
140 #endif
141
142 /**
143 * @tc.name: LoadDistributedHDF_003
144 * @tc.desc: Verify LoadDistributedHDF func
145 * @tc.type: FUNC
146 * @tc.require: AR000GHSJM
147 */
148 HWTEST_F(HdfOperateTest, LoadDistributedHDF_003, TestSize.Level1)
149 {
150 DHLOGI("HdfOperateTest::LoadDistributedHDF_003");
151 HdfOperateManager::GetInstance().hdfOperateMap_[DHType::AUDIO] = nullptr;
152 int32_t ret = HdfOperateManager::GetInstance().LoadDistributedHDF(DHType::AUDIO);
153 HdfOperateManager::GetInstance().hdfOperateMap_.clear();
154 EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret);
155 }
156
157 /**
158 * @tc.name: UnLoadDistributedHDF_001
159 * @tc.desc: Verify UnLoadDistributedHDF func
160 * @tc.type: FUNC
161 * @tc.require: AR000GHSJM
162 */
163 HWTEST_F(HdfOperateTest, UnLoadDistributedHDF_001, TestSize.Level1)
164 {
165 DHLOGI("HdfOperateTest::UnLoadDistributedHDF_001");
166 HdfOperateManager::GetInstance().ResetRefCount(DHType::AUDIO);
167 int32_t ret = HdfOperateManager::GetInstance().UnLoadDistributedHDF(DHType::AUDIO);
168 EXPECT_EQ(DH_FWK_SUCCESS, ret);
169 }
170
171 /**
172 * @tc.name: UnLoadDistributedHDF_002
173 * @tc.desc: Verify UnLoadDistributedHDF func
174 * @tc.type: FUNC
175 * @tc.require: AR000GHSJM
176 */
177 HWTEST_F(HdfOperateTest, UnLoadDistributedHDF_002, TestSize.Level1)
178 {
179 DHLOGI("HdfOperateTest::UnLoadDistributedHDF_002");
180 HdfOperateManager::GetInstance().hdfOperateMap_[DHType::AUDIO] = nullptr;
181 int32_t ret = HdfOperateManager::GetInstance().UnLoadDistributedHDF(DHType::AUDIO);
182 HdfOperateManager::GetInstance().hdfOperateMap_.clear();
183 EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret);
184 }
185
186 /**
187 * @tc.name: ResetRefCount_001
188 * @tc.desc: Verify ResetRefCount func
189 * @tc.type: FUNC
190 * @tc.require: AR000GHSJM
191 */
192 HWTEST_F(HdfOperateTest, ResetRefCount_001, TestSize.Level1)
193 {
194 DHLOGI("HdfOperateTest::ResetRefCount_001");
195 SetUpComponentLoaderConfig();
196 HdfOperateManager::GetInstance().hdfOperateMap_.clear();
197 HdfOperateManager::GetInstance().ResetRefCount(DHType::AUDIO);
198 int32_t ret = HdfOperateManager::GetInstance().LoadDistributedHDF(DHType::AUDIO);
199 EXPECT_EQ(DH_FWK_SUCCESS, ret);
200 HdfOperateManager::GetInstance().ResetRefCount(DHType::AUDIO);
201 ret = HdfOperateManager::GetInstance().LoadDistributedHDF(DHType::AUDIO);
202 EXPECT_EQ(DH_FWK_SUCCESS, ret);
203 ret = HdfOperateManager::GetInstance().UnLoadDistributedHDF(DHType::AUDIO);
204 SetDownComponentLoaderConfig();
205 EXPECT_EQ(DH_FWK_SUCCESS, ret);
206 }
207
208 /**
209 * @tc.name: RigidGetSourcePtr_001
210 * @tc.desc: Verify RigidGetSourcePtr func
211 * @tc.type: FUNC
212 * @tc.require: AR000GHSJM
213 */
214 HWTEST_F(HdfOperateTest, RigidGetSourcePtr_001, TestSize.Level1)
215 {
216 DHLOGI("HdfOperateTest::RigidGetSourcePtr_001");
217 IDistributedHardwareSource *sourcePtr = nullptr;
218 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().RigidGetSourcePtr(DHType::AUDIO, sourcePtr));
219 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().RigidGetSourcePtr(DHType::AUDIO, sourcePtr));
220 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().RigidReleaseSourcePtr(DHType::AUDIO));
221 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().RigidReleaseSourcePtr(DHType::AUDIO));
222 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().RigidGetSourcePtr(DHType::CAMERA, sourcePtr));
223 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().RigidGetSourcePtr(DHType::CAMERA, sourcePtr));
224 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().RigidReleaseSourcePtr(DHType::CAMERA));
225 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().RigidReleaseSourcePtr(DHType::CAMERA));
226 EXPECT_EQ(ERR_DH_FWK_NO_HDF_SUPPORT,
227 HdfOperateManager::GetInstance().RigidGetSourcePtr(DHType::UNKNOWN, sourcePtr));
228 }
229
230 /**
231 * @tc.name: RigidReleaseSourcePtr_001
232 * @tc.desc: Verify RigidReleaseSourcePtr func
233 * @tc.type: FUNC
234 * @tc.require: AR000GHSJM
235 */
236 HWTEST_F(HdfOperateTest, RigidReleaseSourcePtr_001, TestSize.Level1)
237 {
238 DHLOGI("HdfOperateTest::RigidReleaseSourcePtr_001");
239 EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().RigidReleaseSourcePtr(DHType::AUDIO));
GetInstance()240 HdfOperateManager::GetInstance().sourceHandlerDataMap_[DHType::AUDIO] = HdfOperateManager::SourceHandlerData {
241 .refCount = 1, .sourceHandler = nullptr, .sourcePtr = nullptr
242 };
243 auto ret = HdfOperateManager::GetInstance().RigidReleaseSourcePtr(DHType::AUDIO);
244 HdfOperateManager::GetInstance().sourceHandlerDataMap_.erase(DHType::AUDIO);
245 EXPECT_EQ(ERR_DH_FWK_LOADER_DLCLOSE_FAIL, ret);
246 }
247
248 HWTEST_F(HdfOperateTest, AddDeathRecipient_001, TestSize.Level1)
249 {
250 sptr<IRemoteObject> remote = nullptr;
251 auto ret = HdfOperateManager::GetInstance().AddDeathRecipient(DHType::UNKNOWN, remote);
252 EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret);
253 }
254
255 HWTEST_F(HdfOperateTest, AddDeathRecipient_002, TestSize.Level1)
256 {
257 sptr<IRemoteObject> remote(new TestPublisherListenerStub());
258 auto ret = HdfOperateManager::GetInstance().AddDeathRecipient(DHType::UNKNOWN, remote);
259 EXPECT_EQ(ERR_DH_FWK_NO_HDF_SUPPORT, ret);
260 }
261
262 HWTEST_F(HdfOperateTest, RemoveDeathRecipient_001, TestSize.Level1)
263 {
264 sptr<IRemoteObject> remote = nullptr;
265 auto ret = HdfOperateManager::GetInstance().RemoveDeathRecipient(DHType::UNKNOWN, remote);
266 EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret);
267 }
268
269 HWTEST_F(HdfOperateTest, RemoveDeathRecipient_002, TestSize.Level1)
270 {
271 sptr<IRemoteObject> remote(new TestPublisherListenerStub());
272 auto ret = HdfOperateManager::GetInstance().RemoveDeathRecipient(DHType::UNKNOWN, remote);
273 EXPECT_EQ(ERR_DH_FWK_NO_HDF_SUPPORT, ret);
274 }
275 } // namespace DistributedHardware
276 } // namespace OHOS
277