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 "assembler/assembly-emitter.h"
17 #include "assembler/assembly-parser.h"
18 #include "libpandafile/class_data_accessor-inl.h"
19
20 #include "ecmascript/base/path_helper.h"
21 #include "ecmascript/global_env.h"
22 #include "ecmascript/jspandafile/js_pandafile.h"
23 #include "ecmascript/jspandafile/js_pandafile_manager.h"
24 #include "ecmascript/jspandafile/program_object.h"
25 #include "ecmascript/js_object-inl.h"
26 #include "ecmascript/module/js_module_manager.h"
27 #include "ecmascript/module/js_module_source_text.h"
28 #include "ecmascript/module/module_data_extractor.h"
29 #include "ecmascript/module/module_logger.h"
30 #include "ecmascript/module/module_path_helper.h"
31 #include "ecmascript/tests/test_helper.h"
32 #include "ecmascript/linked_hash_table.h"
33 #include "ecmascript/checkpoint/thread_state_transition.h"
34 #include "ecmascript/module/js_module_deregister.h"
35 #include "ecmascript/module/js_shared_module.h"
36 #include "ecmascript/module/js_shared_module_manager.h"
37 #include "ecmascript/module/module_tools.h"
38 #include "ecmascript/require/js_cjs_module.h"
39
40
41 using namespace panda::ecmascript;
42 using namespace panda::panda_file;
43 using namespace panda::pandasm;
44
45 namespace panda::test {
46 class EcmaModuleTest : public testing::Test {
47 public:
SetUpTestCase()48 static void SetUpTestCase()
49 {
50 GTEST_LOG_(INFO) << "SetUpTestCase";
51 }
52
TearDownTestCase()53 static void TearDownTestCase()
54 {
55 GTEST_LOG_(INFO) << "TearDownCase";
56 }
57
SetUp()58 void SetUp() override
59 {
60 TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
61 }
62
TearDown()63 void TearDown() override
64 {
65 TestHelper::DestroyEcmaVMWithScope(instance, scope);
66 }
67 EcmaVM *instance {nullptr};
68 ecmascript::EcmaHandleScope *scope {nullptr};
69 JSThread *thread {nullptr};
70 };
71
72 /*
73 * Feature: Module
74 * Function: AddImportEntry
75 * SubFunction: AddImportEntry
76 * FunctionPoints: Add import entry
77 * CaseDescription: Add two import item and check module import entries size
78 */
HWTEST_F_L0(EcmaModuleTest,AddImportEntry)79 HWTEST_F_L0(EcmaModuleTest, AddImportEntry)
80 {
81 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
82 JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
83 JSHandle<ImportEntry> importEntry1 = objectFactory->NewImportEntry();
84 SourceTextModule::AddImportEntry(thread, module, importEntry1, 0, 2);
85 JSHandle<ImportEntry> importEntry2 = objectFactory->NewImportEntry();
86 SourceTextModule::AddImportEntry(thread, module, importEntry2, 1, 2);
87 JSHandle<TaggedArray> importEntries(thread, module->GetImportEntries());
88 EXPECT_TRUE(importEntries->GetLength() == 2U);
89 }
90
91 /*
92 * Feature: Module
93 * Function: AddLocalExportEntry
94 * SubFunction: AddLocalExportEntry
95 * FunctionPoints: Add local export entry
96 * CaseDescription: Add two local export item and check module local export entries size
97 */
HWTEST_F_L0(EcmaModuleTest,AddLocalExportEntry)98 HWTEST_F_L0(EcmaModuleTest, AddLocalExportEntry)
99 {
100 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
101 JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
102 JSHandle<LocalExportEntry> localExportEntry1 = objectFactory->NewLocalExportEntry();
103 SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry1, 0, 2);
104 JSHandle<LocalExportEntry> localExportEntry2 = objectFactory->NewLocalExportEntry();
105 SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry2, 1, 2);
106 JSHandle<TaggedArray> localExportEntries(thread, module->GetLocalExportEntries());
107 EXPECT_TRUE(localExportEntries->GetLength() == 2U);
108 }
109
110 /*
111 * Feature: Module
112 * Function: AddIndirectExportEntry
113 * SubFunction: AddIndirectExportEntry
114 * FunctionPoints: Add indirect export entry
115 * CaseDescription: Add two indirect export item and check module indirect export entries size
116 */
HWTEST_F_L0(EcmaModuleTest,AddIndirectExportEntry)117 HWTEST_F_L0(EcmaModuleTest, AddIndirectExportEntry)
118 {
119 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
120 JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
121 JSHandle<IndirectExportEntry> indirectExportEntry1 = objectFactory->NewIndirectExportEntry();
122 SourceTextModule::AddIndirectExportEntry(thread, module, indirectExportEntry1, 0, 2);
123 JSHandle<IndirectExportEntry> indirectExportEntry2 = objectFactory->NewIndirectExportEntry();
124 SourceTextModule::AddIndirectExportEntry(thread, module, indirectExportEntry2, 1, 2);
125 JSHandle<TaggedArray> indirectExportEntries(thread, module->GetIndirectExportEntries());
126 EXPECT_TRUE(indirectExportEntries->GetLength() == 2U);
127 }
128
129 /*
130 * Feature: Module
131 * Function: StarExportEntries
132 * SubFunction: StarExportEntries
133 * FunctionPoints: Add start export entry
134 * CaseDescription: Add two start export item and check module start export entries size
135 */
HWTEST_F_L0(EcmaModuleTest,AddStarExportEntry)136 HWTEST_F_L0(EcmaModuleTest, AddStarExportEntry)
137 {
138 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
139 JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
140 JSHandle<StarExportEntry> starExportEntry1 = objectFactory->NewStarExportEntry();
141 SourceTextModule::AddStarExportEntry(thread, module, starExportEntry1, 0, 2);
142 JSHandle<StarExportEntry> starExportEntry2 = objectFactory->NewStarExportEntry();
143 SourceTextModule::AddStarExportEntry(thread, module, starExportEntry2, 1, 2);
144 JSHandle<TaggedArray> startExportEntries(thread, module->GetStarExportEntries());
145 EXPECT_TRUE(startExportEntries->GetLength() == 2U);
146 }
147
148 /*
149 * Feature: Module
150 * Function: StoreModuleValue
151 * SubFunction: StoreModuleValue/GetModuleValue
152 * FunctionPoints: store a module export item in module
153 * CaseDescription: Simulated implementation of "export foo as bar", set foo as "hello world",
154 * use "import bar" in same js file
155 */
HWTEST_F_L0(EcmaModuleTest,StoreModuleValue)156 HWTEST_F_L0(EcmaModuleTest, StoreModuleValue)
157 {
158 ObjectFactory* objFactory = thread->GetEcmaVM()->GetFactory();
159 CString localName = "foo";
160 CString exportName = "bar";
161 CString value = "hello world";
162
163 JSHandle<JSTaggedValue> localNameHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
164 JSHandle<JSTaggedValue> exportNameHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName));
165 JSHandle<LocalExportEntry> localExportEntry =
166 objFactory->NewLocalExportEntry(exportNameHandle, localNameHandle, LocalExportEntry::LOCAL_DEFAULT_INDEX,
167 SharedTypes::UNSENDABLE_MODULE);
168 JSHandle<SourceTextModule> module = objFactory->NewSourceTextModule();
169 SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry, 0, 1);
170
171 JSHandle<JSTaggedValue> storeKey = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
172 JSHandle<JSTaggedValue> valueHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(value));
173 module->StoreModuleValue(thread, storeKey, valueHandle);
174
175 JSHandle<JSTaggedValue> loadKey = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
176 JSTaggedValue loadValue = module->GetModuleValue(thread, loadKey.GetTaggedValue(), false);
177 EXPECT_EQ(valueHandle.GetTaggedValue(), loadValue);
178 }
179
180 /*
181 * Feature: Module
182 * Function: GetModuleValue
183 * SubFunction: StoreModuleValue/GetModuleValue
184 * FunctionPoints: load module value from module
185 * CaseDescription: Simulated implementation of "export default let foo = 'hello world'",
186 * use "import C from 'xxx' to get default value"
187 */
HWTEST_F_L0(EcmaModuleTest,GetModuleValue)188 HWTEST_F_L0(EcmaModuleTest, GetModuleValue)
189 {
190 ObjectFactory* objFactory = thread->GetEcmaVM()->GetFactory();
191 // export entry
192 CString exportLocalName = "*default*";
193 CString exportName = "default";
194 CString exportValue = "hello world";
195 JSHandle<JSTaggedValue> exportLocalNameHandle =
196 JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportLocalName));
197 JSHandle<JSTaggedValue> exportNameHandle =
198 JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName));
199 JSHandle<LocalExportEntry> localExportEntry = objFactory->NewLocalExportEntry(exportNameHandle,
200 exportLocalNameHandle, LocalExportEntry::LOCAL_DEFAULT_INDEX, SharedTypes::UNSENDABLE_MODULE);
201 JSHandle<SourceTextModule> moduleExport = objFactory->NewSourceTextModule();
202 SourceTextModule::AddLocalExportEntry(thread, moduleExport, localExportEntry, 0, 1);
203 // store module value
204 JSHandle<JSTaggedValue> exportValueHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportValue));
205 moduleExport->StoreModuleValue(thread, exportLocalNameHandle, exportValueHandle);
206
207 JSTaggedValue importDefaultValue =
208 moduleExport->GetModuleValue(thread, exportLocalNameHandle.GetTaggedValue(), false);
209 EXPECT_EQ(exportValueHandle.GetTaggedValue(), importDefaultValue);
210 }
211
HWTEST_F_L0(EcmaModuleTest,GetExportedNames)212 HWTEST_F_L0(EcmaModuleTest, GetExportedNames)
213 {
214 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
215 JSHandle<SourceTextModule> module = factory->NewSourceTextModule();
216 JSHandle<TaggedArray> exportStarSet = factory->NewTaggedArray(2);
217 exportStarSet->Set(thread, 0, module.GetTaggedValue());
218
219 CVector<std::string> exportedNames = SourceTextModule::GetExportedNames(thread, module, exportStarSet);
220 EXPECT_EQ(exportedNames.size(), 0);
221 }
222
HWTEST_F_L0(EcmaModuleTest,FindByExport)223 HWTEST_F_L0(EcmaModuleTest, FindByExport)
224 {
225 CString localName1 = "foo";
226 CString localName2 = "foo2";
227 CString localName3 = "foo3";
228 CString exportName1 = "bar";
229 CString exportName2 = "bar2";
230 CString value = "hello world";
231 CString value2 = "hello world2";
232
233 ObjectFactory* objFactory = thread->GetEcmaVM()->GetFactory();
234 JSHandle<SourceTextModule> module = objFactory->NewSourceTextModule();
235 JSHandle<JSTaggedValue> localNameHandle1 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName1));
236 JSHandle<JSTaggedValue> localNameHandle2 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName2));
237 JSHandle<JSTaggedValue> exportNameHandle1 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName1));
238 JSHandle<JSTaggedValue> exportNameHandle2 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName2));
239 JSHandle<LocalExportEntry> localExportEntry1 =
240 objFactory->NewLocalExportEntry(exportNameHandle1, localNameHandle1, LocalExportEntry::LOCAL_DEFAULT_INDEX,
241 SharedTypes::UNSENDABLE_MODULE);
242 SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry1, 0, 2);
243
244 JSHandle<LocalExportEntry> localExportEntry2 =
245 objFactory->NewLocalExportEntry(exportNameHandle2, localNameHandle2, LocalExportEntry::LOCAL_DEFAULT_INDEX,
246 SharedTypes::UNSENDABLE_MODULE);
247 SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry2, 1, 2);
248
249 JSHandle<JSTaggedValue> storeKey = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName1));
250 JSHandle<JSTaggedValue> valueHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(value));
251 module->StoreModuleValue(thread, storeKey, valueHandle);
252
253 JSHandle<JSTaggedValue> storeKey2 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName2));
254 JSHandle<JSTaggedValue> valueHandle2 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(value2));
255 module->StoreModuleValue(thread, storeKey2, valueHandle2);
256
257 // FindByExport cannot find key from exportEntries, returns Hole()
258 JSHandle<JSTaggedValue> loadKey1 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName3));
259 JSTaggedValue loadValue1 = module->GetModuleValue(thread, loadKey1.GetTaggedValue(), false);
260 EXPECT_EQ(JSTaggedValue::Hole(), loadValue1);
261
262 // FindByExport retrieves the key from exportEntries and returns the value corresponding to the key
263 JSHandle<JSTaggedValue> loadKey2 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName1));
264 JSTaggedValue loadValue2 = module->GetModuleValue(thread, loadKey2.GetTaggedValue(), false);
265 EXPECT_EQ(valueHandle.GetTaggedValue(), loadValue2);
266 }
267
HWTEST_F_L0(EcmaModuleTest,GetRecordName1)268 HWTEST_F_L0(EcmaModuleTest, GetRecordName1)
269 {
270 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_module_base.abc";
271
272 JSNApi::EnableUserUncaughtErrorHandler(instance);
273
274 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_module_base");
275 EXPECT_TRUE(result);
276 }
277
HWTEST_F_L0(EcmaModuleTest,GetRecordName2)278 HWTEST_F_L0(EcmaModuleTest, GetRecordName2)
279 {
280 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_A.abc";
281
282 JSNApi::EnableUserUncaughtErrorHandler(instance);
283
284 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_A");
285 EXPECT_TRUE(result);
286 }
287
HWTEST_F_L0(EcmaModuleTest,GetExportObjectIndex)288 HWTEST_F_L0(EcmaModuleTest, GetExportObjectIndex)
289 {
290 ThreadNativeScope nativeScope(thread);
291 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
292
293 JSNApi::EnableUserUncaughtErrorHandler(instance);
294
295 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
296 JSNApi::GetExportObject(instance, "module_test_module_test_B", "a");
297 EXPECT_TRUE(result);
298 }
299
HWTEST_F_L0(EcmaModuleTest,HostResolveImportedModule)300 HWTEST_F_L0(EcmaModuleTest, HostResolveImportedModule)
301 {
302 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
303
304 JSNApi::EnableUserUncaughtErrorHandler(instance);
305
306 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
307 ObjectFactory *factory = instance->GetFactory();
308 JSHandle<SourceTextModule> module = factory->NewSourceTextModule();
309 JSHandle<JSTaggedValue> moduleRecord(thread, module.GetTaggedValue());
310 moduleManager->AddResolveImportedModule(baseFileName.c_str(), moduleRecord.GetTaggedValue());
311 JSHandle<JSTaggedValue> res = moduleManager->HostResolveImportedModule(baseFileName.c_str());
312
313 EXPECT_EQ(moduleRecord->GetRawData(), res.GetTaggedValue().GetRawData());
314 }
315
HWTEST_F_L0(EcmaModuleTest,HostResolveImportedModule2)316 HWTEST_F_L0(EcmaModuleTest, HostResolveImportedModule2)
317 {
318 CString recordName = "module_test_module_test_A";
319 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
320
321 CString baseFileName = MODULE_ABC_PATH "module_test_module_test_A.abc";
322 std::shared_ptr<JSPandaFile> jsPandaFile =
323 JSPandaFileManager::GetInstance()->LoadJSPandaFile(thread, baseFileName, JSPandaFile::ENTRY_MAIN_FUNCTION);
324 EXPECT_NE(jsPandaFile, nullptr);
325 JSHandle<JSTaggedValue> res1 = moduleManager->HostResolveImportedModule(jsPandaFile.get(), baseFileName);
326 EXPECT_NE(res1.GetTaggedValue(), JSTaggedValue::Undefined());
327 JSHandle<JSTaggedValue> res2 = moduleManager->HostResolveImportedModule(jsPandaFile.get(), baseFileName);
328 EXPECT_NE(res2.GetTaggedValue(), JSTaggedValue::Undefined());
329 }
330
HWTEST_F_L0(EcmaModuleTest,IsSharedModuleLoaded)331 HWTEST_F_L0(EcmaModuleTest, IsSharedModuleLoaded)
332 {
333 CString recordName = "module_test_module_test_A";
334 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
335 bool res = moduleManager->IsSharedModuleLoaded(recordName);
336 EXPECT_EQ(res, false);
337 }
338
HWTEST_F_L0(EcmaModuleTest,GetModuleValueInner)339 HWTEST_F_L0(EcmaModuleTest, GetModuleValueInner)
340 {
341 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
342 JSNApi::EnableUserUncaughtErrorHandler(instance);
343 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
344 EXPECT_TRUE(result);
345 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
346 JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
347 JSHandle<JSTaggedValue> moduleRecord = JSHandle<JSTaggedValue>::Cast(module);
348
349 JSTaggedValue res1 = moduleManager->GetModuleValueInner(0, moduleRecord);
350 EXPECT_EQ(res1, JSTaggedValue::Hole());
351
352 JSTaggedValue res2 = moduleManager->GetModuleValueOutter(0, moduleRecord);
353 EXPECT_TRUE(res2.IsInt());
354 }
355
HWTEST_F_L0(EcmaModuleTest,GetModuleValueOutterInternal)356 HWTEST_F_L0(EcmaModuleTest, GetModuleValueOutterInternal)
357 {
358 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
359 JSNApi::EnableUserUncaughtErrorHandler(instance);
360 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
361 EXPECT_TRUE(result);
362 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
363 JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_B");
364 JSHandle<JSTaggedValue> moduleRecord = JSHandle<JSTaggedValue>::Cast(module);
365
366 // moduleEnvironment IsUndefined
367 JSTaggedValue res = moduleManager->GetModuleValueOutter(0, moduleRecord);
368 EXPECT_TRUE(res.IsSpecial());
369 }
370
HWTEST_F_L0(EcmaModuleTest,GetModuleNamespaceInternal)371 HWTEST_F_L0(EcmaModuleTest, GetModuleNamespaceInternal)
372 {
373 CString localName = "foo";
374
375 ObjectFactory* objFactory = thread->GetEcmaVM()->GetFactory();
376 JSHandle<JSTaggedValue> localNameHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
377 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
378
379 // moduleEnvironment IsUndefined
380 JSHandle<SourceTextModule> module = objFactory->NewSourceTextModule();
381 JSTaggedValue res1 = moduleManager->GetModuleNamespaceInternal(localNameHandle.GetTaggedValue(),
382 module.GetTaggedValue());
383 EXPECT_EQ(res1, thread->GlobalConstants()->GetUndefined());
384
385 // FindEntry fail
386 JSHandle<NameDictionary> map(NameDictionary::Create(thread, NameDictionary::ComputeHashTableSize(1)));
387 module->SetEnvironment(thread, map);
388 JSTaggedValue res2 = moduleManager->GetModuleNamespaceInternal(localNameHandle.GetTaggedValue(),
389 module.GetTaggedValue());
390 EXPECT_EQ(res2, thread->GlobalConstants()->GetUndefined());
391 }
392
HWTEST_F_L0(EcmaModuleTest,GetExportObjectIndex2)393 HWTEST_F_L0(EcmaModuleTest, GetExportObjectIndex2)
394 {
395 CString key = "module_test_module_test_A";
396 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
397 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
398 JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
399
400 // EcmaModuleRecordNameString is empty
401 int res1 = moduleManager->GetExportObjectIndex(thread->GetEcmaVM(), module, key);
402 EXPECT_EQ(res1, 0);
403
404 // EcmaModuleRecordNameString is not empty
405 module->SetEcmaModuleRecordNameString("test");
406 int res2 = moduleManager->GetExportObjectIndex(thread->GetEcmaVM(), module, key);
407 EXPECT_EQ(res2, 0);
408 }
409
HWTEST_F_L0(EcmaModuleTest,GetModuleNameSpaceFromFile)410 HWTEST_F_L0(EcmaModuleTest, GetModuleNameSpaceFromFile)
411 {
412 CString recordName1 = "a";
413 CString recordName2 = "module_test_module_test_B";
414 CString baseFileName = MODULE_ABC_PATH "module_test_module_test_B.abc";
415 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
416
417 // ExecuteFromAbcFile is success
418 JSHandle<JSTaggedValue> res2 = moduleManager->GetModuleNameSpaceFromFile(thread, recordName2, baseFileName);
419 EXPECT_NE(res2, thread->GlobalConstants()->GetHandledUndefinedString());
420
421 // ExecuteFromAbcFile is fail
422 JSHandle<JSTaggedValue> res1 = moduleManager->GetModuleNameSpaceFromFile(thread, recordName1, baseFileName);
423 EXPECT_EQ(res1, thread->GlobalConstants()->GetHandledUndefinedString());
424 }
425
HWTEST_F_L0(EcmaModuleTest,TryGetImportedModule)426 HWTEST_F_L0(EcmaModuleTest, TryGetImportedModule)
427 {
428 // TryGetImportedModule can not found Module
429 CString moduleName = "moduleName";
430 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
431 JSHandle<JSTaggedValue> res1 = moduleManager->TryGetImportedModule(moduleName);
432 EXPECT_EQ(res1, thread->GlobalConstants()->GetHandledUndefined());
433
434 // TryGetImportedModule can found Module
435 ObjectFactory *factory = instance->GetFactory();
436 JSHandle<SourceTextModule> module = factory->NewSourceTextModule();
437 JSHandle<JSTaggedValue> moduleRecord(thread, module.GetTaggedValue());
438 moduleManager->AddResolveImportedModule(moduleName, moduleRecord.GetTaggedValue());
439 JSHandle<JSTaggedValue> res2 = moduleManager->TryGetImportedModule(moduleName);
440 EXPECT_EQ(res2, moduleRecord);
441 }
442
HWTEST_F_L0(EcmaModuleTest,PreventExtensions_IsExtensible)443 HWTEST_F_L0(EcmaModuleTest, PreventExtensions_IsExtensible)
444 {
445 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
446 JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
447 JSHandle<LocalExportEntry> localExportEntry1 = objectFactory->NewLocalExportEntry();
448 SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry1, 0, 2);
449 JSHandle<LocalExportEntry> localExportEntry2 = objectFactory->NewLocalExportEntry();
450 SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry2, 1, 2);
451 JSHandle<TaggedArray> localExportEntries(thread, module->GetLocalExportEntries());
452 CString baseFileName = "a.abc";
453 module->SetEcmaModuleFilenameString(baseFileName);
454 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
455 JSHandle<JSTaggedValue> moduleRecord = JSHandle<JSTaggedValue>::Cast(module);
456 moduleManager->AddResolveImportedModule(baseFileName, moduleRecord.GetTaggedValue());
457 JSHandle<ModuleNamespace> np =
458 ModuleNamespace::ModuleNamespaceCreate(thread, moduleRecord, localExportEntries);
459 EXPECT_FALSE(np->IsExtensible());
460 EXPECT_TRUE(ModuleNamespace::PreventExtensions());
461 }
462
HWTEST_F_L0(EcmaModuleTest,ConcatFileNameWithMerge1)463 HWTEST_F_L0(EcmaModuleTest, ConcatFileNameWithMerge1)
464 {
465 CString baseFilename = "merge.abc";
466 const char *data = R"(
467 .language ECMAScript
468 .function any func_main_0(any a0, any a1, any a2) {
469 ldai 1
470 return
471 }
472 )";
473 JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
474 Parser parser;
475 auto res = parser.Parse(data);
476 std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
477 std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
478
479 // Test moduleRequestName start with "@bundle"
480 CString moduleRecordName = "moduleTest1";
481 CString moduleRequestName = "@bundle:com.bundleName.test/moduleName/requestModuleName1";
482 CString result = "com.bundleName.test/moduleName/requestModuleName1";
483 CString entryPoint = ModulePathHelper::ConcatFileNameWithMerge(thread, pf.get(), baseFilename, moduleRecordName,
484 moduleRequestName);
485 EXPECT_EQ(result, entryPoint);
486
487 // Test cross application
488 moduleRecordName = "@bundle:com.bundleName1.test/moduleName/requestModuleName1";
489 CString newBaseFileName = "/data/storage/el1/bundle/com.bundleName.test/moduleName/moduleName/ets/modules.abc";
490 ModulePathHelper::ConcatFileNameWithMerge(thread, pf.get(), baseFilename, moduleRecordName, moduleRequestName);
491 EXPECT_EQ(baseFilename, newBaseFileName);
492 }
493
HWTEST_F_L0(EcmaModuleTest,ConcatFileNameWithMerge2)494 HWTEST_F_L0(EcmaModuleTest, ConcatFileNameWithMerge2)
495 {
496 CString baseFilename = "merge.abc";
497 const char *data = R"(
498 .language ECMAScript
499 .function any func_main_0(any a0, any a1, any a2) {
500 ldai 1
501 return
502 }
503 )";
504 JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
505 Parser parser;
506 auto res = parser.Parse(data);
507 std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
508 std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
509
510 // Test moduleRequestName start with "./"
511 CString moduleRecordName = "moduleTest2";
512 CString moduleRequestName = "./requestModule.js";
513 CString result = "requestModule";
514 pf->InsertJSRecordInfo(result);
515 CString entryPoint = ModulePathHelper::ConcatFileNameWithMerge(thread, pf.get(), baseFilename, moduleRecordName,
516 moduleRequestName);
517 EXPECT_EQ(result, entryPoint);
518
519 // Test moduleRecordName with "/"
520 moduleRecordName = "moduleName/moduleTest2";
521 moduleRequestName = "./requestModule.js";
522 result = "moduleName/requestModule";
523 pf->InsertJSRecordInfo(result);
524 entryPoint = ModulePathHelper::ConcatFileNameWithMerge(
525 thread, pf.get(), baseFilename, moduleRecordName, moduleRequestName);
526 EXPECT_EQ(result, entryPoint);
527 }
528
HWTEST_F_L0(EcmaModuleTest,ConcatFileNameWithMerge3)529 HWTEST_F_L0(EcmaModuleTest, ConcatFileNameWithMerge3)
530 {
531 CString baseFilename = "merge.abc";
532 const char *data = R"(
533 .language ECMAScript
534 .function any func_main_0(any a0, any a1, any a2) {
535 ldai 1
536 return
537 }
538 )";
539 JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
540 Parser parser;
541 auto res = parser.Parse(data);
542 std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
543 std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
544
545 // Test RecordName is not in JSPandaFile
546 CString moduleRecordName = "moduleTest3";
547 CString moduleRequestName = "./secord.js";
548 CString result = "secord";
549 CString requestFileName = "secord.abc";
550 CString entryPoint =
551 ModulePathHelper::ConcatFileNameWithMerge(thread, pf.get(), baseFilename, moduleRecordName, moduleRequestName);
552 EXPECT_EQ(baseFilename, requestFileName);
553 EXPECT_EQ(result, entryPoint);
554
555 // Test RecordName is not in JSPandaFile and baseFilename with "/" and moduleRequestName with "/"
556 baseFilename = "test/merge.abc";
557 std::unique_ptr<const File> pfPtr2 = pandasm::AsmEmitter::Emit(res.Value());
558 std::shared_ptr<JSPandaFile> pf2 = pfManager->NewJSPandaFile(pfPtr2.release(), baseFilename);
559
560 moduleRecordName = "moduleTest3";
561 moduleRequestName = "./test/secord.js";
562 result = "secord";
563 requestFileName = "test/test/secord.abc";
564 entryPoint = ModulePathHelper::ConcatFileNameWithMerge(thread, pf2.get(), baseFilename, moduleRecordName,
565 moduleRequestName);
566 EXPECT_EQ(baseFilename, requestFileName);
567 EXPECT_EQ(result, entryPoint);
568 }
569
HWTEST_F_L0(EcmaModuleTest,ConcatFileNameWithMerge4)570 HWTEST_F_L0(EcmaModuleTest, ConcatFileNameWithMerge4)
571 {
572 CString baseFilename = "merge.abc";
573 const char *data = R"(
574 .language ECMAScript
575 .function any func_main_0(any a0, any a1, any a2) {
576 ldai 1
577 return
578 }
579 )";
580 JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
581 Parser parser;
582 auto res = parser.Parse(data);
583 std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
584 std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
585 CUnorderedMap<CString, JSPandaFile::JSRecordInfo*> &recordInfo =
586 const_cast<CUnorderedMap<CString, JSPandaFile::JSRecordInfo*>&>(pf->GetJSRecordInfo());
587
588 CString moduleRecordName = "node_modules/0/moduleTest4/index";
589 CString moduleRequestName = "json/index";
590 CString result = "node_modules/0/moduleTest4/node_modules/json/index";
591 JSPandaFile::JSRecordInfo *info = new JSPandaFile::JSRecordInfo();
592 info->npmPackageName = "node_modules/0/moduleTest4";
593 recordInfo.insert({moduleRecordName, info});
594 recordInfo.insert({result, info});
595 CString entryPoint = ModulePathHelper::ConcatFileNameWithMerge(
596 thread, pf.get(), baseFilename, moduleRecordName, moduleRequestName);
597 EXPECT_EQ(result, entryPoint);
598
599 // delete info
600 delete info;
601 recordInfo.erase(moduleRecordName);
602 recordInfo.erase(result);
603 }
604
605
HWTEST_F_L0(EcmaModuleTest,NormalizePath)606 HWTEST_F_L0(EcmaModuleTest, NormalizePath)
607 {
608 CString res1 = "node_modules/0/moduleTest/index";
609 CString moduleRecordName1 = "node_modules///0//moduleTest/index";
610
611 CString res2 = "node_modules/0/moduleTest/index";
612 CString moduleRecordName2 = "./node_modules///0//moduleTest/index";
613
614 CString res3 = "node_modules/0/moduleTest/index";
615 CString moduleRecordName3 = "../node_modules/0/moduleTest///index";
616
617 CString res4 = "moduleTest/index";
618 CString moduleRecordName4 = "./node_modules/..//moduleTest////index";
619
620 CString res5 = "node_modules/moduleTest/index";
621 CString moduleRecordName5 = "node_modules/moduleTest/index/";
622
623 CString normalName1 = PathHelper::NormalizePath(moduleRecordName1);
624 CString normalName2 = PathHelper::NormalizePath(moduleRecordName2);
625 CString normalName3 = PathHelper::NormalizePath(moduleRecordName3);
626 CString normalName4 = PathHelper::NormalizePath(moduleRecordName4);
627 CString normalName5 = PathHelper::NormalizePath(moduleRecordName5);
628
629 EXPECT_EQ(res1, normalName1);
630 EXPECT_EQ(res2, normalName2);
631 EXPECT_EQ(res3, normalName3);
632 EXPECT_EQ(res4, normalName4);
633 EXPECT_EQ(res5, normalName5);
634 }
635
HWTEST_F_L0(EcmaModuleTest,ParseAbcPathAndOhmUrl)636 HWTEST_F_L0(EcmaModuleTest, ParseAbcPathAndOhmUrl)
637 {
638 // old pages url
639 instance->SetBundleName("com.bundleName.test");
640 instance->SetModuleName("moduleName");
641 CString inputFileName = "moduleName/ets/pages/index.abc";
642 CString outFileName = "";
643 CString res1 = "com.bundleName.test/moduleName/ets/pages/index";
644 CString entryPoint;
645 ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
646 EXPECT_EQ(entryPoint, res1);
647 EXPECT_EQ(outFileName, "");
648
649 // new pages url
650 inputFileName = "@bundle:com.bundleName.test/moduleName/ets/pages/index.abc";
651 ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
652 EXPECT_EQ(entryPoint, res1);
653 EXPECT_EQ(outFileName, "/data/storage/el1/bundle/moduleName/ets/modules.abc");
654
655 // new pages url Intra-application cross hap
656 inputFileName = "@bundle:com.bundleName.test/moduleName1/ets/pages/index.abc";
657 CString outRes = "/data/storage/el1/bundle/moduleName1/ets/modules.abc";
658 CString res2 = "com.bundleName.test/moduleName1/ets/pages/index";
659 ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
660 EXPECT_EQ(entryPoint, res2);
661 EXPECT_EQ(outFileName, outRes);
662
663 // new pages url Cross-application
664 inputFileName = "@bundle:com.bundleName.test1/moduleName1/ets/pages/index.abc";
665 CString outRes1 = "/data/storage/el1/bundle/com.bundleName.test1/moduleName1/moduleName1/ets/modules.abc";
666 CString res3 = "com.bundleName.test1/moduleName1/ets/pages/index";
667 ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
668 EXPECT_EQ(entryPoint, res3);
669 EXPECT_EQ(outFileName, outRes1);
670
671 // worker url Intra-application cross hap
672 inputFileName = "/data/storage/el1/bundle/entry/ets/mainAbility.abc";
673 CString outRes2 = "/data/storage/el1/bundle/entry/ets/modules.abc";
674 CString res4 = "com.bundleName.test/entry/ets/mainAbility";
675 ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
676 EXPECT_EQ(entryPoint, res4);
677 EXPECT_EQ(outFileName, outRes2);
678
679 // worker url
680 outFileName = "";
681 inputFileName = "/data/storage/el1/bundle/moduleName/ets/mainAbility.abc";
682 CString res5 = "com.bundleName.test/moduleName/ets/mainAbility";
683 ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
684 EXPECT_EQ(entryPoint, res5);
685 EXPECT_EQ(outFileName, "/data/storage/el1/bundle/moduleName/ets/modules.abc");
686 }
687
HWTEST_F_L0(EcmaModuleTest,CheckNativeModule)688 HWTEST_F_L0(EcmaModuleTest, CheckNativeModule)
689 {
690 // load file
691 CString requestName1 = "@bundle:bundleName/moduleName/ets/index";
692
693 // load native modules
694 CString requestName2 = "@ohos:router";
695 CString requestName3 = "@app:bundleName/moduleName/lib*.so";
696 CString requestName4 = "@native:system.app";
697 CString requestName5 = "@xxx:internal";
698
699 // load npm Packages
700 CString requestName6 = "@package:pkg_modules/.ohpm/json5@2.2.3/pkg_modules/json5/dist/index";
701 CString requestName7 = "@ohos/common";
702
703 std::pair<bool, ModuleTypes> res1 = SourceTextModule::CheckNativeModule(requestName1);
704 EXPECT_EQ(res1.first, false);
705 EXPECT_EQ(res1.second, ModuleTypes::UNKNOWN);
706
707 std::pair<bool, ModuleTypes> res2 = SourceTextModule::CheckNativeModule(requestName2);
708 EXPECT_EQ(res2.first, true);
709 EXPECT_EQ(res2.second, ModuleTypes::OHOS_MODULE);
710
711 std::pair<bool, ModuleTypes> res3 = SourceTextModule::CheckNativeModule(requestName3);
712 EXPECT_EQ(res3.first, true);
713 EXPECT_EQ(res3.second, ModuleTypes::APP_MODULE);
714
715 std::pair<bool, ModuleTypes> res4 = SourceTextModule::CheckNativeModule(requestName4);
716 EXPECT_EQ(res4.first, true);
717 EXPECT_EQ(res4.second, ModuleTypes::NATIVE_MODULE);
718
719 std::pair<bool, ModuleTypes> res5 = SourceTextModule::CheckNativeModule(requestName5);
720 EXPECT_EQ(res5.first, true);
721 EXPECT_EQ(res5.second, ModuleTypes::INTERNAL_MODULE);
722
723 std::pair<bool, ModuleTypes> res6 = SourceTextModule::CheckNativeModule(requestName6);
724 EXPECT_EQ(res6.first, false);
725 EXPECT_EQ(res6.second, ModuleTypes::UNKNOWN);
726
727 std::pair<bool, ModuleTypes> res7 = SourceTextModule::CheckNativeModule(requestName7);
728 EXPECT_EQ(res7.first, false);
729 EXPECT_EQ(res7.second, ModuleTypes::UNKNOWN);
730 }
731
HWTEST_F_L0(EcmaModuleTest,ResolveDirPath)732 HWTEST_F_L0(EcmaModuleTest, ResolveDirPath)
733 {
734 CString inputFileName = "moduleName/ets/pages/index.abc";
735 CString resName1 = "moduleName/ets/pages/";
736 CString outFileName = PathHelper::ResolveDirPath(inputFileName);
737 EXPECT_EQ(outFileName, resName1);
738
739 inputFileName = "moduleName\\ets\\pages\\index.abc";
740 CString resName2 = "moduleName\\ets\\pages\\";
741 outFileName = PathHelper::ResolveDirPath(inputFileName);
742 EXPECT_EQ(outFileName, resName2);
743
744 inputFileName = "cjs";
745 CString resName3 = "";
746 outFileName = PathHelper::ResolveDirPath(inputFileName);
747 EXPECT_EQ(outFileName, resName3);
748 }
749
HWTEST_F_L0(EcmaModuleTest,DeleteNamespace)750 HWTEST_F_L0(EcmaModuleTest, DeleteNamespace)
751 {
752 CString inputFileName = "moduleName@nameSpace";
753 CString res1 = "moduleName";
754 PathHelper::DeleteNamespace(inputFileName);
755 EXPECT_EQ(inputFileName, res1);
756
757 inputFileName = "moduleName";
758 CString res2 = "moduleName";
759 PathHelper::DeleteNamespace(inputFileName);
760 EXPECT_EQ(inputFileName, res2);
761 }
762
HWTEST_F_L0(EcmaModuleTest,AdaptOldIsaRecord)763 HWTEST_F_L0(EcmaModuleTest, AdaptOldIsaRecord)
764 {
765 CString inputFileName = "bundleName/moduleName@namespace/moduleName";
766 CString res1 = "moduleName";
767 PathHelper::AdaptOldIsaRecord(inputFileName);
768 EXPECT_EQ(inputFileName, res1);
769 }
770
HWTEST_F_L0(EcmaModuleTest,GetStrippedModuleName)771 HWTEST_F_L0(EcmaModuleTest, GetStrippedModuleName)
772 {
773 CString inputFileName = "@ohos:hilog";
774 CString res1 = "hilog";
775 CString outFileName = PathHelper::GetStrippedModuleName(inputFileName);
776 EXPECT_EQ(outFileName, res1);
777 }
778
HWTEST_F_L0(EcmaModuleTest,GetInternalModulePrefix)779 HWTEST_F_L0(EcmaModuleTest, GetInternalModulePrefix)
780 {
781 CString inputFileName = "@ohos:hilog";
782 CString res1 = "ohos";
783 CString outFileName = PathHelper::GetInternalModulePrefix(inputFileName);
784 EXPECT_EQ(outFileName, res1);
785 }
786
HWTEST_F_L0(EcmaModuleTest,IsNativeModuleRequest)787 HWTEST_F_L0(EcmaModuleTest, IsNativeModuleRequest)
788 {
789 CString inputFileName = "json5";
790 bool res1 = ModulePathHelper::IsNativeModuleRequest(inputFileName);
791 EXPECT_TRUE(!res1);
792
793 inputFileName = "@ohos:hilog";
794 bool res2 = ModulePathHelper::IsNativeModuleRequest(inputFileName);
795 EXPECT_TRUE(res2);
796
797 inputFileName = "@app:xxxx";
798 bool res3 = ModulePathHelper::IsNativeModuleRequest(inputFileName);
799 EXPECT_TRUE(res3);
800
801 inputFileName = "@native:xxxx";
802 bool res4 = ModulePathHelper::IsNativeModuleRequest(inputFileName);
803 EXPECT_TRUE(res4);
804 }
805
HWTEST_F_L0(EcmaModuleTest,IsImportFile)806 HWTEST_F_L0(EcmaModuleTest, IsImportFile)
807 {
808 CString inputFileName = "./test";
809 bool res1 = ModulePathHelper::IsImportFile(inputFileName);
810 EXPECT_TRUE(res1);
811 CString outFileName = ModulePathHelper::RemoveSuffix(inputFileName);
812 EXPECT_EQ(outFileName, inputFileName);
813
814 inputFileName = "test";
815 bool res2 = ModulePathHelper::IsImportFile(inputFileName);
816 EXPECT_TRUE(!res2);
817 outFileName = ModulePathHelper::RemoveSuffix(inputFileName);
818 EXPECT_EQ(outFileName, inputFileName);
819
820 CString result = "test";
821 inputFileName = "test.js";
822 bool res3 = ModulePathHelper::IsImportFile(inputFileName);
823 EXPECT_TRUE(res3);
824 outFileName = ModulePathHelper::RemoveSuffix(inputFileName);
825 EXPECT_EQ(outFileName, result);
826
827 inputFileName = "test.ts";
828 bool res4 = ModulePathHelper::IsImportFile(inputFileName);
829 EXPECT_TRUE(res4);
830 outFileName = ModulePathHelper::RemoveSuffix(inputFileName);
831 EXPECT_EQ(outFileName, result);
832
833 inputFileName = "test.ets";
834 bool res5 = ModulePathHelper::IsImportFile(inputFileName);
835 EXPECT_TRUE(res5);
836 outFileName = ModulePathHelper::RemoveSuffix(inputFileName);
837 EXPECT_EQ(outFileName, result);
838
839 inputFileName = "test.json";
840 bool res6 = ModulePathHelper::IsImportFile(inputFileName);
841 EXPECT_TRUE(res6);
842 outFileName = ModulePathHelper::RemoveSuffix(inputFileName);
843 EXPECT_EQ(outFileName, result);
844 }
845
HWTEST_F_L0(EcmaModuleTest,GetModuleNameWithPath)846 HWTEST_F_L0(EcmaModuleTest, GetModuleNameWithPath)
847 {
848 CString inputPath1 = "com.example.application/entry";
849 CString res1 = "entry";
850 CString outFileName1 = ModulePathHelper::GetModuleNameWithPath(inputPath1);
851 EXPECT_EQ(outFileName1, res1);
852
853 CString inputPath2 = "com.example.applicationentry";
854 CString res2 = "";
855 CString outFileName2 = ModulePathHelper::GetModuleNameWithPath(inputPath2);
856 EXPECT_EQ(outFileName2, res2);
857 }
858
HWTEST_F_L0(EcmaModuleTest,ConcatPandaFilePath)859 HWTEST_F_L0(EcmaModuleTest, ConcatPandaFilePath)
860 {
861 CString inputPath1 = "entry";
862 CString res1 = "/data/storage/el1/bundle/entry/ets/modules.abc";
863 CString outFileName1 = ModulePathHelper::ConcatPandaFilePath(inputPath1);
864 EXPECT_EQ(outFileName1, res1);
865
866 CString inputPath2 = "";
867 CString res2 = "";
868 CString outFileName2 = ModulePathHelper::ConcatPandaFilePath(inputPath2);
869 EXPECT_EQ(outFileName2, res2);
870
871 CString inputPath3 = "entry1";
872 CString res3 = "/data/storage/el1/bundle/entry1/ets/modules.abc";
873 CString outFileName3 = ModulePathHelper::ConcatPandaFilePath(inputPath3);
874 EXPECT_EQ(outFileName3, res3);
875 }
876
HWTEST_F_L0(EcmaModuleTest,ParseFileNameToVMAName)877 HWTEST_F_L0(EcmaModuleTest, ParseFileNameToVMAName)
878 {
879 CString inputFileName = "test.abc";
880 CString outFileName = ModulePathHelper::ParseFileNameToVMAName(inputFileName);
881 CString exceptOutFileName = "ArkTS Code:test.abc";
882 EXPECT_EQ(outFileName, exceptOutFileName);
883
884 inputFileName = "";
885 outFileName = ModulePathHelper::ParseFileNameToVMAName(inputFileName);
886 exceptOutFileName = "ArkTS Code";
887 EXPECT_EQ(outFileName, exceptOutFileName);
888
889 inputFileName = "libutil.z.so/util.js";
890 outFileName = ModulePathHelper::ParseFileNameToVMAName(inputFileName);
891 exceptOutFileName = "ArkTS Code:libutil.z.so/util.js";
892 EXPECT_EQ(outFileName, exceptOutFileName);
893
894 inputFileName = "libutil.HashMap.z.so/util.HashMap.js";
895 outFileName = ModulePathHelper::ParseFileNameToVMAName(inputFileName);
896 exceptOutFileName = "ArkTS Code:libhashmap.z.so/HashMap.js";
897 EXPECT_EQ(outFileName, exceptOutFileName);
898
899 inputFileName = "/data/storage/el1/bundle/com.example.application/ets/modules.abc";
900 outFileName = ModulePathHelper::ParseFileNameToVMAName(inputFileName);
901 exceptOutFileName = "ArkTS Code:com.example.application/ets/modules.abc";
902 EXPECT_EQ(outFileName, exceptOutFileName);
903 }
904
HWTEST_F_L0(EcmaModuleTest,ConcatUnifiedOhmUrl)905 HWTEST_F_L0(EcmaModuleTest, ConcatUnifiedOhmUrl)
906 {
907 CString pkgName = "entry";
908 CString path = "/Index";
909 CString version = "1.0.0";
910 CString outFileName = ModulePathHelper::ConcatUnifiedOhmUrl("", pkgName, "", path, version);
911 CString exceptOutFileName = "&entry/src/main/Index&1.0.0";
912 EXPECT_EQ(outFileName, exceptOutFileName);
913
914 CString path2 = "Index";
915 outFileName = ModulePathHelper::ConcatUnifiedOhmUrl("", path2, version);
916 exceptOutFileName = "&Index&1.0.0";
917 EXPECT_EQ(outFileName, exceptOutFileName);
918 }
919
HWTEST_F_L0(EcmaModuleTest,ConcatImportFileNormalizedOhmurl)920 HWTEST_F_L0(EcmaModuleTest, ConcatImportFileNormalizedOhmurl)
921 {
922 CString recordPath = "&entry/ets/";
923 CString requestName = "test";
924 CString outFileName = ModulePathHelper::ConcatImportFileNormalizedOhmurl(recordPath, requestName, "");
925 CString exceptOutFileName = "&entry/ets/test&";
926 EXPECT_EQ(outFileName, exceptOutFileName);
927 }
928
HWTEST_F_L0(EcmaModuleTest,ConcatNativeSoNormalizedOhmurl)929 HWTEST_F_L0(EcmaModuleTest, ConcatNativeSoNormalizedOhmurl)
930 {
931 CString pkgName = "libentry.so";
932 CString outFileName = ModulePathHelper::ConcatNativeSoNormalizedOhmurl("", "", pkgName, "");
933 CString exceptOutFileName = "@normalized:Y&&&libentry.so&";
934 EXPECT_EQ(outFileName, exceptOutFileName);
935 }
936
HWTEST_F_L0(EcmaModuleTest,ConcatNotSoNormalizedOhmurl)937 HWTEST_F_L0(EcmaModuleTest, ConcatNotSoNormalizedOhmurl)
938 {
939 CString pkgName = "har";
940 CString path = "Index";
941 CString version = "1.0.0";
942 CString outFileName = ModulePathHelper::ConcatNotSoNormalizedOhmurl("", "", pkgName, path, version);
943 CString exceptOutFileName = "@normalized:N&&&har/Index&1.0.0";
944 EXPECT_EQ(outFileName, exceptOutFileName);
945 }
946
HWTEST_F_L0(EcmaModuleTest,TransformToNormalizedOhmUrl2)947 HWTEST_F_L0(EcmaModuleTest, TransformToNormalizedOhmUrl2)
948 {
949 CString inputFileName = "/data/storage/el1/bundle/hsp/ets/modules.abc";
950 CString outBaseFileName = "/data/storage/el1/bundle/com.example.application/hsp/hsp/ets/modules.abc";
951 CString entryPoint = "com.example.myapplication/hsp/ets/pages/Index";
952 CString res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
953 EXPECT_EQ(res, "com.example.myapplication/hsp/ets/pages/Index");
954 }
955
HWTEST_F_L0(EcmaModuleTest,TranslateExpressionToNormalized)956 HWTEST_F_L0(EcmaModuleTest, TranslateExpressionToNormalized)
957 {
958 instance->SetBundleName("com.example.myapplication");
959 CString baseFilename = "merge.abc";
960 const char *data = R"(
961 .language ECMAScript
962 .function any func_main_0(any a0, any a1, any a2) {
963 ldai 1
964 return
965 }
966 )";
967 JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
968 Parser parser;
969 auto res = parser.Parse(data);
970 std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
971 std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
972
973 CString requestPath = "@native:system.app";
974 CString baseFileName = "";
975 CString recordName = "";
976 ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, recordName, requestPath);
977 EXPECT_EQ(requestPath, "@native:system.app");
978
979 requestPath = "@ohos:hilog";
980 ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, recordName, requestPath);
981 EXPECT_EQ(requestPath, "@ohos:hilog");
982
983 requestPath = "@normalized:N&&&har/Index&1.0.0";
984 ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, recordName, requestPath);
985 EXPECT_EQ(requestPath, "@normalized:N&&&har/Index&1.0.0");
986
987 requestPath = "@arkui-x.bridge";
988 CString result = ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, recordName,
989 requestPath);
990 EXPECT_EQ(result, "@ohos:bridge");
991
992 requestPath = "ets/Test";
993 recordName = "&entry/ets/pages/Index&";
994 pf->InsertJSRecordInfo("&entry/ets/Test&");
995 result = ModulePathHelper::TranslateExpressionToNormalized(thread, pf.get(), baseFileName, recordName,
996 requestPath);
997 EXPECT_EQ(result, "&entry/ets/Test&");
998 }
999
HWTEST_F_L0(EcmaModuleTest,TranslateExpressionToNormalized2)1000 HWTEST_F_L0(EcmaModuleTest, TranslateExpressionToNormalized2)
1001 {
1002 CMap<CString, CMap<CString, CVector<CString>>> pkgList;
1003 CMap<CString, CVector<CString>> entryList;
1004 entryList["entry"] = {
1005 "packageName", "entry",
1006 "bundleName", "",
1007 "moduleName", "",
1008 "version", "",
1009 "entryPath", "src/main/",
1010 "isSO", "false"
1011 };
1012 entryList["har"] = {
1013 "packageName", "har",
1014 "bundleName", "",
1015 "moduleName", "",
1016 "version", "1.2.0",
1017 "entryPath", "Index.ets",
1018 "isSO", "false"
1019 };
1020 pkgList["entry"] = entryList;
1021 instance->SetpkgContextInfoList(pkgList);
1022
1023 CString requestPath = "har";
1024 CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1025 CString result = ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, "",
1026 requestPath);
1027 EXPECT_EQ(result, "@normalized:N&&&har/Index&1.2.0");
1028
1029 requestPath = "har/src/main/Test";
1030 result = ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, "",
1031 requestPath);
1032 EXPECT_EQ(result, "@normalized:N&&&har/src/main/Test&1.2.0");
1033 }
1034
HWTEST_F_L0(EcmaModuleTest,TranslateExpressionToNormalized5)1035 HWTEST_F_L0(EcmaModuleTest, TranslateExpressionToNormalized5)
1036 {
1037 CMap<CString, CMap<CString, CVector<CString>>> pkgList;
1038 CMap<CString, CVector<CString>> entryList;
1039 entryList["har"] = {
1040 "packageName", "har",
1041 "bundleName", "",
1042 "moduleName", "",
1043 "version", "1.2.0",
1044 "entryPath", "./Index.ets",
1045 "isSO", "false"
1046 };
1047 pkgList["entry"] = entryList;
1048 instance->SetpkgContextInfoList(pkgList);
1049
1050 CMap<CString, CString> aliasMap;
1051 aliasMap["@ohos/library"] = "har";
1052 instance->SetPkgAliasList(aliasMap);
1053
1054 CString requestPath = "@ohos/library/src/main/ets/Test";
1055 CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1056 CString result = ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, "",
1057 requestPath);
1058 EXPECT_EQ(result, "@normalized:N&&&har/src/main/ets/Test&1.2.0");
1059 }
1060
HWTEST_F_L0(EcmaModuleTest,SplitNormalizedRecordName)1061 HWTEST_F_L0(EcmaModuleTest, SplitNormalizedRecordName)
1062 {
1063 CString requestPath = "&har/Index&1.0.0";
1064 CVector<CString> res = ModulePathHelper::SplitNormalizedRecordName(requestPath);
1065 int exceptCount = 5;
1066 EXPECT_EQ(res.size(), exceptCount);
1067 CString emptyStr = "";
1068 EXPECT_EQ(res[0], emptyStr);
1069 EXPECT_EQ(res[1], emptyStr);
1070 EXPECT_EQ(res[2], emptyStr);
1071
1072 CString importPath = "har/Index";
1073 EXPECT_EQ(res[3], importPath);
1074 CString version = "1.0.0";
1075 EXPECT_EQ(res[4], version);
1076 }
1077
HWTEST_F_L0(EcmaModuleTest,ConcatPreviewTestUnifiedOhmUrl)1078 HWTEST_F_L0(EcmaModuleTest, ConcatPreviewTestUnifiedOhmUrl)
1079 {
1080 CString bundleName = "";
1081 CString pkgName = "entry";
1082 CString path = "/.test/testability/pages/Index";
1083 CString version = "";
1084 CString exceptOutUrl = "&entry/.test/testability/pages/Index&";
1085 CString res = ModulePathHelper::ConcatPreviewTestUnifiedOhmUrl(bundleName, pkgName, path, version);
1086 EXPECT_EQ(res, exceptOutUrl);
1087 }
1088
HWTEST_F_L0(EcmaModuleTest,NeedTranslateToNormalized)1089 HWTEST_F_L0(EcmaModuleTest, NeedTranslateToNormalized)
1090 {
1091 CString requestName = "@ohos:hilog";
1092 bool res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1093 EXPECT_EQ(res, false);
1094
1095 requestName = "@app:com.example.myapplication/entry";
1096 res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1097 EXPECT_EQ(res, false);
1098
1099 requestName = "@bundle:com.example.myapplication/library";
1100 res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1101 EXPECT_EQ(res, false);
1102
1103 requestName = "@package:pkg_modules/.ohpm/json5@2.2.3/pkg_modules/json5/dist/index";
1104 res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1105 EXPECT_EQ(res, false);
1106
1107 requestName = "@normalized:N&&&har/Index&1.0.0";
1108 res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1109 EXPECT_EQ(res, false);
1110
1111 requestName = "json5";
1112 res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1113 EXPECT_EQ(res, true);
1114
1115 requestName = "library";
1116 res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1117 EXPECT_EQ(res, true);
1118 }
1119
HWTEST_F_L0(EcmaModuleTest,GetCurrentModuleName)1120 HWTEST_F_L0(EcmaModuleTest, GetCurrentModuleName)
1121 {
1122 ThreadNativeScope nativeScope(thread);
1123 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_module.abc";
1124 JSNApi::EnableUserUncaughtErrorHandler(instance);
1125 JSNApi::Execute(instance, baseFileName, "module_test_module_test_module");
1126 Local<ObjectRef> res = JSNApi::GetExportObject(instance, "module_test_module_test_module", "moduleName");
1127 JSHandle<JSTaggedValue> result = JSNApiHelper::ToJSHandle(res);
1128 CString moduleName = ConvertToString(result.GetTaggedValue());
1129 EXPECT_EQ(moduleName, "");
1130 }
1131
HWTEST_F_L0(EcmaModuleTest,ConcatMergeFileNameToNormalized)1132 HWTEST_F_L0(EcmaModuleTest, ConcatMergeFileNameToNormalized)
1133 {
1134 CString baseFilename = "merge.abc";
1135 const char *data = R"(
1136 .language ECMAScript
1137 .function any func_main_0(any a0, any a1, any a2) {
1138 ldai 1
1139 return
1140 }
1141 )";
1142 JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
1143 Parser parser;
1144 auto res = parser.Parse(data);
1145 std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
1146 std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
1147
1148 CString requestPath = "@normalized:N&&&har/Index&1.0.0";
1149 CString recordName = "";
1150 CString result = "&har/Index&1.0.0";
1151 CString entryPoint = ModulePathHelper::ConcatMergeFileNameToNormalized(thread, pf.get(), baseFilename, recordName,
1152 requestPath);
1153 EXPECT_EQ(result, entryPoint);
1154
1155 requestPath = "&index";
1156 result = "&index";
1157 entryPoint = ModulePathHelper::ConcatMergeFileNameToNormalized(thread, pf.get(), baseFilename, recordName,
1158 requestPath);
1159 EXPECT_EQ(result, entryPoint);
1160
1161 requestPath = "./@normalized:N&&&har/Index&1.0.0";
1162 result = "@normalized:N&&&har/Index&1.0.0&";
1163 pf->InsertJSRecordInfo(result);
1164 entryPoint = ModulePathHelper::ConcatMergeFileNameToNormalized(thread, pf.get(), baseFilename, recordName,
1165 requestPath);
1166 EXPECT_EQ(result, entryPoint);
1167
1168 recordName = "pkg_modules/.ohpm/validator@13.12.0/pkg_modules/validator/index";
1169 requestPath = "./lib/toDate";
1170 result = "pkg_modules/.ohpm/validator@13.12.0/pkg_modules/validator/lib/toDate";
1171 pf->InsertJSRecordInfo(result);
1172 CUnorderedMap<CString, JSPandaFile::JSRecordInfo*> &recordInfo =
1173 const_cast<CUnorderedMap<CString, JSPandaFile::JSRecordInfo*>&>(pf->GetJSRecordInfo());
1174 JSPandaFile::JSRecordInfo *info = new JSPandaFile::JSRecordInfo();
1175 info->npmPackageName = result;
1176 recordInfo.insert({recordName, info});
1177
1178 entryPoint = ModulePathHelper::ConcatMergeFileNameToNormalized(thread, pf.get(), baseFilename, recordName,
1179 requestPath);
1180 EXPECT_EQ(result, entryPoint);
1181
1182 delete info;
1183 recordInfo.erase(recordName);
1184 }
1185
HWTEST_F_L0(EcmaModuleTest,ModuleLogger)1186 HWTEST_F_L0(EcmaModuleTest, ModuleLogger) {
1187 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1188 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1189 CString baseFileName = "modules.abc";
1190 module1->SetEcmaModuleFilenameString(baseFileName);
1191 CString recordName1 = "a";
1192 module1->SetEcmaModuleRecordNameString(recordName1);
1193 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1194 module2->SetEcmaModuleFilenameString(baseFileName);
1195 CString recordName2 = "b";
1196 module2->SetEcmaModuleRecordNameString(recordName2);
1197 JSHandle<JSTaggedValue> moduleRequest = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("c"));
1198 JSHandle<JSTaggedValue> importName = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("ccc"));
1199 JSHandle<JSTaggedValue> localName = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("ccc"));
1200 JSHandle<ImportEntry> importEntry = objectFactory->NewImportEntry(moduleRequest, importName,
1201 localName, SharedTypes::UNSENDABLE_MODULE);
1202 SourceTextModule::AddImportEntry(thread, module2, importEntry, 0, 1);
1203 JSHandle<SourceTextModule> module3 = objectFactory->NewSourceTextModule();
1204 module2->SetEcmaModuleFilenameString(baseFileName);
1205 CString recordName3 = "c";
1206 module2->SetEcmaModuleRecordNameString(recordName3);
1207 ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
1208 moduleLogger->SetStartTime(recordName1);
1209 moduleLogger->SetEndTime(recordName1);
1210 moduleLogger->SetStartTime(recordName2);
1211 moduleLogger->SetEndTime(recordName2);
1212 moduleLogger->SetStartTime(recordName3);
1213 moduleLogger->InsertEntryPointModule(module1);
1214 moduleLogger->InsertParentModule(module1, module2);
1215 moduleLogger->InsertModuleLoadInfo(module2, module3, -1);
1216 moduleLogger->InsertModuleLoadInfo(module2, module3, 0);
1217 moduleLogger->PrintModuleLoadInfo();
1218 Local<JSValueRef> nativeFunc = SourceTextModule::GetRequireNativeModuleFunc(thread->GetEcmaVM(),
1219 module3->GetTypes());
1220 bool isFunc = nativeFunc->IsFunction(thread->GetEcmaVM());
1221 EXPECT_EQ(isFunc, false);
1222 }
1223
HWTEST_F_L0(EcmaModuleTest,GetRequireNativeModuleFunc)1224 HWTEST_F_L0(EcmaModuleTest, GetRequireNativeModuleFunc) {
1225 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1226 JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
1227 uint16_t registerNum = module->GetRegisterCounts();
1228 module->SetStatus(ecmascript::ModuleStatus::INSTANTIATED);
1229 module->SetRegisterCounts(registerNum);
1230 Local<JSValueRef> nativeFunc = SourceTextModule::GetRequireNativeModuleFunc(thread->GetEcmaVM(),
1231 module->GetTypes());
1232 bool isFunc = nativeFunc->IsFunction(thread->GetEcmaVM());
1233 EXPECT_EQ(isFunc, false);
1234 }
1235
1236 /*
1237 * Feature: Module
1238 * Function: StoreModuleValue
1239 * SubFunction: StoreModuleValue/GetModuleValue
1240 * FunctionPoints: store a module export item in module
1241 * CaseDescription: Simulated implementation of "export foo as bar", set foo as "hello world",
1242 * use "import bar" in same js file
1243 */
HWTEST_F_L0(EcmaModuleTest,StoreModuleValue2)1244 HWTEST_F_L0(EcmaModuleTest, StoreModuleValue2)
1245 {
1246 ObjectFactory* objFactory = thread->GetEcmaVM()->GetFactory();
1247 CString localName = "foo";
1248 CString exportName = "bar";
1249 CString value = "hello world";
1250 CString value2 = "hello world1";
1251 int32_t index = 1;
1252
1253 JSHandle<JSTaggedValue> localNameHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
1254 JSHandle<JSTaggedValue> exportNameHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName));
1255 JSHandle<LocalExportEntry> localExportEntry =
1256 objFactory->NewLocalExportEntry(exportNameHandle, localNameHandle, LocalExportEntry::LOCAL_DEFAULT_INDEX,
1257 SharedTypes::UNSENDABLE_MODULE);
1258 JSHandle<SourceTextModule> module = objFactory->NewSourceTextModule();
1259 SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry, 0, 1);
1260
1261 JSHandle<JSTaggedValue> storeKey = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
1262 JSHandle<JSTaggedValue> valueHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(value));
1263 JSHandle<JSTaggedValue> valueHandle1 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(value2));
1264 module->StoreModuleValue(thread, storeKey, valueHandle);
1265 module->StoreModuleValue(thread, index, valueHandle1);
1266 JSHandle<JSTaggedValue> loadKey = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
1267 JSTaggedValue loadValue = module->GetModuleValue(thread, loadKey.GetTaggedValue(), false);
1268 JSTaggedValue loadValue1 = module->GetModuleValue(thread, index, false);
1269 EXPECT_EQ(valueHandle.GetTaggedValue(), loadValue);
1270 EXPECT_EQ(valueHandle1.GetTaggedValue(), loadValue1);
1271 }
1272
HWTEST_F_L0(EcmaModuleTest,MakeAppArgs1)1273 HWTEST_F_L0(EcmaModuleTest, MakeAppArgs1) {
1274 std::vector<Local<JSValueRef>> arguments;
1275 CString soPath = "@normalized:Y&&&libentry.so&";
1276 CString moduleName = "entry";
1277 CString requestName = "@normalized:";
1278 arguments.emplace_back(StringRef::NewFromUtf8(thread->GetEcmaVM(), soPath.c_str()));
1279 SourceTextModule::MakeAppArgs(thread->GetEcmaVM(), arguments, soPath, moduleName, requestName);
1280 std::string res1 = arguments[0]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1281 std::string res2 = arguments[1]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1282 std::string res3 = arguments[2]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1283 EXPECT_TRUE(res1 == "entry");
1284 EXPECT_TRUE(res2 == "true");
1285 EXPECT_TRUE(res3 == "/entry");
1286 }
1287
HWTEST_F_L0(EcmaModuleTest,MakeAppArgs2)1288 HWTEST_F_L0(EcmaModuleTest, MakeAppArgs2) {
1289 std::vector<Local<JSValueRef>> arguments;
1290 CString soPath = "@app:com.example.myapplication/entry";
1291 CString moduleName = "entry";
1292 CString requestName = "@app:";
1293 arguments.emplace_back(StringRef::NewFromUtf8(thread->GetEcmaVM(), soPath.c_str()));
1294 SourceTextModule::MakeAppArgs(thread->GetEcmaVM(), arguments, soPath, moduleName, requestName);
1295 std::string res1 = arguments[0]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1296 std::string res2 = arguments[1]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1297 std::string res3 = arguments[2]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1298 EXPECT_TRUE(res1 == "entry");
1299 EXPECT_TRUE(res2 == "true");
1300 EXPECT_TRUE(res3 == "@app:com.example.myapplication");
1301 }
1302
HWTEST_F_L0(EcmaModuleTest,ConcatHspFileNameCrossBundle)1303 HWTEST_F_L0(EcmaModuleTest, ConcatHspFileNameCrossBundle)
1304 {
1305 CString bundleName = "com.example.application";
1306 CString moduleName = "entry";
1307 CString expectRes = "/data/storage/el1/bundle/com.example.application/entry/entry/ets/modules.abc";
1308 CString res = ModulePathHelper::ConcatHspFileNameCrossBundle(bundleName, moduleName);
1309 EXPECT_EQ(res, expectRes);
1310 }
1311
HWTEST_F_L0(EcmaModuleTest,ConcatHspFileName)1312 HWTEST_F_L0(EcmaModuleTest, ConcatHspFileName)
1313 {
1314 CString moduleName = "entry";
1315 CString expectRes = "/data/storage/el1/bundle/entry/ets/modules.abc";
1316 CString res = ModulePathHelper::ConcatHspFileName(moduleName);
1317 EXPECT_EQ(res, expectRes);
1318 }
1319
HWTEST_F_L0(EcmaModuleTest,ParseNormalizedOhmUrl)1320 HWTEST_F_L0(EcmaModuleTest, ParseNormalizedOhmUrl)
1321 {
1322 CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1323 CString recordName = "&har/Index&1.0.0";
1324 CString requestName = "@normalized:N&&&har/src/main/page/Test&1.0.0";
1325 CString expectRes = "&har/src/main/page/Test&1.0.0";
1326 CString exceptBaseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1327 CString res = ModulePathHelper::ParseNormalizedOhmUrl(thread, baseFileName, recordName, requestName);
1328 EXPECT_EQ(res, expectRes);
1329 EXPECT_EQ(baseFileName, exceptBaseFileName);
1330
1331 baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1332 requestName = "@normalized:N&hsp&&hsp/src/main/page/Test&1.0.0";
1333 expectRes = "&hsp/src/main/page/Test&1.0.0";
1334 exceptBaseFileName = "/data/storage/el1/bundle/hsp/ets/modules.abc";
1335 CString res2 = ModulePathHelper::ParseNormalizedOhmUrl(thread, baseFileName, recordName, requestName);
1336 EXPECT_EQ(res2, expectRes);
1337 EXPECT_EQ(baseFileName, exceptBaseFileName);
1338
1339 baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1340 requestName = "@normalized:N&hsp&com.example.application&hsp/src/main/page/Test&1.0.0";
1341 exceptBaseFileName = "/data/storage/el1/bundle/com.example.application/hsp/hsp/ets/modules.abc";
1342 expectRes = "com.example.application&hsp/src/main/page/Test&1.0.0";
1343 CString res3 = ModulePathHelper::ParseNormalizedOhmUrl(thread, baseFileName, recordName, requestName);
1344 EXPECT_EQ(res3, expectRes);
1345 EXPECT_EQ(baseFileName, exceptBaseFileName);
1346
1347 baseFileName = "";
1348 recordName = "&har/Index&1.0.0";
1349 requestName = "@normalized:N&&&har/src/main/page/Test&1.0.0";
1350 CString res4 = ModulePathHelper::ParseNormalizedOhmUrl(thread, baseFileName, recordName, requestName);
1351 EXPECT_EQ(baseFileName, "");
1352 }
1353
HWTEST_F_L0(EcmaModuleTest,GetModuleNameWithBaseFile)1354 HWTEST_F_L0(EcmaModuleTest, GetModuleNameWithBaseFile)
1355 {
1356 CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1357 CString expectRes = "entry";
1358 CString res = ModulePathHelper::GetModuleNameWithBaseFile(baseFileName);
1359 EXPECT_EQ(res, expectRes);
1360
1361 baseFileName = "/data/storage/el1/bundle/com.example.application/hsp/hsp/ets/modules.abc";
1362 expectRes = "hsp";
1363 res = ModulePathHelper::GetModuleNameWithBaseFile(baseFileName);
1364 EXPECT_EQ(res, expectRes);
1365 }
1366
HWTEST_F_L0(EcmaModuleTest,GetBundleNameWithRecordName)1367 HWTEST_F_L0(EcmaModuleTest, GetBundleNameWithRecordName)
1368 {
1369 CString recordName = "com.example.myapplication/library";
1370 CString expectRes = "com.example.myapplication";
1371 CString res = ModulePathHelper::GetBundleNameWithRecordName(instance, recordName);
1372 EXPECT_EQ(res, expectRes);
1373
1374 CMap<CString, CMap<CString, CVector<CString>>> list;
1375 CMap<CString, CVector<CString>> childList;
1376 list["hsp"] = childList;
1377 instance->SetpkgContextInfoList(list);
1378
1379 recordName = "&hsp&com.example.application&hsp/src/main/page/Test&1.0.0";
1380 expectRes = "com.example.application";
1381 res = ModulePathHelper::GetBundleNameWithRecordName(instance, recordName);
1382 EXPECT_EQ(res, expectRes);
1383
1384 instance->SetBundleName("com.example1.application");
1385 recordName = "&har/src/main/page/Test&1.0.0";
1386 expectRes = "com.example1.application";
1387 res = ModulePathHelper::GetBundleNameWithRecordName(instance, recordName);
1388 EXPECT_EQ(res, expectRes);
1389 }
1390
HWTEST_F_L0(EcmaModuleTest,TransformToNormalizedOhmUrl)1391 HWTEST_F_L0(EcmaModuleTest, TransformToNormalizedOhmUrl)
1392 {
1393 CMap<CString, CMap<CString, CVector<CString>>> pkgList;
1394 CMap<CString, CVector<CString>> entryList;
1395 entryList["entry"] = {
1396 "packageName", "entry",
1397 "bundleName", "",
1398 "moduleName", "",
1399 "version", "",
1400 "entryPath", "src/main/",
1401 "isSO", "false"
1402 };
1403 entryList["har"] = {
1404 "packageName", "har",
1405 "bundleName", "",
1406 "moduleName", "",
1407 "version", "1.2.0",
1408 "entryPath", "",
1409 "isSO", "false"
1410 };
1411 pkgList["entry"] = entryList;
1412 CMap<CString, CVector<CString>> ohosTestList;
1413 ohosTestList["ohosTest"] = {
1414 "packageName", "ohosTest",
1415 "bundleName", "",
1416 "moduleName", "",
1417 "version", "",
1418 "entryPath", "src/",
1419 "isSO", "false"
1420 };
1421 pkgList["ohosTest"] = ohosTestList;
1422 instance->SetpkgContextInfoList(pkgList);
1423
1424 CString inputFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1425 CString outBaseFileName = "";
1426 CString entryPoint = "ENTRY_MAIN_FUNCTION";
1427 CString res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1428 EXPECT_EQ(res, "ENTRY_MAIN_FUNCTION");
1429
1430 outBaseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1431 entryPoint = "com.example.myapplication/entry@har/ets/pages/Index";
1432 res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1433 EXPECT_EQ(res, "&har/src/main/ets/pages/Index&1.2.0");
1434
1435 outBaseFileName = "/data/storage/el1/bundle/ohosTest/ets/modules.abc";
1436 entryPoint = "com.example.myapplication/ohosTest/ets/pages/Index";
1437 res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1438 EXPECT_EQ(res, "&ohosTest/src/ets/pages/Index&");
1439
1440 outBaseFileName = "/data/storage/el1/bundle/entry/.test/ets/modules.abc";
1441 entryPoint = "com.example.myapplication/entry/.test/ets/pages/Index";
1442 res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1443 EXPECT_EQ(res, "&entry/.test/ets/pages/Index&");
1444 }
1445
HWTEST_F_L0(EcmaModuleTest,TranslateExpressionInputWithEts)1446 HWTEST_F_L0(EcmaModuleTest, TranslateExpressionInputWithEts)
1447 {
1448 instance->SetBundleName("com.example.myapplication");
1449 CString baseFilename = "merge.abc";
1450 const char *data = R"(
1451 .language ECMAScript
1452 .function any func_main_0(any a0, any a1, any a2) {
1453 ldai 1
1454 return
1455 }
1456 )";
1457 JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
1458 Parser parser;
1459 auto res = parser.Parse(data);
1460 std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
1461 std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
1462
1463 CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1464 CString requestName = "ets/Test";
1465 CString recordName = "com.example.myapplication/entry/ets/pages/Index";
1466 CString expectRes = "com.example.myapplication/entry/ets/Test";
1467 CString result = ModulePathHelper::TranslateExpressionInputWithEts(thread, pf.get(), baseFileName, requestName);
1468 EXPECT_EQ(result, "");
1469
1470 pf->InsertJSRecordInfo(expectRes);
1471 result = ModulePathHelper::TranslateExpressionInputWithEts(thread, pf.get(), baseFileName, requestName);
1472 EXPECT_EQ(result, expectRes);
1473 }
1474
HWTEST_F_L0(EcmaModuleTest,ReviseLoadedModuleCount1)1475 HWTEST_F_L0(EcmaModuleTest, ReviseLoadedModuleCount1) {
1476 CString moduleName = "testModule";
1477 ModuleDeregister::ReviseLoadedModuleCount(thread, moduleName);
1478 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1479 bool res = moduleManager->IsLocalModuleLoaded(moduleName);
1480 EXPECT_EQ(res, false);
1481 }
1482
HWTEST_F_L0(EcmaModuleTest,IncreaseRegisterCounts)1483 HWTEST_F_L0(EcmaModuleTest, IncreaseRegisterCounts)
1484 {
1485 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1486 JSNApi::EnableUserUncaughtErrorHandler(instance);
1487 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1488 EXPECT_TRUE(result);
1489 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1490 JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
1491 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1492 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1493 std::set<CString> increaseModule;
1494
1495 ModuleDeregister::IncreaseRegisterCounts(thread, module, increaseModule);
1496 module->SetRegisterCounts(INT8_MAX);
1497 ModuleDeregister::IncreaseRegisterCounts(thread, module, increaseModule);
1498 module2->SetRegisterCounts(INT8_MAX);
1499 ModuleDeregister::IncreaseRegisterCounts(thread, module2, increaseModule);
1500 module2->SetLoadingTypes(LoadingTypes::STABLE_MODULE);
1501 ModuleDeregister::IncreaseRegisterCounts(thread, module2, increaseModule);
1502 }
1503
HWTEST_F_L0(EcmaModuleTest,DecreaseRegisterCounts)1504 HWTEST_F_L0(EcmaModuleTest, DecreaseRegisterCounts)
1505 {
1506 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1507 JSNApi::EnableUserUncaughtErrorHandler(instance);
1508 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1509 EXPECT_TRUE(result);
1510 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1511 JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
1512 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1513 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1514 std::set<CString> decreaseModule;
1515
1516 ModuleDeregister::DecreaseRegisterCounts(thread, module, decreaseModule);
1517 module->SetRegisterCounts(INT8_MAX);
1518 ModuleDeregister::DecreaseRegisterCounts(thread, module, decreaseModule);
1519 module2->SetLoadingTypes(LoadingTypes::DYNAMITC_MODULE);
1520 ModuleDeregister::DecreaseRegisterCounts(thread, module2, decreaseModule);
1521 }
1522
HWTEST_F_L0(EcmaModuleTest,GetSendableModuleValueImpl)1523 HWTEST_F_L0(EcmaModuleTest, GetSendableModuleValueImpl) {
1524 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1525 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1526 SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1527 int32_t index = 2;
1528 JSTaggedValue currentModule1 = module1.GetTaggedValue();
1529 manager1->GetSendableModuleValueImpl(thread, index, currentModule1);
1530
1531 SharedModuleManager* manager2 = SharedModuleManager::GetInstance();
1532 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1533 JSNApi::EnableUserUncaughtErrorHandler(instance);
1534 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1535 EXPECT_TRUE(result);
1536 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1537 JSHandle<SourceTextModule> module2 = moduleManager->HostGetImportedModule("module_test_module_test_C");
1538 JSTaggedValue currentModule2 = module2.GetTaggedValue();
1539 manager2->GetSendableModuleValueImpl(thread, index, currentModule2);
1540 }
1541
HWTEST_F_L0(EcmaModuleTest,GetLazySendableModuleValueImpl)1542 HWTEST_F_L0(EcmaModuleTest, GetLazySendableModuleValueImpl) {
1543 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1544 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1545 SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1546 int32_t index = 2;
1547 JSTaggedValue currentModule1 = module1.GetTaggedValue();
1548 manager1->GetLazySendableModuleValueImpl(thread, index, currentModule1);
1549 }
1550
HWTEST_F_L0(EcmaModuleTest,ResolveImportedModuleWithMerge)1551 HWTEST_F_L0(EcmaModuleTest, ResolveImportedModuleWithMerge) {
1552 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1553 JSNApi::EnableUserUncaughtErrorHandler(instance);
1554 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1555 EXPECT_TRUE(result);
1556 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1557 JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
1558 module->SetSharedType(SharedTypes::SHARED_MODULE);
1559
1560 CString recordName2 = "testModule";
1561 SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1562 bool executeFromJob = false;
1563 manager1->ResolveImportedModuleWithMerge(thread, baseFileName.c_str(), recordName2, executeFromJob);
1564 }
1565
HWTEST_F_L0(EcmaModuleTest,ResolveImportedModuleWithMerge2)1566 HWTEST_F_L0(EcmaModuleTest, ResolveImportedModuleWithMerge2) {
1567 CString moduleName1;
1568 CString recordName1;
1569
1570 SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1571 bool executeFromJob = false;
1572 manager1->ResolveImportedModuleWithMerge(thread, moduleName1, recordName1, executeFromJob);
1573 }
1574
HWTEST_F_L0(EcmaModuleTest,IsInstaniatedSModule)1575 HWTEST_F_L0(EcmaModuleTest, IsInstaniatedSModule) {
1576 SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1577 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1578 JSNApi::EnableUserUncaughtErrorHandler(instance);
1579 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1580 EXPECT_TRUE(result);
1581 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1582 JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
1583 bool res = manager1->IsInstaniatedSModule(thread, module);
1584 EXPECT_EQ(res, true);
1585 }
1586
HWTEST_F_L0(EcmaModuleTest,ProcessModuleLoadInfoForESM)1587 HWTEST_F_L0(EcmaModuleTest, ProcessModuleLoadInfoForESM)
1588 {
1589 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1590 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1591 CString baseFileName = "modules.abc";
1592 module1->SetEcmaModuleFilenameString(baseFileName);
1593 CString recordName1 = "a";
1594 module1->SetEcmaModuleRecordNameString(recordName1);
1595 JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
1596 JSHandle<ImportEntry> importEntry =
1597 objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
1598 SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
1599
1600 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1601 module2->SetEcmaModuleFilenameString(baseFileName);
1602 CString recordName2 = "b";
1603 module2->SetEcmaModuleRecordNameString(recordName2);
1604 JSHandle<LocalExportEntry> localExportEntry =
1605 objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
1606 JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
1607 localExportEntries->Set(thread, 0, localExportEntry);
1608 module2->SetLocalExportEntries(thread, localExportEntries);
1609 module2->StoreModuleValue(thread, 0, val);
1610 module2->SetStatus(ModuleStatus::EVALUATED);
1611 ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
1612 thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
1613 // test ResolvedIndexBinding
1614 JSHandle<ResolvedIndexBinding> indexBinding =
1615 objectFactory->NewResolvedIndexBindingRecord(module2, 0);
1616 JSTaggedValue res1 = ModuleTools::ProcessModuleLoadInfo(thread, module1, indexBinding.GetTaggedValue(), 0);
1617 EXPECT_EQ(res1, val.GetTaggedValue());
1618
1619 JSTaggedValue res2 = ModuleTools::ProcessModuleNameSpaceLoadInfo(thread, module1, module2);
1620 EXPECT_NE(res2, JSTaggedValue::Exception());
1621 thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
1622 delete moduleLogger;
1623 }
1624
HWTEST_F_L0(EcmaModuleTest,ProcessModuleLoadInfoForCJS)1625 HWTEST_F_L0(EcmaModuleTest, ProcessModuleLoadInfoForCJS)
1626 {
1627 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1628 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1629 CString baseFileName = "modules.abc";
1630 module1->SetEcmaModuleFilenameString(baseFileName);
1631 CString recordName1 = "a";
1632 module1->SetEcmaModuleRecordNameString(recordName1);
1633 JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
1634 JSHandle<ImportEntry> importEntry =
1635 objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
1636 SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
1637
1638 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1639 module2->SetEcmaModuleFilenameString(baseFileName);
1640 CString recordName2 = "cjs";
1641 module2->SetEcmaModuleRecordNameString(recordName2);
1642 JSHandle<LocalExportEntry> localExportEntry =
1643 objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
1644 JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
1645 localExportEntries->Set(thread, 0, localExportEntry);
1646 module2->SetLocalExportEntries(thread, localExportEntries);
1647 module2->StoreModuleValue(thread, 0, val);
1648 module2->SetTypes(ModuleTypes::CJS_MODULE);
1649 module2->SetStatus(ModuleStatus::EVALUATED);
1650 JSHandle<CjsModule> moduleCjs = objectFactory->NewCjsModule();
1651 JSHandle<JSTaggedValue> recordName2Hdl =
1652 JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(recordName2.c_str()));
1653 JSHandle<JSTaggedValue> baseFileNameHdl =
1654 JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(baseFileName.c_str()));
1655 CjsModule::InitializeModule(thread, moduleCjs, recordName2Hdl, baseFileNameHdl);
1656 CjsModule::PutIntoCache(thread, moduleCjs, recordName2Hdl);
1657
1658 JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
1659 JSHandle<JSTaggedValue> resolution =
1660 JSHandle<JSTaggedValue>::Cast(objectFactory->NewResolvedBindingRecord(module2, val));
1661 envRec->Set(thread, 0, resolution);
1662 module1->SetEnvironment(thread, envRec);
1663
1664 ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
1665 thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
1666
1667 // test ResolvedBinding
1668 JSTaggedValue res1 = ModuleTools::ProcessModuleNameSpaceLoadInfo(thread, module1, module2);
1669 EXPECT_NE(res1, JSTaggedValue::Exception());
1670
1671 JSTaggedValue res2 = ModuleTools::ProcessModuleLoadInfo(thread, module1, resolution.GetTaggedValue(), 0);
1672 EXPECT_EQ(res2, JSTaggedValue::Exception());
1673 thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
1674 delete moduleLogger;
1675 }
1676
HWTEST_F_L0(EcmaModuleTest,ProcessModuleLoadInfoForNativeModule)1677 HWTEST_F_L0(EcmaModuleTest, ProcessModuleLoadInfoForNativeModule)
1678 {
1679 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1680 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1681 CString baseFileName = "modules.abc";
1682 module1->SetEcmaModuleFilenameString(baseFileName);
1683 CString recordName1 = "a";
1684 module1->SetEcmaModuleRecordNameString(recordName1);
1685 JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
1686 JSHandle<ImportEntry> importEntry =
1687 objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
1688 SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
1689
1690 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1691 module2->SetEcmaModuleFilenameString(baseFileName);
1692 CString recordName2 = "nativeModule";
1693 module2->SetEcmaModuleRecordNameString(recordName2);
1694 JSHandle<LocalExportEntry> localExportEntry =
1695 objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
1696 JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
1697 localExportEntries->Set(thread, 0, localExportEntry);
1698 module2->SetLocalExportEntries(thread, localExportEntries);
1699 module2->StoreModuleValue(thread, 0, val);
1700 module2->SetTypes(ModuleTypes::NATIVE_MODULE);
1701 module2->SetStatus(ModuleStatus::EVALUATED);
1702
1703 JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
1704 JSHandle<JSTaggedValue> resolution = JSHandle<JSTaggedValue>::Cast(
1705 objectFactory->NewResolvedBindingRecord(module2, val));
1706 envRec->Set(thread, 0, resolution);
1707 module1->SetEnvironment(thread, envRec);
1708
1709 ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
1710 thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
1711
1712 JSTaggedValue res1 = ModuleTools::ProcessModuleLoadInfo(thread, module1, resolution.GetTaggedValue(), 0);
1713 EXPECT_EQ(res1, JSTaggedValue::Exception());
1714
1715 JSTaggedValue res2 = ModuleTools::ProcessModuleNameSpaceLoadInfo(thread, module1, module2);
1716 EXPECT_NE(res2, JSTaggedValue::Exception());
1717 thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
1718 delete moduleLogger;
1719 }
1720
HWTEST_F_L0(EcmaModuleTest,ResolvedBindingForLog)1721 HWTEST_F_L0(EcmaModuleTest, ResolvedBindingForLog)
1722 {
1723 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1724 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1725 CString baseFileName = "modules.abc";
1726 module1->SetEcmaModuleFilenameString(baseFileName);
1727 CString recordName1 = "a";
1728 module1->SetEcmaModuleRecordNameString(recordName1);
1729 JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
1730 JSHandle<ImportEntry> importEntry =
1731 objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
1732 SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
1733
1734 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1735 module2->SetEcmaModuleFilenameString(baseFileName);
1736 CString recordName2 = "b";
1737 module2->SetEcmaModuleRecordNameString(recordName2);
1738 JSHandle<LocalExportEntry> localExportEntry =
1739 objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
1740 JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
1741 localExportEntries->Set(thread, 0, localExportEntry);
1742 module2->SetLocalExportEntries(thread, localExportEntries);
1743 module2->StoreModuleValue(thread, 0, val);
1744 module2->SetStatus(ModuleStatus::EVALUATED);
1745 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1746 moduleManager->AddResolveImportedModule(recordName2, module2.GetTaggedValue());
1747
1748 ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
1749 thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
1750 // test ResolvedRecordIndexBinding
1751 JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName2);
1752 JSHandle<EcmaString> baseFileNameHdl = objectFactory->NewFromUtf8(baseFileName);
1753 JSHandle<ResolvedRecordIndexBinding> recordIndexBinding =
1754 objectFactory->NewSResolvedRecordIndexBindingRecord(recordNameHdl, baseFileNameHdl, 0);
1755 JSTaggedValue res1 = ModuleTools::ProcessModuleLoadInfo(thread, module1, recordIndexBinding.GetTaggedValue(), 0);
1756 EXPECT_EQ(res1, val.GetTaggedValue());
1757
1758 // test ResolvedRecordBinding
1759 JSHandle<ResolvedRecordBinding> nameBinding =
1760 objectFactory->NewSResolvedRecordBindingRecord(recordNameHdl, val);
1761 JSTaggedValue res2 = ModuleTools::ProcessModuleLoadInfo(thread, module1, nameBinding.GetTaggedValue(), 0);
1762 EXPECT_EQ(res2, JSTaggedValue::Exception());
1763 thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
1764 delete moduleLogger;
1765 }
1766
HWTEST_F_L0(EcmaModuleTest,ToStringWithPrecision)1767 HWTEST_F_L0(EcmaModuleTest, ToStringWithPrecision)
1768 {
1769 std::string res = ModuleLogger::ToStringWithPrecision(4.550, 3);
1770 EXPECT_EQ(res, "4.55");
1771 }
1772 } // namespace panda::test
1773