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,ModuleLogger)1132 HWTEST_F_L0(EcmaModuleTest, ModuleLogger) {
1133 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1134 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1135 CString baseFileName = "modules.abc";
1136 module1->SetEcmaModuleFilenameString(baseFileName);
1137 CString recordName1 = "a";
1138 module1->SetEcmaModuleRecordNameString(recordName1);
1139 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1140 module2->SetEcmaModuleFilenameString(baseFileName);
1141 CString recordName2 = "b";
1142 module2->SetEcmaModuleRecordNameString(recordName2);
1143 JSHandle<JSTaggedValue> moduleRequest = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("c"));
1144 JSHandle<JSTaggedValue> importName = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("ccc"));
1145 JSHandle<JSTaggedValue> localName = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("ccc"));
1146 JSHandle<ImportEntry> importEntry = objectFactory->NewImportEntry(moduleRequest, importName,
1147 localName, SharedTypes::UNSENDABLE_MODULE);
1148 SourceTextModule::AddImportEntry(thread, module2, importEntry, 0, 1);
1149 JSHandle<SourceTextModule> module3 = objectFactory->NewSourceTextModule();
1150 module2->SetEcmaModuleFilenameString(baseFileName);
1151 CString recordName3 = "c";
1152 module2->SetEcmaModuleRecordNameString(recordName3);
1153 ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
1154 moduleLogger->SetStartTime(recordName1);
1155 moduleLogger->SetEndTime(recordName1);
1156 moduleLogger->SetStartTime(recordName2);
1157 moduleLogger->SetEndTime(recordName2);
1158 moduleLogger->SetStartTime(recordName3);
1159 moduleLogger->InsertEntryPointModule(module1);
1160 moduleLogger->InsertParentModule(module1, module2);
1161 moduleLogger->InsertModuleLoadInfo(module2, module3, -1);
1162 moduleLogger->InsertModuleLoadInfo(module2, module3, 0);
1163 moduleLogger->PrintModuleLoadInfo();
1164 Local<JSValueRef> nativeFunc = SourceTextModule::GetRequireNativeModuleFunc(thread->GetEcmaVM(),
1165 module3->GetTypes());
1166 bool isFunc = nativeFunc->IsFunction(thread->GetEcmaVM());
1167 EXPECT_EQ(isFunc, false);
1168 }
1169
HWTEST_F_L0(EcmaModuleTest,GetRequireNativeModuleFunc)1170 HWTEST_F_L0(EcmaModuleTest, GetRequireNativeModuleFunc) {
1171 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1172 JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
1173 uint16_t registerNum = module->GetRegisterCounts();
1174 module->SetStatus(ecmascript::ModuleStatus::INSTANTIATED);
1175 module->SetRegisterCounts(registerNum);
1176 Local<JSValueRef> nativeFunc = SourceTextModule::GetRequireNativeModuleFunc(thread->GetEcmaVM(),
1177 module->GetTypes());
1178 bool isFunc = nativeFunc->IsFunction(thread->GetEcmaVM());
1179 EXPECT_EQ(isFunc, false);
1180 }
1181
1182 /*
1183 * Feature: Module
1184 * Function: StoreModuleValue
1185 * SubFunction: StoreModuleValue/GetModuleValue
1186 * FunctionPoints: store a module export item in module
1187 * CaseDescription: Simulated implementation of "export foo as bar", set foo as "hello world",
1188 * use "import bar" in same js file
1189 */
HWTEST_F_L0(EcmaModuleTest,StoreModuleValue2)1190 HWTEST_F_L0(EcmaModuleTest, StoreModuleValue2)
1191 {
1192 ObjectFactory* objFactory = thread->GetEcmaVM()->GetFactory();
1193 CString localName = "foo";
1194 CString exportName = "bar";
1195 CString value = "hello world";
1196 CString value2 = "hello world1";
1197 int32_t index = 1;
1198
1199 JSHandle<JSTaggedValue> localNameHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
1200 JSHandle<JSTaggedValue> exportNameHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName));
1201 JSHandle<LocalExportEntry> localExportEntry =
1202 objFactory->NewLocalExportEntry(exportNameHandle, localNameHandle, LocalExportEntry::LOCAL_DEFAULT_INDEX,
1203 SharedTypes::UNSENDABLE_MODULE);
1204 JSHandle<SourceTextModule> module = objFactory->NewSourceTextModule();
1205 SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry, 0, 1);
1206
1207 JSHandle<JSTaggedValue> storeKey = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
1208 JSHandle<JSTaggedValue> valueHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(value));
1209 JSHandle<JSTaggedValue> valueHandle1 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(value2));
1210 module->StoreModuleValue(thread, storeKey, valueHandle);
1211 module->StoreModuleValue(thread, index, valueHandle1);
1212 JSHandle<JSTaggedValue> loadKey = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
1213 JSTaggedValue loadValue = module->GetModuleValue(thread, loadKey.GetTaggedValue(), false);
1214 JSTaggedValue loadValue1 = module->GetModuleValue(thread, index, false);
1215 EXPECT_EQ(valueHandle.GetTaggedValue(), loadValue);
1216 EXPECT_EQ(valueHandle1.GetTaggedValue(), loadValue1);
1217 }
1218
HWTEST_F_L0(EcmaModuleTest,MakeAppArgs1)1219 HWTEST_F_L0(EcmaModuleTest, MakeAppArgs1) {
1220 std::vector<Local<JSValueRef>> arguments;
1221 CString soPath = "@normalized:Y&&&libentry.so&";
1222 CString moduleName = "entry";
1223 CString requestName = "@normalized:";
1224 arguments.emplace_back(StringRef::NewFromUtf8(thread->GetEcmaVM(), soPath.c_str()));
1225 SourceTextModule::MakeAppArgs(thread->GetEcmaVM(), arguments, soPath, moduleName, requestName);
1226 std::string res1 = arguments[0]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1227 std::string res2 = arguments[1]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1228 std::string res3 = arguments[2]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1229 EXPECT_TRUE(res1 == "entry");
1230 EXPECT_TRUE(res2 == "true");
1231 EXPECT_TRUE(res3 == "/entry");
1232 }
1233
HWTEST_F_L0(EcmaModuleTest,MakeAppArgs2)1234 HWTEST_F_L0(EcmaModuleTest, MakeAppArgs2) {
1235 std::vector<Local<JSValueRef>> arguments;
1236 CString soPath = "@app:com.example.myapplication/entry";
1237 CString moduleName = "entry";
1238 CString requestName = "@app:";
1239 arguments.emplace_back(StringRef::NewFromUtf8(thread->GetEcmaVM(), soPath.c_str()));
1240 SourceTextModule::MakeAppArgs(thread->GetEcmaVM(), arguments, soPath, moduleName, requestName);
1241 std::string res1 = arguments[0]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1242 std::string res2 = arguments[1]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1243 std::string res3 = arguments[2]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1244 EXPECT_TRUE(res1 == "entry");
1245 EXPECT_TRUE(res2 == "true");
1246 EXPECT_TRUE(res3 == "@app:com.example.myapplication");
1247 }
1248
HWTEST_F_L0(EcmaModuleTest,ConcatHspFileNameCrossBundle)1249 HWTEST_F_L0(EcmaModuleTest, ConcatHspFileNameCrossBundle)
1250 {
1251 CString bundleName = "com.example.application";
1252 CString moduleName = "entry";
1253 CString expectRes = "/data/storage/el1/bundle/com.example.application/entry/entry/ets/modules.abc";
1254 CString res = ModulePathHelper::ConcatHspFileNameCrossBundle(bundleName, moduleName);
1255 EXPECT_EQ(res, expectRes);
1256 }
1257
HWTEST_F_L0(EcmaModuleTest,ConcatHspFileName)1258 HWTEST_F_L0(EcmaModuleTest, ConcatHspFileName)
1259 {
1260 CString moduleName = "entry";
1261 CString expectRes = "/data/storage/el1/bundle/entry/ets/modules.abc";
1262 CString res = ModulePathHelper::ConcatHspFileName(moduleName);
1263 EXPECT_EQ(res, expectRes);
1264 }
1265
HWTEST_F_L0(EcmaModuleTest,ParseNormalizedOhmUrl)1266 HWTEST_F_L0(EcmaModuleTest, ParseNormalizedOhmUrl)
1267 {
1268 CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1269 CString recordName = "&har/Index&1.0.0";
1270 CString requestName = "@normalized:N&&&har/src/main/page/Test&1.0.0";
1271 CString expectRes = "&har/src/main/page/Test&1.0.0";
1272 CString exceptBaseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1273 CString res = ModulePathHelper::ParseNormalizedOhmUrl(thread, baseFileName, recordName, requestName);
1274 EXPECT_EQ(res, expectRes);
1275 EXPECT_EQ(baseFileName, exceptBaseFileName);
1276
1277 baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1278 requestName = "@normalized:N&hsp&&hsp/src/main/page/Test&1.0.0";
1279 expectRes = "&hsp/src/main/page/Test&1.0.0";
1280 exceptBaseFileName = "/data/storage/el1/bundle/hsp/ets/modules.abc";
1281 CString res2 = ModulePathHelper::ParseNormalizedOhmUrl(thread, baseFileName, recordName, requestName);
1282 EXPECT_EQ(res2, expectRes);
1283 EXPECT_EQ(baseFileName, exceptBaseFileName);
1284
1285 baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1286 requestName = "@normalized:N&hsp&com.example.application&hsp/src/main/page/Test&1.0.0";
1287 exceptBaseFileName = "/data/storage/el1/bundle/com.example.application/hsp/hsp/ets/modules.abc";
1288 expectRes = "com.example.application&hsp/src/main/page/Test&1.0.0";
1289 CString res3 = ModulePathHelper::ParseNormalizedOhmUrl(thread, baseFileName, recordName, requestName);
1290 EXPECT_EQ(res3, expectRes);
1291 EXPECT_EQ(baseFileName, exceptBaseFileName);
1292
1293 baseFileName = "";
1294 recordName = "&har/Index&1.0.0";
1295 requestName = "@normalized:N&&&har/src/main/page/Test&1.0.0";
1296 CString res4 = ModulePathHelper::ParseNormalizedOhmUrl(thread, baseFileName, recordName, requestName);
1297 EXPECT_EQ(baseFileName, "");
1298 }
1299
HWTEST_F_L0(EcmaModuleTest,GetModuleNameWithBaseFile)1300 HWTEST_F_L0(EcmaModuleTest, GetModuleNameWithBaseFile)
1301 {
1302 CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1303 CString expectRes = "entry";
1304 CString res = ModulePathHelper::GetModuleNameWithBaseFile(baseFileName);
1305 EXPECT_EQ(res, expectRes);
1306
1307 baseFileName = "/data/storage/el1/bundle/com.example.application/hsp/hsp/ets/modules.abc";
1308 expectRes = "hsp";
1309 res = ModulePathHelper::GetModuleNameWithBaseFile(baseFileName);
1310 EXPECT_EQ(res, expectRes);
1311 }
1312
HWTEST_F_L0(EcmaModuleTest,GetBundleNameWithRecordName)1313 HWTEST_F_L0(EcmaModuleTest, GetBundleNameWithRecordName)
1314 {
1315 CString recordName = "com.example.myapplication/library";
1316 CString expectRes = "com.example.myapplication";
1317 CString res = ModulePathHelper::GetBundleNameWithRecordName(instance, recordName);
1318 EXPECT_EQ(res, expectRes);
1319
1320 CMap<CString, CMap<CString, CVector<CString>>> list;
1321 CMap<CString, CVector<CString>> childList;
1322 list["hsp"] = childList;
1323 instance->SetpkgContextInfoList(list);
1324
1325 recordName = "&hsp&com.example.application&hsp/src/main/page/Test&1.0.0";
1326 expectRes = "com.example.application";
1327 res = ModulePathHelper::GetBundleNameWithRecordName(instance, recordName);
1328 EXPECT_EQ(res, expectRes);
1329
1330 instance->SetBundleName("com.example1.application");
1331 recordName = "&har/src/main/page/Test&1.0.0";
1332 expectRes = "com.example1.application";
1333 res = ModulePathHelper::GetBundleNameWithRecordName(instance, recordName);
1334 EXPECT_EQ(res, expectRes);
1335 }
1336
HWTEST_F_L0(EcmaModuleTest,TransformToNormalizedOhmUrl)1337 HWTEST_F_L0(EcmaModuleTest, TransformToNormalizedOhmUrl)
1338 {
1339 CMap<CString, CMap<CString, CVector<CString>>> pkgList;
1340 CMap<CString, CVector<CString>> entryList;
1341 entryList["entry"] = {
1342 "packageName", "entry",
1343 "bundleName", "",
1344 "moduleName", "",
1345 "version", "",
1346 "entryPath", "src/main/",
1347 "isSO", "false"
1348 };
1349 entryList["har"] = {
1350 "packageName", "har",
1351 "bundleName", "",
1352 "moduleName", "",
1353 "version", "1.2.0",
1354 "entryPath", "",
1355 "isSO", "false"
1356 };
1357 pkgList["entry"] = entryList;
1358 CMap<CString, CVector<CString>> ohosTestList;
1359 ohosTestList["ohosTest"] = {
1360 "packageName", "ohosTest",
1361 "bundleName", "",
1362 "moduleName", "",
1363 "version", "",
1364 "entryPath", "src/",
1365 "isSO", "false"
1366 };
1367 pkgList["ohosTest"] = ohosTestList;
1368 instance->SetpkgContextInfoList(pkgList);
1369
1370 CString inputFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1371 CString outBaseFileName = "";
1372 CString entryPoint = "ENTRY_MAIN_FUNCTION";
1373 CString res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1374 EXPECT_EQ(res, "ENTRY_MAIN_FUNCTION");
1375
1376 outBaseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1377 entryPoint = "com.example.myapplication/entry@har/ets/pages/Index";
1378 res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1379 EXPECT_EQ(res, "&har/src/main/ets/pages/Index&1.2.0");
1380
1381 outBaseFileName = "/data/storage/el1/bundle/ohosTest/ets/modules.abc";
1382 entryPoint = "com.example.myapplication/ohosTest/ets/pages/Index";
1383 res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1384 EXPECT_EQ(res, "&ohosTest/src/ets/pages/Index&");
1385
1386 outBaseFileName = "/data/storage/el1/bundle/entry/.test/ets/modules.abc";
1387 entryPoint = "com.example.myapplication/entry/.test/ets/pages/Index";
1388 res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1389 EXPECT_EQ(res, "&entry/.test/ets/pages/Index&");
1390 }
1391
HWTEST_F_L0(EcmaModuleTest,TranslateExpressionInputWithEts)1392 HWTEST_F_L0(EcmaModuleTest, TranslateExpressionInputWithEts)
1393 {
1394 instance->SetBundleName("com.example.myapplication");
1395 CString baseFilename = "merge.abc";
1396 const char *data = R"(
1397 .language ECMAScript
1398 .function any func_main_0(any a0, any a1, any a2) {
1399 ldai 1
1400 return
1401 }
1402 )";
1403 JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
1404 Parser parser;
1405 auto res = parser.Parse(data);
1406 std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
1407 std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
1408
1409 CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1410 CString requestName = "ets/Test";
1411 CString recordName = "com.example.myapplication/entry/ets/pages/Index";
1412 CString expectRes = "com.example.myapplication/entry/ets/Test";
1413 CString result = ModulePathHelper::TranslateExpressionInputWithEts(thread, pf.get(), baseFileName, requestName);
1414 EXPECT_EQ(result, "");
1415
1416 pf->InsertJSRecordInfo(expectRes);
1417 result = ModulePathHelper::TranslateExpressionInputWithEts(thread, pf.get(), baseFileName, requestName);
1418 EXPECT_EQ(result, expectRes);
1419 }
1420
HWTEST_F_L0(EcmaModuleTest,ReviseLoadedModuleCount1)1421 HWTEST_F_L0(EcmaModuleTest, ReviseLoadedModuleCount1) {
1422 CString moduleName = "testModule";
1423 ModuleDeregister::ReviseLoadedModuleCount(thread, moduleName);
1424 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1425 bool res = moduleManager->IsLocalModuleLoaded(moduleName);
1426 EXPECT_EQ(res, false);
1427 }
1428
HWTEST_F_L0(EcmaModuleTest,IncreaseRegisterCounts)1429 HWTEST_F_L0(EcmaModuleTest, IncreaseRegisterCounts)
1430 {
1431 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1432 JSNApi::EnableUserUncaughtErrorHandler(instance);
1433 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1434 EXPECT_TRUE(result);
1435 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1436 JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
1437 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1438 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1439 std::set<CString> increaseModule;
1440
1441 ModuleDeregister::IncreaseRegisterCounts(thread, module, increaseModule);
1442 module->SetRegisterCounts(INT8_MAX);
1443 ModuleDeregister::IncreaseRegisterCounts(thread, module, increaseModule);
1444 module2->SetRegisterCounts(INT8_MAX);
1445 ModuleDeregister::IncreaseRegisterCounts(thread, module2, increaseModule);
1446 module2->SetLoadingTypes(LoadingTypes::STABLE_MODULE);
1447 ModuleDeregister::IncreaseRegisterCounts(thread, module2, increaseModule);
1448 }
1449
HWTEST_F_L0(EcmaModuleTest,DecreaseRegisterCounts)1450 HWTEST_F_L0(EcmaModuleTest, DecreaseRegisterCounts)
1451 {
1452 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1453 JSNApi::EnableUserUncaughtErrorHandler(instance);
1454 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1455 EXPECT_TRUE(result);
1456 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1457 JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
1458 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1459 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1460 std::set<CString> decreaseModule;
1461
1462 ModuleDeregister::DecreaseRegisterCounts(thread, module, decreaseModule);
1463 module->SetRegisterCounts(INT8_MAX);
1464 ModuleDeregister::DecreaseRegisterCounts(thread, module, decreaseModule);
1465 module2->SetLoadingTypes(LoadingTypes::DYNAMITC_MODULE);
1466 ModuleDeregister::DecreaseRegisterCounts(thread, module2, decreaseModule);
1467 }
1468
HWTEST_F_L0(EcmaModuleTest,GetSendableModuleValueImpl)1469 HWTEST_F_L0(EcmaModuleTest, GetSendableModuleValueImpl) {
1470 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1471 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1472 SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1473 int32_t index = 2;
1474 JSTaggedValue currentModule1 = module1.GetTaggedValue();
1475 manager1->GetSendableModuleValueImpl(thread, index, currentModule1);
1476
1477 SharedModuleManager* manager2 = SharedModuleManager::GetInstance();
1478 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1479 JSNApi::EnableUserUncaughtErrorHandler(instance);
1480 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1481 EXPECT_TRUE(result);
1482 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1483 JSHandle<SourceTextModule> module2 = moduleManager->HostGetImportedModule("module_test_module_test_C");
1484 JSTaggedValue currentModule2 = module2.GetTaggedValue();
1485 manager2->GetSendableModuleValueImpl(thread, index, currentModule2);
1486 }
1487
HWTEST_F_L0(EcmaModuleTest,GetLazySendableModuleValueImpl)1488 HWTEST_F_L0(EcmaModuleTest, GetLazySendableModuleValueImpl) {
1489 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1490 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1491 SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1492 int32_t index = 2;
1493 JSTaggedValue currentModule1 = module1.GetTaggedValue();
1494 manager1->GetLazySendableModuleValueImpl(thread, index, currentModule1);
1495 }
1496
HWTEST_F_L0(EcmaModuleTest,ResolveImportedModuleWithMerge)1497 HWTEST_F_L0(EcmaModuleTest, ResolveImportedModuleWithMerge) {
1498 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1499 JSNApi::EnableUserUncaughtErrorHandler(instance);
1500 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1501 EXPECT_TRUE(result);
1502 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1503 JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
1504 module->SetSharedType(SharedTypes::SHARED_MODULE);
1505
1506 CString recordName2 = "testModule";
1507 SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1508 bool executeFromJob = false;
1509 manager1->ResolveImportedModuleWithMerge(thread, baseFileName.c_str(), recordName2, executeFromJob);
1510 }
1511
HWTEST_F_L0(EcmaModuleTest,ResolveImportedModuleWithMerge2)1512 HWTEST_F_L0(EcmaModuleTest, ResolveImportedModuleWithMerge2) {
1513 CString moduleName1;
1514 CString recordName1;
1515
1516 SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1517 bool executeFromJob = false;
1518 manager1->ResolveImportedModuleWithMerge(thread, moduleName1, recordName1, executeFromJob);
1519 }
1520
HWTEST_F_L0(EcmaModuleTest,IsInstaniatedSModule)1521 HWTEST_F_L0(EcmaModuleTest, IsInstaniatedSModule) {
1522 SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1523 std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1524 JSNApi::EnableUserUncaughtErrorHandler(instance);
1525 bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1526 EXPECT_TRUE(result);
1527 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1528 JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
1529 bool res = manager1->IsInstaniatedSModule(thread, module);
1530 EXPECT_EQ(res, true);
1531 }
1532
HWTEST_F_L0(EcmaModuleTest,ProcessModuleLoadInfoForESM)1533 HWTEST_F_L0(EcmaModuleTest, ProcessModuleLoadInfoForESM)
1534 {
1535 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1536 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1537 CString baseFileName = "modules.abc";
1538 module1->SetEcmaModuleFilenameString(baseFileName);
1539 CString recordName1 = "a";
1540 module1->SetEcmaModuleRecordNameString(recordName1);
1541 JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
1542 JSHandle<ImportEntry> importEntry =
1543 objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
1544 SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
1545
1546 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1547 module2->SetEcmaModuleFilenameString(baseFileName);
1548 CString recordName2 = "b";
1549 module2->SetEcmaModuleRecordNameString(recordName2);
1550 JSHandle<LocalExportEntry> localExportEntry =
1551 objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
1552 JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
1553 localExportEntries->Set(thread, 0, localExportEntry);
1554 module2->SetLocalExportEntries(thread, localExportEntries);
1555 module2->StoreModuleValue(thread, 0, val);
1556 module2->SetStatus(ModuleStatus::EVALUATED);
1557 ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
1558 thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
1559 // test ResolvedIndexBinding
1560 JSHandle<ResolvedIndexBinding> indexBinding =
1561 objectFactory->NewResolvedIndexBindingRecord(module2, 0);
1562 JSTaggedValue res1 = ModuleTools::ProcessModuleLoadInfo(thread, module1, indexBinding.GetTaggedValue(), 0);
1563 EXPECT_EQ(res1, val.GetTaggedValue());
1564
1565 JSTaggedValue res2 = ModuleTools::ProcessModuleNameSpaceLoadInfo(thread, module1, module2);
1566 EXPECT_NE(res2, JSTaggedValue::Exception());
1567 thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
1568 delete moduleLogger;
1569 }
1570
HWTEST_F_L0(EcmaModuleTest,ProcessModuleLoadInfoForCJS)1571 HWTEST_F_L0(EcmaModuleTest, ProcessModuleLoadInfoForCJS)
1572 {
1573 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1574 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1575 CString baseFileName = "modules.abc";
1576 module1->SetEcmaModuleFilenameString(baseFileName);
1577 CString recordName1 = "a";
1578 module1->SetEcmaModuleRecordNameString(recordName1);
1579 JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
1580 JSHandle<ImportEntry> importEntry =
1581 objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
1582 SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
1583
1584 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1585 module2->SetEcmaModuleFilenameString(baseFileName);
1586 CString recordName2 = "cjs";
1587 module2->SetEcmaModuleRecordNameString(recordName2);
1588 JSHandle<LocalExportEntry> localExportEntry =
1589 objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
1590 JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
1591 localExportEntries->Set(thread, 0, localExportEntry);
1592 module2->SetLocalExportEntries(thread, localExportEntries);
1593 module2->StoreModuleValue(thread, 0, val);
1594 module2->SetTypes(ModuleTypes::CJS_MODULE);
1595 module2->SetStatus(ModuleStatus::EVALUATED);
1596 JSHandle<CjsModule> moduleCjs = objectFactory->NewCjsModule();
1597 JSHandle<JSTaggedValue> recordName2Hdl =
1598 JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(recordName2.c_str()));
1599 JSHandle<JSTaggedValue> baseFileNameHdl =
1600 JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(baseFileName.c_str()));
1601 CjsModule::InitializeModule(thread, moduleCjs, recordName2Hdl, baseFileNameHdl);
1602 CjsModule::PutIntoCache(thread, moduleCjs, recordName2Hdl);
1603
1604 JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
1605 JSHandle<JSTaggedValue> resolution =
1606 JSHandle<JSTaggedValue>::Cast(objectFactory->NewResolvedBindingRecord(module2, val));
1607 envRec->Set(thread, 0, resolution);
1608 module1->SetEnvironment(thread, envRec);
1609
1610 ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
1611 thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
1612
1613 // test ResolvedBinding
1614 JSTaggedValue res1 = ModuleTools::ProcessModuleNameSpaceLoadInfo(thread, module1, module2);
1615 EXPECT_NE(res1, JSTaggedValue::Exception());
1616
1617 JSTaggedValue res2 = ModuleTools::ProcessModuleLoadInfo(thread, module1, resolution.GetTaggedValue(), 0);
1618 EXPECT_EQ(res2, JSTaggedValue::Exception());
1619 thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
1620 delete moduleLogger;
1621 }
1622
HWTEST_F_L0(EcmaModuleTest,ProcessModuleLoadInfoForNativeModule)1623 HWTEST_F_L0(EcmaModuleTest, ProcessModuleLoadInfoForNativeModule)
1624 {
1625 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1626 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1627 CString baseFileName = "modules.abc";
1628 module1->SetEcmaModuleFilenameString(baseFileName);
1629 CString recordName1 = "a";
1630 module1->SetEcmaModuleRecordNameString(recordName1);
1631 JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
1632 JSHandle<ImportEntry> importEntry =
1633 objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
1634 SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
1635
1636 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1637 module2->SetEcmaModuleFilenameString(baseFileName);
1638 CString recordName2 = "nativeModule";
1639 module2->SetEcmaModuleRecordNameString(recordName2);
1640 JSHandle<LocalExportEntry> localExportEntry =
1641 objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
1642 JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
1643 localExportEntries->Set(thread, 0, localExportEntry);
1644 module2->SetLocalExportEntries(thread, localExportEntries);
1645 module2->StoreModuleValue(thread, 0, val);
1646 module2->SetTypes(ModuleTypes::NATIVE_MODULE);
1647 module2->SetStatus(ModuleStatus::EVALUATED);
1648
1649 JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
1650 JSHandle<JSTaggedValue> resolution = JSHandle<JSTaggedValue>::Cast(
1651 objectFactory->NewResolvedBindingRecord(module2, val));
1652 envRec->Set(thread, 0, resolution);
1653 module1->SetEnvironment(thread, envRec);
1654
1655 ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
1656 thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
1657
1658 JSTaggedValue res1 = ModuleTools::ProcessModuleLoadInfo(thread, module1, resolution.GetTaggedValue(), 0);
1659 EXPECT_EQ(res1, JSTaggedValue::Exception());
1660
1661 JSTaggedValue res2 = ModuleTools::ProcessModuleNameSpaceLoadInfo(thread, module1, module2);
1662 EXPECT_NE(res2, JSTaggedValue::Exception());
1663 thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
1664 delete moduleLogger;
1665 }
1666
HWTEST_F_L0(EcmaModuleTest,ResolvedBindingForLog)1667 HWTEST_F_L0(EcmaModuleTest, ResolvedBindingForLog)
1668 {
1669 ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1670 JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1671 CString baseFileName = "modules.abc";
1672 module1->SetEcmaModuleFilenameString(baseFileName);
1673 CString recordName1 = "a";
1674 module1->SetEcmaModuleRecordNameString(recordName1);
1675 JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
1676 JSHandle<ImportEntry> importEntry =
1677 objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
1678 SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
1679
1680 JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1681 module2->SetEcmaModuleFilenameString(baseFileName);
1682 CString recordName2 = "b";
1683 module2->SetEcmaModuleRecordNameString(recordName2);
1684 JSHandle<LocalExportEntry> localExportEntry =
1685 objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
1686 JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
1687 localExportEntries->Set(thread, 0, localExportEntry);
1688 module2->SetLocalExportEntries(thread, localExportEntries);
1689 module2->StoreModuleValue(thread, 0, val);
1690 module2->SetStatus(ModuleStatus::EVALUATED);
1691 ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1692 moduleManager->AddResolveImportedModule(recordName2, module2.GetTaggedValue());
1693
1694 ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
1695 thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
1696 // test ResolvedRecordIndexBinding
1697 JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName2);
1698 JSHandle<EcmaString> baseFileNameHdl = objectFactory->NewFromUtf8(baseFileName);
1699 JSHandle<ResolvedRecordIndexBinding> recordIndexBinding =
1700 objectFactory->NewSResolvedRecordIndexBindingRecord(recordNameHdl, baseFileNameHdl, 0);
1701 JSTaggedValue res1 = ModuleTools::ProcessModuleLoadInfo(thread, module1, recordIndexBinding.GetTaggedValue(), 0);
1702 EXPECT_EQ(res1, val.GetTaggedValue());
1703
1704 // test ResolvedRecordBinding
1705 JSHandle<ResolvedRecordBinding> nameBinding =
1706 objectFactory->NewSResolvedRecordBindingRecord(recordNameHdl, val);
1707 JSTaggedValue res2 = ModuleTools::ProcessModuleLoadInfo(thread, module1, nameBinding.GetTaggedValue(), 0);
1708 EXPECT_EQ(res2, JSTaggedValue::Exception());
1709 thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
1710 delete moduleLogger;
1711 }
1712
HWTEST_F_L0(EcmaModuleTest,ToStringWithPrecision)1713 HWTEST_F_L0(EcmaModuleTest, ToStringWithPrecision)
1714 {
1715 std::string res = ModuleLogger::ToStringWithPrecision(4.550, 3);
1716 EXPECT_EQ(res, "4.55");
1717 }
1718 } // namespace panda::test
1719