1 /*
2 * Copyright (c) 2022-2024 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 "plugin_manager_test.h"
17 #include <ipc_skeleton.h>
18 #include <iservice_registry.h>
19 #include "edm_ipc_interface_code.h"
20 #include "func_code_utils.h"
21 #define private public
22 #include "plugin_manager.h"
23 #undef private
24 #include "string_ex.h"
25 #include "system_ability_definition.h"
26
27 using namespace testing::ext;
28 using namespace OHOS;
29 using namespace OHOS::EDM;
30
31 namespace OHOS {
32 namespace EDM {
33 namespace TEST {
34 constexpr uint32_t INVAILD_PLUGIN_CODE = 10000;
35
SetUp()36 void PluginManagerTest::SetUp()
37 {
38 PluginManager::GetInstance()->AddPlugin(std::make_shared<TestPlugin>());
39 }
40
TearDown()41 void PluginManagerTest::TearDown()
42 {
43 PluginManager::GetInstance().reset();
44 }
45
46 /**
47 * @tc.name: TestGetInstance
48 * @tc.desc: Test PluginManager GetInstance func.
49 * @tc.type: FUNC
50 */
51 HWTEST_F(PluginManagerTest, TestGetInstance, TestSize.Level1)
52 {
53 ASSERT_TRUE(PluginManager::GetInstance() != nullptr);
54 ASSERT_TRUE(PluginManager::GetInstance().get() != nullptr);
55 }
56
57 /**
58 * @tc.name: TestGetPluginByFuncCode
59 * @tc.desc: Test PluginManager GetPluginByFuncCode func.
60 * @tc.type: FUNC
61 */
62 HWTEST_F(PluginManagerTest, TestGetPluginByFuncCode, TestSize.Level1)
63 {
64 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByFuncCode(
65 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, 0));
66 ASSERT_TRUE(plugin != nullptr);
67 ASSERT_TRUE(plugin->GetPolicyName() == "TestPlugin");
68 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByFuncCode(
69 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, INVAILD_PLUGIN_CODE)) == nullptr);
70 }
71
72 /**
73 * @tc.name: TestGetPluginByPolicyName
74 * @tc.desc: Test PluginManager GetPluginByPolicyName func.
75 * @tc.type: FUNC
76 */
77 HWTEST_F(PluginManagerTest, TestGetPluginByPolicyName, TestSize.Level1)
78 {
79 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByPolicyName("TestPlugin");
80 ASSERT_TRUE(plugin != nullptr);
81 ASSERT_TRUE(plugin->GetCode() == 0);
82 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByPolicyName("XXXXExamplePlugin") == nullptr);
83 }
84
85 /**
86 * @tc.name: TestGetPluginByCode
87 * @tc.desc: Test PluginManager GetPluginByCode func.
88 * @tc.type: FUNC
89 */
90 HWTEST_F(PluginManagerTest, TestGetPluginByCode, TestSize.Level1)
91 {
92 std::shared_ptr<IPlugin> plugin = PluginManager::GetInstance()->GetPluginByCode(0);
93 ASSERT_TRUE(plugin != nullptr);
94 ASSERT_TRUE(plugin->GetPolicyName() == "TestPlugin");
95 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByCode(INVAILD_PLUGIN_CODE) == nullptr);
96 }
97
98 /**
99 * @tc.name: TestEnhanceStrategyOnGetPolicy
100 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
101 * @tc.type: FUNC
102 */
103 HWTEST_F(PluginManagerTest, TestEnhanceStrategyOnGetPolicy, TestSize.Level1)
104 {
105 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::ENHANCE);
106 std::string policyData;
107 MessageParcel data;
108 MessageParcel reply;
109 ErrCode ret = strategy->OnGetExecute(
110 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, 0), policyData, data, reply, 0);
111 ASSERT_TRUE(ret == ERR_OK);
112 ret = strategy->OnGetExecute(
113 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, INVAILD_PLUGIN_CODE), policyData, data, reply, 0);
114 ASSERT_TRUE(ret == ERR_EDM_GET_POLICY_FAILED);
115 }
116
117 /**
118 * @tc.name: TestEnhanceStrategyOnSetPolicy
119 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
120 * @tc.type: FUNC
121 */
122 HWTEST_F(PluginManagerTest, TestEnhanceStrategyOnSetPolicy, TestSize.Level1)
123 {
124 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::ENHANCE);
125 MessageParcel data;
126 MessageParcel reply;
127 HandlePolicyData policyData;
128 ErrCode ret = strategy->OnSetExecute(
129 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, 0), data, reply, policyData, 0);
130 ASSERT_TRUE(ret == ERR_OK);
131 ret = strategy->OnSetExecute(
132 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, INVAILD_PLUGIN_CODE), data, reply, policyData, 0);
133 ASSERT_TRUE(ret == ERR_EDM_HANDLE_POLICY_FAILED);
134 }
135
136 /**
137 * @tc.name: TestSingleStrategyOnGetPolicy
138 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
139 * @tc.type: FUNC
140 */
141 HWTEST_F(PluginManagerTest, TestSingleStrategyOnGetPolicy, TestSize.Level1)
142 {
143 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::SINGLE);
144 std::string policyData;
145 MessageParcel data;
146 MessageParcel reply;
147 ErrCode ret = strategy->OnGetExecute(
148 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, 0), policyData, data, reply, 0);
149 ASSERT_TRUE(ret == ERR_OK);
150 ret = strategy->OnGetExecute(
151 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, INVAILD_PLUGIN_CODE), policyData, data, reply, 0);
152 ASSERT_TRUE(ret == ERR_EDM_GET_POLICY_FAILED);
153 }
154
155 /**
156 * @tc.name: TestSingleStrategyOnSetPolicy
157 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
158 * @tc.type: FUNC
159 */
160 HWTEST_F(PluginManagerTest, TestSingleStrategyOnSetPolicy, TestSize.Level1)
161 {
162 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::SINGLE);
163 MessageParcel data;
164 MessageParcel reply;
165 HandlePolicyData policyData;
166 ErrCode ret = strategy->OnSetExecute(
167 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, 0), data, reply, policyData, 0);
168 ASSERT_TRUE(ret == ERR_OK);
169 ret = strategy->OnSetExecute(
170 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, INVAILD_PLUGIN_CODE), data, reply, policyData, 0);
171 ASSERT_TRUE(ret == ERR_EDM_HANDLE_POLICY_FAILED);
172 }
173
174 /**
175 * @tc.name: TestReplaceStrategyOnGetPolicy
176 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
177 * @tc.type: FUNC
178 */
179 HWTEST_F(PluginManagerTest, TestReplaceStrategyOnGetPolicy, TestSize.Level1)
180 {
181 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::REPLACE);
182 std::string policyData;
183 MessageParcel data;
184 MessageParcel reply;
185 ErrCode ret = strategy->OnGetExecute(
186 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, 0), policyData, data, reply, 0);
187 ASSERT_TRUE(ret == ERR_OK);
188 ret = strategy->OnGetExecute(
189 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, INVAILD_PLUGIN_CODE), policyData, data, reply, 0);
190 ASSERT_TRUE(ret == ERR_EDM_GET_POLICY_FAILED);
191 }
192
193 /**
194 * @tc.name: TestReplaceStrategyOnSetPolicy
195 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
196 * @tc.type: FUNC
197 */
198 HWTEST_F(PluginManagerTest, TestReplaceStrategyOnSetPolicy, TestSize.Level1)
199 {
200 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::REPLACE);
201 MessageParcel data;
202 MessageParcel reply;
203 HandlePolicyData policyData;
204 ErrCode ret = strategy->OnSetExecute(
205 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, 0), data, reply, policyData, 0);
206 ASSERT_TRUE(ret == ERR_OK);
207 ret = strategy->OnSetExecute(
208 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, INVAILD_PLUGIN_CODE), data, reply, policyData, 0);
209 ASSERT_TRUE(ret == ERR_EDM_HANDLE_POLICY_FAILED);
210 }
211
212 /**
213 * @tc.name: TestEnhanceStrategyOnGetPolicyWithExtension
214 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
215 * @tc.type: FUNC
216 */
217 HWTEST_F(PluginManagerTest, TestEnhanceStrategyOnGetPolicyWithExtension, TestSize.Level1)
218 {
219 PluginManager::GetInstance()->AddExtensionPlugin(
220 std::make_shared<TestExtensionPlugin>(), 0, ExecuteStrategy::ENHANCE);
221 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::ENHANCE);
222 std::string policyData;
223 MessageParcel data;
224 MessageParcel reply;
225 ErrCode ret = strategy->OnGetExecute(
226 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, 0), policyData, data, reply, 0);
227 ASSERT_TRUE(ret == ERR_OK);
228 auto extensionPlugin = PluginManager::GetInstance()->pluginsCode_.find(1);
229 PluginManager::GetInstance()->pluginsCode_.erase(extensionPlugin);
230 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByCode(1) == nullptr);
231 }
232
233 /**
234 * @tc.name: TestEnhanceStrategyOnSetPolicyWithExtension
235 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
236 * @tc.type: FUNC
237 */
238 HWTEST_F(PluginManagerTest, TestEnhanceStrategyOnSetPolicyWithExtension, TestSize.Level1)
239 {
240 PluginManager::GetInstance()->AddExtensionPlugin(
241 std::make_shared<TestExtensionPlugin>(), 0, ExecuteStrategy::ENHANCE);
242 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::ENHANCE);
243 MessageParcel data;
244 MessageParcel reply;
245 HandlePolicyData policyData;
246 ErrCode ret = strategy->OnSetExecute(
247 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, 0), data, reply, policyData, 0);
248 ASSERT_TRUE(ret == ERR_OK);
249 auto extensionPlugin = PluginManager::GetInstance()->pluginsCode_.find(1);
250 PluginManager::GetInstance()->pluginsCode_.erase(extensionPlugin);
251 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByCode(1) == nullptr);
252 }
253
254 /**
255 * @tc.name: TestReplaceStrategyOnGetPolicyWithExtension
256 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
257 * @tc.type: FUNC
258 */
259 HWTEST_F(PluginManagerTest, TestReplaceStrategyOnGetPolicyWithExtension, TestSize.Level1)
260 {
261 PluginManager::GetInstance()->AddExtensionPlugin(
262 std::make_shared<TestExtensionPlugin>(), 0, ExecuteStrategy::REPLACE);
263 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::REPLACE);
264 std::string policyData;
265 MessageParcel data;
266 MessageParcel reply;
267 ErrCode ret = strategy->OnGetExecute(
268 POLICY_FUNC_CODE((uint32_t)FuncOperateType::GET, 0), policyData, data, reply, 0);
269 ASSERT_TRUE(ret == ERR_OK);
270 auto extensionPlugin = PluginManager::GetInstance()->pluginsCode_.find(1);
271 PluginManager::GetInstance()->pluginsCode_.erase(extensionPlugin);
272 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByCode(1) == nullptr);
273 }
274
275 /**
276 * @tc.name: TestReplaceStrategyOnSetPolicyWithExtension
277 * @tc.desc: Test PluginManager CreateExecuteStrategy func.
278 * @tc.type: FUNC
279 */
280 HWTEST_F(PluginManagerTest, TestReplaceStrategyOnSetPolicyWithExtension, TestSize.Level1)
281 {
282 PluginManager::GetInstance()->AddExtensionPlugin(
283 std::make_shared<TestExtensionPlugin>(), 0, ExecuteStrategy::REPLACE);
284 auto strategy = PluginManager::GetInstance()->CreateExecuteStrategy(ExecuteStrategy::REPLACE);
285 MessageParcel data;
286 MessageParcel reply;
287 HandlePolicyData policyData;
288 ErrCode ret = strategy->OnSetExecute(
289 POLICY_FUNC_CODE((uint32_t)FuncOperateType::SET, 0), data, reply, policyData, 0);
290 ASSERT_TRUE(ret == ERR_OK);
291 auto extensionPlugin = PluginManager::GetInstance()->pluginsCode_.find(1);
292 PluginManager::GetInstance()->pluginsCode_.erase(extensionPlugin);
293 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByCode(1) == nullptr);
294 }
295
296 /**
297 * @tc.name: TestLoadAllPlugin
298 * @tc.desc: Test PluginManager LoadAllPlugin func.
299 * @tc.type: FUNC
300 */
301 HWTEST_F(PluginManagerTest, TestLoadAllPlugin, TestSize.Level1)
302 {
303 auto pluginManager = PluginManager::GetInstance();
304 pluginManager->LoadAllPlugin();
305 ASSERT_TRUE(pluginManager->soLoadStateMap_[SONAME::DEVICE_CORE_PLUGIN_SO]->pluginHasInit);
306 ASSERT_TRUE(pluginManager->soLoadStateMap_[SONAME::COMMUNICATION_PLUGIN_SO]->pluginHasInit);
307 ASSERT_TRUE(pluginManager->soLoadStateMap_[SONAME::SYS_SERVICE_PLUGIN_SO]->pluginHasInit);
308 ASSERT_TRUE(pluginManager->soLoadStateMap_[SONAME::NEED_EXTRA_PLUGIN_SO]->pluginHasInit);
309 }
310
311 /**
312 * @tc.name: TestIsExtraPlugin
313 * @tc.desc: Test PluginManager IsExtraPlugin func.
314 * @tc.type: FUNC
315 */
316 HWTEST_F(PluginManagerTest, TestIsExtraPlugin, TestSize.Level1)
317 {
318 ASSERT_FALSE(PluginManager::GetInstance()->IsExtraPlugin(SONAME::DEVICE_CORE_PLUGIN_SO));
319 ASSERT_FALSE(PluginManager::GetInstance()->IsExtraPlugin(SONAME::COMMUNICATION_PLUGIN_SO));
320 ASSERT_FALSE(PluginManager::GetInstance()->IsExtraPlugin(SONAME::SYS_SERVICE_PLUGIN_SO));
321 ASSERT_FALSE(PluginManager::GetInstance()->IsExtraPlugin(SONAME::NEED_EXTRA_PLUGIN_SO));
322 ASSERT_FALSE(PluginManager::GetInstance()->IsExtraPlugin(SONAME::OLD_EDM_PLUGIN_SO));
323 ASSERT_TRUE(PluginManager::GetInstance()->IsExtraPlugin("custom_plugin.so"));
324 }
325
326 /**
327 * @tc.name: TestLoadPluginByFuncCode
328 * @tc.desc: Test PluginManager LoadPluginByFuncCode func.
329 * @tc.type: FUNC
330 */
331 HWTEST_F(PluginManagerTest, TestLoadPluginByFuncCode, TestSize.Level1)
332 {
333 std::uint32_t funcCode =
334 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::DISABLED_PRINTER);
335 PluginManager::GetInstance()->LoadPluginByFuncCode(funcCode);
336 ASSERT_TRUE(PluginManager::GetInstance()->soLoadStateMap_[SONAME::DEVICE_CORE_PLUGIN_SO]->pluginHasInit);
337 }
338
339 /**
340 * @tc.name: TestGetSoNameByCode
341 * @tc.desc: Test PluginManager GetSoNameByCode func.
342 * @tc.type: FUNC
343 */
344 HWTEST_F(PluginManagerTest, TestGetSoNameByCode, TestSize.Level1)
345 {
346 std::string soName;
347 bool ret = PluginManager::GetInstance()->GetSoNameByCode(EdmInterfaceCode::DISALLOW_ADD_LOCAL_ACCOUNT, soName);
348 ASSERT_TRUE(ret);
349 ASSERT_TRUE(soName == SONAME::DEVICE_CORE_PLUGIN_SO);
350
351 ret = PluginManager::GetInstance()->GetSoNameByCode(EdmInterfaceCode::IS_WIFI_ACTIVE, soName);
352 ASSERT_TRUE(ret);
353 ASSERT_TRUE(soName == SONAME::COMMUNICATION_PLUGIN_SO);
354
355 ret = PluginManager::GetInstance()->GetSoNameByCode(EdmInterfaceCode::SET_DATETIME, soName);
356 ASSERT_TRUE(ret);
357 ASSERT_TRUE(soName == SONAME::SYS_SERVICE_PLUGIN_SO);
358
359 ret = PluginManager::GetInstance()->GetSoNameByCode(EdmInterfaceCode::GET_DEVICE_SERIAL, soName);
360 ASSERT_TRUE(ret);
361 ASSERT_TRUE(soName == SONAME::NEED_EXTRA_PLUGIN_SO);
362
363 ret = PluginManager::GetInstance()->GetSoNameByCode(10000, soName);
364 ASSERT_FALSE(ret);
365 }
366
367 /**
368 * @tc.name: TestUnloadPlugin_NormalCase
369 * @tc.desc: Test PluginManager UnloadPlugin func with normal case.
370 * @tc.type: FUNC
371 */
372 HWTEST_F(PluginManagerTest, TestUnloadPlugin_NormalCase, TestSize.Level1)
373 {
374 // Load a plugin first
375 std::string soName = SONAME::DEVICE_CORE_PLUGIN_SO;
376 PluginManager::GetInstance()->LoadPlugin(soName);
377
378 // Verify plugin is loaded
379 auto loadState = PluginManager::GetInstance()->soLoadStateMap_[soName];
380 ASSERT_TRUE(loadState != nullptr);
381 ASSERT_TRUE(loadState->pluginHasInit);
382
383 // Unload the plugin
384 PluginManager::GetInstance()->UnloadPlugin(soName);
385 // Verify plugin is unloaded
386 EXPECT_EQ(PluginManager::GetInstance()->soLoadStateMap_.find(soName),
387 PluginManager::GetInstance()->soLoadStateMap_.end());
388 }
389
390 /**
391 * @tc.name: TestUnloadPlugin_NormalCase2
392 * @tc.desc: Test PluginManager UnloadPlugin func with normal case.
393 * @tc.type: FUNC
394 */
395 HWTEST_F(PluginManagerTest, TestUnloadPlugin_NormalCase2, TestSize.Level1)
396 {
397 // Load a plugin first
398 std::string soName = SONAME::COMMUNICATION_PLUGIN_SO;
399 PluginManager::GetInstance()->LoadPlugin(soName);
400
401 // Verify plugin is loaded
402 auto loadState = PluginManager::GetInstance()->soLoadStateMap_[soName];
403 ASSERT_TRUE(loadState != nullptr);
404 ASSERT_TRUE(loadState->pluginHasInit);
405
406 // Unload the plugin
407 PluginManager::GetInstance()->UnloadPlugin(soName);
408
409 // Verify plugin is unloaded
410 EXPECT_EQ(PluginManager::GetInstance()->soLoadStateMap_.find(soName),
411 PluginManager::GetInstance()->soLoadStateMap_.end());
412 }
413
414 /**
415 * @tc.name: TestUnloadPlugin_NormalCase3
416 * @tc.desc: Test PluginManager UnloadPlugin func with normal case.
417 * @tc.type: FUNC
418 */
419 HWTEST_F(PluginManagerTest, TestUnloadPlugin_NormalCase3, TestSize.Level1)
420 {
421 // Load a plugin first
422 std::string soName = SONAME::SYS_SERVICE_PLUGIN_SO;
423 PluginManager::GetInstance()->LoadPlugin(soName);
424
425 // Verify plugin is loaded
426 auto loadState = PluginManager::GetInstance()->soLoadStateMap_[soName];
427 ASSERT_TRUE(loadState != nullptr);
428 ASSERT_TRUE(loadState->pluginHasInit);
429
430 // Unload the plugin
431 PluginManager::GetInstance()->UnloadPlugin(soName);
432
433 // Verify plugin is unloaded
434 EXPECT_EQ(PluginManager::GetInstance()->soLoadStateMap_.find(soName),
435 PluginManager::GetInstance()->soLoadStateMap_.end());
436 }
437
438 /**
439 * @tc.name: TestUnloadPlugin_NormalCase4
440 * @tc.desc: Test PluginManager UnloadPlugin func with normal case.
441 * @tc.type: FUNC
442 */
443 HWTEST_F(PluginManagerTest, TestUnloadPlugin_NormalCase4, TestSize.Level1)
444 {
445 // Load a plugin first
446 std::string soName = SONAME::NEED_EXTRA_PLUGIN_SO;
447 PluginManager::GetInstance()->LoadPlugin(soName);
448
449 // Verify plugin is loaded
450 auto loadState = PluginManager::GetInstance()->soLoadStateMap_[soName];
451 ASSERT_TRUE(loadState != nullptr);
452 ASSERT_TRUE(loadState->pluginHasInit);
453
454 // Unload the plugin
455 PluginManager::GetInstance()->UnloadPlugin(soName);
456
457 // Verify plugin is unloaded
458 EXPECT_EQ(PluginManager::GetInstance()->soLoadStateMap_.find(soName),
459 PluginManager::GetInstance()->soLoadStateMap_.end());
460 }
461
462 /**
463 * @tc.name: TestUnloadPlugin_NormalCase5
464 * @tc.desc: Test PluginManager UnloadPlugin func with normal case.
465 * @tc.type: FUNC
466 */
467 HWTEST_F(PluginManagerTest, TestUnloadPlugin_NormalCase5, TestSize.Level1)
468 {
469 // Load a plugin first
470 PluginManager::GetInstance()->LoadExtraPlugin();
471 if (PluginManager::GetInstance()->soLoadStateMap_.empty()) {
472 return;
473 }
474
475 std::string soName = PluginManager::GetInstance()->soLoadStateMap_.begin()->first;
476 // Verify plugin is loaded
477 auto loadState = PluginManager::GetInstance()->soLoadStateMap_[soName];
478 ASSERT_TRUE(loadState != nullptr);
479 ASSERT_TRUE(loadState->pluginHasInit);
480
481 // Unload the plugin
482 PluginManager::GetInstance()->UnloadPlugin(soName);
483
484 // Verify plugin is unloaded
485 EXPECT_EQ(PluginManager::GetInstance()->soLoadStateMap_.find(soName),
486 PluginManager::GetInstance()->soLoadStateMap_.end());
487 }
488
489 /**
490 * @tc.name: TestRemovePlugin_NormalCase
491 * @tc.desc: Test PluginManager RemovePlugin func with normal case.
492 * @tc.type: FUNC
493 * @tc.require: AR000HFTD5
494 */
495 HWTEST_F(PluginManagerTest, TestRemovePlugin_NormalCase, TestSize.Level1)
496 {
497 // Setup: Add a test plugin
498 auto plugin = std::make_shared<TestPlugin>();
499 PluginManager::GetInstance()->AddPlugin(plugin);
500
501 // Verify plugin is added
502 ASSERT_TRUE(PluginManager::GetInstance()->GetPluginByCode(0) != nullptr);
503
504 // Remove the plugin
505 PluginManager::GetInstance()->RemovePlugin(plugin);
506
507 // Verify plugin is removed
508 EXPECT_TRUE(PluginManager::GetInstance()->GetPluginByCode(0) == nullptr);
509 EXPECT_EQ(PluginManager::GetInstance()->pluginsCode_.find(0),
510 PluginManager::GetInstance()->pluginsCode_.end());
511 EXPECT_EQ(PluginManager::GetInstance()->pluginsName_.find("TestPlugin"),
512 PluginManager::GetInstance()->pluginsName_.end());
513 }
514
515 /**
516 * @tc.name: TestRemovePlugin_NullPlugin
517 * @tc.desc: Test PluginManager RemovePlugin with null plugin.
518 * @tc.type: FUNC
519 * @tc.require: AR000HFTD5
520 */
521 HWTEST_F(PluginManagerTest, TestRemovePlugin_NullPlugin, TestSize.Level1)
522 {
523 // Verify no changes to plugin manager state
524 EXPECT_TRUE(PluginManager::GetInstance()->GetPluginByCode(0) != nullptr);
525 }
526
527 /**
528 * @tc.name: TestRemovePlugin_NonExistentPlugin
529 * @tc.desc: Test PluginManager RemovePlugin with non-existent plugin.
530 * @tc.type: FUNC
531 * @tc.require: AR000HFTD5
532 */
533 HWTEST_F(PluginManagerTest, TestRemovePlugin_NonExistentPlugin, TestSize.Level1)
534 {
535 // Create a plugin but don't add it
536 auto nonExistentPlugin = std::make_shared<TestPlugin>();
537 nonExistentPlugin->policyCode_ = 999; // Use a code that's not registered
538
539 // Verify no changes to plugin manager state
540 EXPECT_TRUE(PluginManager::GetInstance()->GetPluginByCode(0) != nullptr);
541 }
542
543 } // namespace TEST
544 } // namespace EDM
545 } // namespace OHOS
546