1 /*
2 * Copyright (c) 2023 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
18 #include "mock_native_module_manager.h"
19 #include "module_load_checker.h"
20
21 using namespace testing::ext;
22
23 class ModuleManagerTest : public testing::Test {
24 public:
ModuleManagerTest()25 ModuleManagerTest() {}
26
~ModuleManagerTest()27 virtual ~ModuleManagerTest() {}
28
29 static void SetUpTestCase();
30
31 static void TearDownTestCase();
32
33 void SetUp();
34
35 void TearDown();
36 };
37
SetUpTestCase()38 void ModuleManagerTest::SetUpTestCase() {}
39
TearDownTestCase()40 void ModuleManagerTest::TearDownTestCase() {}
41
SetUp()42 void ModuleManagerTest::SetUp()
43 {
44 MockResetModuleManagerState();
45 }
46
TearDown()47 void ModuleManagerTest::TearDown()
48 {
49 MockResetModuleManagerState();
50 }
51
52 constexpr char MODULE_NS[] = "moduleNs_";
53
54 /*
55 * @tc.name: LoadNativeModuleTest_001
56 * @tc.desc: test NativeModule's LoadNativeModule function
57 * @tc.type: FUNC
58 * @tc.require: #I76XTV
59 */
60 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_001, TestSize.Level1)
61 {
62 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_001 starts";
63
64 std::string errInfo = "";
65 NativeModuleManager* moduleManager = NativeModuleManager::GetInstance();
66 NativeModule *module = moduleManager->LoadNativeModule(nullptr, nullptr, false, errInfo, false, nullptr);
67 EXPECT_EQ(module, nullptr);
68
69 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_001 ends";
70 }
71
72 /*
73 * @tc.name: LoadNativeModuleTest_002
74 * @tc.desc: test NativeModule's LoadNativeModule function
75 * @tc.type: FUNC
76 * @tc.require: #I76XTV
77 */
78 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_002, TestSize.Level1)
79 {
80 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_002 starts";
81
82 const char *moduleName = "moduleName_002";
83 NativeModule mockModule;
84 NativeModule *module;
85 NativeModuleManager* moduleManager = NativeModuleManager::GetInstance();
86
87 MockFindNativeModuleByDisk(&mockModule);
88
89 std::string errInfo = "";
90 module = moduleManager->LoadNativeModule(moduleName, nullptr, false, errInfo, false, "");
91 EXPECT_EQ(module, &mockModule);
92
93 module = moduleManager->LoadNativeModule(moduleName, nullptr, false, errInfo, false);
94 EXPECT_EQ(module, &mockModule);
95
96 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_002 end";
97 }
98
99 /*
100 * @tc.name: LoadNativeModuleTest_003
101 * @tc.desc: test NativeModule's LoadNativeModule function
102 * @tc.type: FUNC
103 * @tc.require: #I76XTV
104 */
105 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_003, TestSize.Level1)
106 {
107 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_003 starts";
108
109 const char *moduleName = "moduleName_003";
110 NativeModule *module;
111 NativeModuleManager* moduleManager = NativeModuleManager::GetInstance();
112
113 std::string errInfo = "";
114 module = moduleManager->LoadNativeModule(moduleName, nullptr, false, errInfo, false, "");
115 EXPECT_EQ(module, nullptr);
116
117 module = moduleManager->LoadNativeModule(moduleName, nullptr, false, errInfo, false);
118 EXPECT_EQ(module, nullptr);
119
120 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_003 end";
121 }
122
123 /*
124 * @tc.name: LoadNativeModuleTest_004
125 * @tc.desc: test NativeModule's LoadNativeModule function
126 * @tc.type: FUNC
127 * @tc.require: #I76XTV
128 */
129 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_004, TestSize.Level1)
130 {
131 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_004 starts";
132
133 const char *moduleName = "moduleName_004";
134 const char *relativePath = "relativePath_004";
135 NativeModule mockModule;
136 NativeModule *module;
137 NativeModuleManager* moduleManager = NativeModuleManager::GetInstance();
138
139 MockFindNativeModuleByDisk(&mockModule);
140
141 std::string errInfo = "";
142 module = moduleManager->LoadNativeModule(moduleName, nullptr, false, errInfo, false, relativePath);
143 EXPECT_EQ(module, &mockModule);
144 moduleManager->Register(module);
145
146 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_004 end";
147 }
148
149 /*
150 * @tc.name: LoadNativeModuleTest_005
151 * @tc.desc: test NativeModule's LoadNativeModule function
152 * @tc.type: FUNC
153 * @tc.require: #I76XTV
154 */
155 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_005, TestSize.Level1)
156 {
157 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_005 starts";
158
159 const char *moduleName = "moduleName_005";
160 const char *relativePath = "errorPath_005";
161
162 NativeModuleManager* moduleManager = NativeModuleManager::GetInstance();
163
164 MockCheckModuleLoadable(true);
165 MockLoadModuleLibrary(nullptr);
166
167 std::string errInfo = "";
168 NativeModule *module = moduleManager->LoadNativeModule(moduleName, nullptr,
169 false, errInfo, false, relativePath);
170 EXPECT_EQ(module, nullptr);
171
172 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_005 end";
173 }
174
175 /*
176 * @tc.name: LoadNativeModuleTest_006
177 * @tc.desc: test NativeModule's SetNativeEngine function
178 * @tc.type: FUNC
179 * @tc.require: #I76XTV
180 */
181 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_006, TestSize.Level1)
182 {
183 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_006 starts";
184
185 std::string moduleKey = "this is moduleKey";
186 const char *moduleName = "moduleName_006";
187 NativeEngine* engine = nullptr;
188 NativeModuleManager moduleManager;
189 moduleManager.SetNativeEngine(moduleKey, engine);
190
191 MockFindNativeModuleByCache(nullptr);
192 std::string result = moduleManager.GetModuleFileName(moduleName, true);
193 EXPECT_TRUE(result.empty());
194 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_006 end";
195 }
196
197 /*
198 * @tc.name: LoadNativeModuleTest_007
199 * @tc.desc: test NativeModule's GetModuleFileName function
200 * @tc.type: FUNC
201 * @tc.require: #I76XTV
202 */
203 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_007, TestSize.Level1)
204 {
205 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_007 starts";
206 const char *moduleName = "moduleName_007";
207 NativeModule mockModule;
208 NativeModuleManager moduleManager;
209
210 MockFindNativeModuleByCache(&mockModule);
211 std::string result = moduleManager.GetModuleFileName(moduleName, true);
212 EXPECT_FALSE(result.empty());
213 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_007 end";
214 }
215
216 /*
217 * @tc.name: LoadNativeModuleTest_008
218 * @tc.desc: test NativeModule's Register function
219 * @tc.type: FUNC
220 * @tc.require: #I76XTV
221 */
222 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_008, TestSize.Level1)
223 {
224 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_008 starts";
225 std::string moduleName = "moduleName_008";
226 const char* libPath = nullptr;
227 std::shared_ptr<NativeModuleManager> moduleManager = std::make_shared<NativeModuleManager>();
228 ASSERT_NE(nullptr, moduleManager);
229
230 moduleManager->Register(nullptr);
231 moduleManager->CreateSharedLibsSonames();
232 std::string nsName;
233 bool res = moduleManager->GetLdNamespaceName(moduleName, nsName);
234 EXPECT_EQ(res, false);
235 moduleManager->CreateLdNamespace(moduleName, libPath, true);
236 res = moduleManager->GetLdNamespaceName(moduleName, nsName);
237 EXPECT_EQ(res, true);
238 EXPECT_STREQ(nsName.c_str(), (MODULE_NS + moduleName).c_str());
239 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_008 end";
240 }
241
242 /*
243 * @tc.name: LoadNativeModuleTest_009
244 * @tc.desc: test NativeModule's CreateLdNamespace function
245 * @tc.type: FUNC
246 * @tc.require: #I76XTV
247 */
248 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_009, TestSize.Level1)
249 {
250 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_009 starts";
251 std::string moduleName = "moduleName_009";
252 const char* libPath = nullptr;
253 std::shared_ptr<NativeModuleManager> moduleManager = std::make_shared<NativeModuleManager>();
254 ASSERT_NE(nullptr, moduleManager);
255
256 std::string nsName;
257 bool res = moduleManager->GetLdNamespaceName(moduleName, nsName);
258 EXPECT_EQ(res, false);
259 moduleManager->CreateLdNamespace(moduleName, libPath, false);
260 res = moduleManager->GetLdNamespaceName(moduleName, nsName);
261 EXPECT_EQ(res, true);
262 EXPECT_STREQ(nsName.c_str(), (MODULE_NS + moduleName).c_str());
263 std::vector<std::string> appLibPath;
264 moduleManager->SetAppLibPath(moduleName, appLibPath, false);
265 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_009 end";
266 }
267
268 /*
269 * @tc.name: LoadNativeModuleTest_010
270 * @tc.desc: test NativeModule's SetAppLibPath function
271 * @tc.type: FUNC
272 * @tc.require: #I76XTV
273 */
274 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_010, TestSize.Level1)
275 {
276 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_010 starts";
277 std::string moduleName = "moduleName_010";
278 std::shared_ptr<NativeModuleManager> moduleManager = std::make_shared<NativeModuleManager>();
279 ASSERT_NE(nullptr, moduleManager);
280
281 std::vector<std::string> appLibPath1 = { "0", "1", "2" };
282 moduleManager->SetAppLibPath(moduleName, appLibPath1, false);
283 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_010 end";
284 }
285
286 /*
287 * @tc.name: LoadNativeModuleTest_011
288 * @tc.desc: test NativeModule's FindNativeModuleByDisk function
289 * @tc.type: FUNC
290 * @tc.require: #I76XTV
291 */
292 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_011, TestSize.Level1)
293 {
294 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_011 starts";
295 const char* moduleName = "moduleName_010";
296 std::shared_ptr<NativeModuleManager> moduleManager = std::make_shared<NativeModuleManager>();
297 ASSERT_NE(nullptr, moduleManager);
298 MockFindNativeModuleByDisk(nullptr);
299 char nativeModulePath[3][4096];
300 nativeModulePath[0][0] = 0;
301 nativeModulePath[1][0] = 0;
302 nativeModulePath[2][0] = 0;
303
304 std::string errInfo = "";
305 EXPECT_EQ(moduleManager->FindNativeModuleByDisk(moduleName, nullptr, nullptr, false, false, errInfo,
306 nativeModulePath, nullptr), nullptr);
307 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_011 end";
308 }
309
310 /*
311 * @tc.name: LoadNativeModuleTest_012
312 * @tc.desc: test NativeModule's EmplaceModuleLib function
313 * @tc.type: FUNC
314 * @tc.require: #I76XTV
315 */
316 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_012, TestSize.Level1)
317 {
318 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_012 starts";
319 std::shared_ptr<NativeModuleManager> moduleManager = std::make_shared<NativeModuleManager>();
320 ASSERT_NE(nullptr, moduleManager);
321
322 std::string moduleKey = "aa";
323 moduleManager->EmplaceModuleLib(moduleKey, nullptr);
324 bool result1 = moduleManager->RemoveModuleLib(moduleKey);
325 std::string moduleKey1 = "bb";
326 bool result2 = moduleManager->RemoveModuleLib(moduleKey1);
327 EXPECT_EQ(result1, false);
328 EXPECT_EQ(result2, false);
329 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_012 end";
330 }
331
332 /*
333 * @tc.name: LoadNativeModuleTest_013
334 * @tc.desc: test NativeModule's RemoveNativeModule function
335 * @tc.type: FUNC
336 * @tc.require: #I76XTV
337 */
338 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_013, TestSize.Level1)
339 {
340 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_013 starts";
341 std::shared_ptr<NativeModuleManager> moduleManager = std::make_shared<NativeModuleManager>();
342 ASSERT_NE(nullptr, moduleManager);
343
344 std::string moduleKey = "aa";
345 moduleManager->EmplaceModuleLib(moduleKey, nullptr);
346 std::string moduleKey1 = "bb";
347 EXPECT_EQ(moduleManager->GetNativeModuleHandle(moduleKey1), nullptr);
348 bool result2 = moduleManager->UnloadNativeModule(moduleKey1);
349 EXPECT_EQ(result2, false);
350 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_013 end";
351 }
352
353 /*
354 * @tc.name: LoadNativeModuleTest_014
355 * @tc.desc: test NativeModule's RemoveNativeModule function
356 * @tc.type: FUNC
357 * @tc.require: #I76XTV
358 */
359 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_014, TestSize.Level1)
360 {
361 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_014 starts";
362 std::shared_ptr<NativeModuleManager> moduleManager = std::make_shared<NativeModuleManager>();
363 ASSERT_NE(nullptr, moduleManager);
364
365 std::string moduleKey = "aa";
366 moduleManager->EmplaceModuleLib(moduleKey, nullptr);
367 std::string moduleKey1 = "bb";
368 bool result = moduleManager->RemoveModuleLib(moduleKey1);
369 EXPECT_EQ(result, false);
370
371 bool result2 = moduleManager->RemoveNativeModule(moduleKey1);
372 EXPECT_EQ(result2, false);
373 bool result3 = moduleManager->UnloadNativeModule(moduleKey1);
374 EXPECT_EQ(result3, false);
375 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_014 end";
376 }
377
378 /*
379 * @tc.name: LoadNativeModuleTest_015
380 * @tc.desc: test NativeModule's UnloadNativeModule function
381 * @tc.type: FUNC
382 * @tc.require: #I76XTV
383 */
384 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_015, TestSize.Level1)
385 {
386 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_015 starts";
387 std::shared_ptr<NativeModuleManager> moduleManager = std::make_shared<NativeModuleManager>();
388 ASSERT_NE(nullptr, moduleManager);
389
390 std::string moduleKey = "aa";
391 moduleManager->EmplaceModuleLib(moduleKey, nullptr);
392 bool result = moduleManager->UnloadNativeModule(moduleKey);
393 EXPECT_EQ(result, false);
394 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_015 end";
395 }
396
397 /*
398 * @tc.name: LoadNativeModuleTest_016
399 * @tc.desc: test NativeModule's UnloadModuleLibrary function
400 * @tc.type: FUNC
401 * @tc.require: #I76XTV
402 */
403 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_016, TestSize.Level1)
404 {
405 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_016 starts";
406 std::shared_ptr<NativeModuleManager> moduleManager = std::make_shared<NativeModuleManager>();
407 ASSERT_NE(nullptr, moduleManager);
408
409 bool result = moduleManager->UnloadModuleLibrary(nullptr);
410 EXPECT_EQ(result, false);
411 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_016 end";
412 }
413
414 /*
415 * @tc.name: LoadNativeModuleTest_017
416 * @tc.desc: test NativeModule's RemoveNativeModuleByCache function
417 * @tc.type: FUNC
418 * @tc.require: #I76XTV
419 */
420 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_017, TestSize.Level1)
421 {
422 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_017 starts";
423 std::shared_ptr<NativeModuleManager> moduleManager = std::make_shared<NativeModuleManager>();
424 ASSERT_NE(nullptr, moduleManager);
425
426 std::string moduleKey = "aa";
427 bool result = moduleManager->RemoveNativeModuleByCache(moduleKey);
428 EXPECT_EQ(result, false);
429 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_017 end";
430 }
431
432 /*
433 * @tc.name: LoadNativeModuleTest_018
434 * @tc.desc: test NativeModule's LoadNativeModule function
435 * @tc.type: FUNC
436 * @tc.require: #I76XTV
437 */
438 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_018, TestSize.Level1)
439 {
440 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_018 starts";
441
442 NativeModuleManager* moduleManager = NativeModuleManager::GetInstance();
443
444 std::string errInfo = "";
445 /* isModuleRestricted is true and isAppModule is false, we will check the restriction */
446 EXPECT_EQ(moduleManager->CheckModuleRestricted("dummy"), false);
447
448 EXPECT_EQ(moduleManager->CheckModuleRestricted("worker"), true);
449
450 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_018 end";
451 }
452
453 /*
454 * @tc.name: LoadNativeModuleTest_019
455 * @tc.desc: test NativeModule's LoadNativeModule function
456 * @tc.type: FUNC
457 * @tc.require: #I76XTV
458 */
459 HWTEST_F(ModuleManagerTest, LoadNativeModuleTest_019, TestSize.Level1)
460 {
461 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_019 starts";
462
463 NativeModuleManager* moduleManager = NativeModuleManager::GetInstance();
464
465 /* isModuleRestricted is true and isAppModule is false, we will check the restriction */
466 EXPECT_EQ(moduleManager->CheckModuleRestricted("dummy"), false);
467
468 EXPECT_EQ(moduleManager->CheckModuleRestricted("worker"), true);
469
470 GTEST_LOG_(INFO) << "ModuleManagerTest, LoadNativeModuleTest_019 end";
471 }
472