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