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