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/accessor/module_data_accessor.h"
24#include "ecmascript/jspandafile/js_pandafile_manager.h"
25#include "ecmascript/jspandafile/program_object.h"
26#include "ecmascript/js_object-inl.h"
27#include "ecmascript/module/js_module_manager.h"
28#include "ecmascript/module/js_module_source_text.h"
29#include "ecmascript/module/module_data_extractor.h"
30#include "ecmascript/module/module_logger.h"
31#include "ecmascript/module/module_path_helper.h"
32#include "ecmascript/tests/test_helper.h"
33#include "ecmascript/linked_hash_table.h"
34#include "ecmascript/checkpoint/thread_state_transition.h"
35#include "ecmascript/module/js_module_deregister.h"
36#include "ecmascript/module/js_shared_module.h"
37#include "ecmascript/module/js_shared_module_manager.h"
38#include "ecmascript/module/module_tools.h"
39#include "ecmascript/require/js_cjs_module.h"
40#include "ecmascript/module/module_manager_helper.h"
41#include "ecmascript/ecma_vm.h"
42
43using namespace panda::ecmascript;
44using namespace panda::panda_file;
45using namespace panda::pandasm;
46
47namespace panda::test {
48using FunctionCallbackInfo = Local<JSValueRef>(*)(JsiRuntimeCallInfo *);
49class EcmaModuleTest : public testing::Test {
50public:
51    static void SetUpTestCase()
52    {
53        GTEST_LOG_(INFO) << "SetUpTestCase";
54    }
55
56    static void TearDownTestCase()
57    {
58        GTEST_LOG_(INFO) << "TearDownCase";
59    }
60
61    void SetUp() override
62    {
63        TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
64    }
65
66    void TearDown() override
67    {
68        TestHelper::DestroyEcmaVMWithScope(instance, scope);
69    }
70
71    static Local<JSValueRef> MockRequireNapiUndefined(JsiRuntimeCallInfo *runtimeCallInfo);
72    static Local<JSValueRef> MockRequireNapiFailure(JsiRuntimeCallInfo *runtimeCallInfo);
73    static Local<JSValueRef> MockRequireNapiValue(JsiRuntimeCallInfo *runtimeCallInfo);
74    static Local<JSValueRef> MockRequireNapiException(JsiRuntimeCallInfo *runtimeCallInfo);
75
76    EcmaVM *instance {nullptr};
77    ecmascript::EcmaHandleScope *scope {nullptr};
78    JSThread *thread {nullptr};
79};
80
81Local<JSValueRef> EcmaModuleTest::MockRequireNapiUndefined(JsiRuntimeCallInfo *runtimeCallInfo)
82{
83    EcmaVM *vm = runtimeCallInfo->GetVM();
84    return JSValueRef::Undefined(vm);
85}
86
87Local<JSValueRef> EcmaModuleTest::MockRequireNapiFailure(JsiRuntimeCallInfo *runtimeCallInfo)
88{
89    EcmaVM *vm = runtimeCallInfo->GetVM();
90    vm->SetErrorInfoEnhance(true);
91    Local<JSValueRef> exports = ObjectRef::CreateNativeModuleFailureInfo(vm, "NativeModuleFailureInfo");
92    return exports;
93}
94
95Local<JSValueRef> EcmaModuleTest::MockRequireNapiValue(JsiRuntimeCallInfo *runtimeCallInfo)
96{
97    EcmaVM *vm = runtimeCallInfo->GetVM();
98    Local<StringRef> localNameHandle = StringRef::NewFromUtf8(vm, "exportVal");
99    return localNameHandle;
100}
101
102Local<JSValueRef> EcmaModuleTest::MockRequireNapiException(JsiRuntimeCallInfo *runtimeCallInfo)
103{
104    EcmaVM *vm = runtimeCallInfo->GetVM();
105    Local<StringRef> message = StringRef::NewFromUtf8(vm, "load native module failed.");
106    Local<JSValueRef> error = Exception::ReferenceError(vm, message);
107    JSNApi::ThrowException(vm, error);
108    return message;
109}
110/*
111 * Feature: Module
112 * Function: AddImportEntry
113 * SubFunction: AddImportEntry
114 * FunctionPoints: Add import entry
115 * CaseDescription: Add two import item and check module import entries size
116 */
117HWTEST_F_L0(EcmaModuleTest, AddImportEntry)
118{
119    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
120    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
121    JSHandle<ImportEntry> importEntry1 = objectFactory->NewImportEntry();
122    SourceTextModule::AddImportEntry(thread, module, importEntry1, 0, 2);
123    JSHandle<ImportEntry> importEntry2 = objectFactory->NewImportEntry();
124    SourceTextModule::AddImportEntry(thread, module, importEntry2, 1, 2);
125    JSHandle<TaggedArray> importEntries(thread, module->GetImportEntries());
126    EXPECT_TRUE(importEntries->GetLength() == 2U);
127}
128
129/*
130 * Feature: Module
131 * Function: AddLocalExportEntry
132 * SubFunction: AddLocalExportEntry
133 * FunctionPoints: Add local export entry
134 * CaseDescription: Add two local export item and check module local export entries size
135 */
136HWTEST_F_L0(EcmaModuleTest, AddLocalExportEntry)
137{
138    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
139    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
140    JSHandle<LocalExportEntry> localExportEntry1 = objectFactory->NewLocalExportEntry();
141    SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry1, 0, 2);
142    JSHandle<LocalExportEntry> localExportEntry2 = objectFactory->NewLocalExportEntry();
143    SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry2, 1, 2);
144    JSHandle<TaggedArray> localExportEntries(thread, module->GetLocalExportEntries());
145    EXPECT_TRUE(localExportEntries->GetLength() == 2U);
146}
147
148/*
149 * Feature: Module
150 * Function: AddIndirectExportEntry
151 * SubFunction: AddIndirectExportEntry
152 * FunctionPoints: Add indirect export entry
153 * CaseDescription: Add two indirect export item and check module indirect export entries size
154 */
155HWTEST_F_L0(EcmaModuleTest, AddIndirectExportEntry)
156{
157    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
158    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
159    JSHandle<IndirectExportEntry> indirectExportEntry1 = objectFactory->NewIndirectExportEntry();
160    SourceTextModule::AddIndirectExportEntry(thread, module, indirectExportEntry1, 0, 2);
161    JSHandle<IndirectExportEntry> indirectExportEntry2 = objectFactory->NewIndirectExportEntry();
162    SourceTextModule::AddIndirectExportEntry(thread, module, indirectExportEntry2, 1, 2);
163    JSHandle<TaggedArray> indirectExportEntries(thread, module->GetIndirectExportEntries());
164    EXPECT_TRUE(indirectExportEntries->GetLength() == 2U);
165}
166
167/*
168 * Feature: Module
169 * Function: StarExportEntries
170 * SubFunction: StarExportEntries
171 * FunctionPoints: Add start export entry
172 * CaseDescription: Add two start export item and check module start export entries size
173 */
174HWTEST_F_L0(EcmaModuleTest, AddStarExportEntry)
175{
176    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
177    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
178    JSHandle<StarExportEntry> starExportEntry1 = objectFactory->NewStarExportEntry();
179    SourceTextModule::AddStarExportEntry(thread, module, starExportEntry1, 0, 2);
180    JSHandle<StarExportEntry> starExportEntry2 = objectFactory->NewStarExportEntry();
181    SourceTextModule::AddStarExportEntry(thread, module, starExportEntry2, 1, 2);
182    JSHandle<TaggedArray> startExportEntries(thread, module->GetStarExportEntries());
183    EXPECT_TRUE(startExportEntries->GetLength() == 2U);
184}
185
186/*
187 * Feature: Module
188 * Function: StoreModuleValue
189 * SubFunction: StoreModuleValue/GetModuleValue
190 * FunctionPoints: store a module export item in module
191 * CaseDescription: Simulated implementation of "export foo as bar", set foo as "hello world",
192 *                  use "import bar" in same js file
193 */
194HWTEST_F_L0(EcmaModuleTest, StoreModuleValue)
195{
196    ObjectFactory* objFactory = thread->GetEcmaVM()->GetFactory();
197    CString localName = "foo";
198    CString exportName = "bar";
199    CString value = "hello world";
200
201    JSHandle<JSTaggedValue> localNameHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
202    JSHandle<JSTaggedValue> exportNameHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName));
203    JSHandle<LocalExportEntry> localExportEntry =
204        objFactory->NewLocalExportEntry(exportNameHandle, localNameHandle, LocalExportEntry::LOCAL_DEFAULT_INDEX,
205                                        SharedTypes::UNSENDABLE_MODULE);
206    JSHandle<SourceTextModule> module = objFactory->NewSourceTextModule();
207    SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry, 0, 1);
208
209    JSHandle<JSTaggedValue> storeKey = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
210    JSHandle<JSTaggedValue> valueHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(value));
211    module->StoreModuleValue(thread, storeKey, valueHandle);
212
213    JSHandle<JSTaggedValue> loadKey = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
214    JSTaggedValue loadValue = module->GetModuleValue(thread, loadKey.GetTaggedValue(), false);
215    EXPECT_EQ(valueHandle.GetTaggedValue(), loadValue);
216}
217
218/*
219 * Feature: Module
220 * Function: GetModuleValue
221 * SubFunction: StoreModuleValue/GetModuleValue
222 * FunctionPoints: load module value from module
223 * CaseDescription: Simulated implementation of "export default let foo = 'hello world'",
224 *                  use "import C from 'xxx' to get default value"
225 */
226HWTEST_F_L0(EcmaModuleTest, GetModuleValue)
227{
228    ObjectFactory* objFactory = thread->GetEcmaVM()->GetFactory();
229    // export entry
230    CString exportLocalName = "*default*";
231    CString exportName = "default";
232    CString exportValue = "hello world";
233    JSHandle<JSTaggedValue> exportLocalNameHandle =
234        JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportLocalName));
235    JSHandle<JSTaggedValue> exportNameHandle =
236        JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName));
237    JSHandle<LocalExportEntry> localExportEntry = objFactory->NewLocalExportEntry(exportNameHandle,
238        exportLocalNameHandle, LocalExportEntry::LOCAL_DEFAULT_INDEX, SharedTypes::UNSENDABLE_MODULE);
239    JSHandle<SourceTextModule> moduleExport = objFactory->NewSourceTextModule();
240    SourceTextModule::AddLocalExportEntry(thread, moduleExport, localExportEntry, 0, 1);
241    // store module value
242    JSHandle<JSTaggedValue> exportValueHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportValue));
243    moduleExport->StoreModuleValue(thread, exportLocalNameHandle, exportValueHandle);
244
245    JSTaggedValue importDefaultValue =
246        moduleExport->GetModuleValue(thread, exportLocalNameHandle.GetTaggedValue(), false);
247    EXPECT_EQ(exportValueHandle.GetTaggedValue(), importDefaultValue);
248}
249
250HWTEST_F_L0(EcmaModuleTest, GetExportedNames)
251{
252    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
253    JSHandle<SourceTextModule> module = factory->NewSourceTextModule();
254    JSHandle<TaggedArray> exportStarSet = factory->NewTaggedArray(2);
255    exportStarSet->Set(thread, 0, module.GetTaggedValue());
256
257    CVector<std::string> exportedNames = SourceTextModule::GetExportedNames(thread, module, exportStarSet);
258    EXPECT_EQ(exportedNames.size(), 0);
259}
260
261HWTEST_F_L0(EcmaModuleTest, FindByExport)
262{
263    CString localName1 = "foo";
264    CString localName2 = "foo2";
265    CString localName3 = "foo3";
266    CString exportName1 = "bar";
267    CString exportName2 = "bar2";
268    CString value = "hello world";
269    CString value2 = "hello world2";
270
271    ObjectFactory* objFactory = thread->GetEcmaVM()->GetFactory();
272    JSHandle<SourceTextModule> module = objFactory->NewSourceTextModule();
273    JSHandle<JSTaggedValue> localNameHandle1 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName1));
274    JSHandle<JSTaggedValue> localNameHandle2 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName2));
275    JSHandle<JSTaggedValue> exportNameHandle1 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName1));
276    JSHandle<JSTaggedValue> exportNameHandle2 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName2));
277    JSHandle<LocalExportEntry> localExportEntry1 =
278        objFactory->NewLocalExportEntry(exportNameHandle1, localNameHandle1, LocalExportEntry::LOCAL_DEFAULT_INDEX,
279                                        SharedTypes::UNSENDABLE_MODULE);
280    SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry1, 0, 2);
281
282    JSHandle<LocalExportEntry> localExportEntry2 =
283        objFactory->NewLocalExportEntry(exportNameHandle2, localNameHandle2, LocalExportEntry::LOCAL_DEFAULT_INDEX,
284                                        SharedTypes::UNSENDABLE_MODULE);
285    SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry2, 1, 2);
286
287    JSHandle<JSTaggedValue> storeKey = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName1));
288    JSHandle<JSTaggedValue> valueHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(value));
289    module->StoreModuleValue(thread, storeKey, valueHandle);
290
291    JSHandle<JSTaggedValue> storeKey2 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName2));
292    JSHandle<JSTaggedValue> valueHandle2 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(value2));
293    module->StoreModuleValue(thread, storeKey2, valueHandle2);
294
295    // FindByExport cannot find key from exportEntries, returns Hole()
296    JSHandle<JSTaggedValue> loadKey1 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName3));
297    JSTaggedValue loadValue1 = module->GetModuleValue(thread, loadKey1.GetTaggedValue(), false);
298    EXPECT_EQ(JSTaggedValue::Hole(), loadValue1);
299
300    // FindByExport retrieves the key from exportEntries and returns the value corresponding to the key
301    JSHandle<JSTaggedValue> loadKey2 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName1));
302    JSTaggedValue loadValue2 = module->GetModuleValue(thread, loadKey2.GetTaggedValue(), false);
303    EXPECT_EQ(valueHandle.GetTaggedValue(), loadValue2);
304}
305
306HWTEST_F_L0(EcmaModuleTest, ReformatPath)
307{
308    // start with pkg_modules
309    CString requestPath = "pkg_modules@entry.@hw-agconnect.hmcore";
310    CString entryPoint = ModulePathHelper::ReformatPath(requestPath);
311    EXPECT_EQ("@entry.@hw-agconnect.hmcore", entryPoint);
312
313    // start with @package:
314    requestPath = "@package:pkg_modules@entry.@hw-agconnect.hmcore";
315    entryPoint = ModulePathHelper::ReformatPath(requestPath);
316    EXPECT_EQ("@entry.@hw-agconnect.hmcore", entryPoint);
317
318    // start with @app:
319    requestPath = "@app:bundleName/moduleName/lib*.so";
320    entryPoint = ModulePathHelper::ReformatPath(requestPath);
321    EXPECT_EQ("lib*.so", entryPoint);
322
323    // no special prefix
324    requestPath = "bundleName/moduleName/lib*.so";
325    entryPoint = ModulePathHelper::ReformatPath(requestPath);
326    EXPECT_EQ("bundleName/moduleName/lib*.so", entryPoint);
327}
328
329HWTEST_F_L0(EcmaModuleTest, ParseUrl)
330{
331    CString recordName = "com.bundleName.test";
332    CString res = ModulePathHelper::ParseUrl(instance, recordName);
333    EXPECT_EQ(res, CString());
334}
335
336HWTEST_F_L0(EcmaModuleTest, MakeNewRecord)
337{
338    CString baseFilename = "merge.abc";
339    const char *data = R"(
340        .language ECMAScript
341        .function any func_main_0(any a0, any a1, any a2) {
342            ldai 1
343            return
344        }
345    )";
346    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
347    Parser parser;
348    auto res = parser.Parse(data);
349    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
350    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
351
352    // is not start with BUNDLE_INSTALL_PATH
353    CString moduleRecordName = "moduleTest1";
354    CString moduleRequestName = "@bundle:com.bundleName.test/moduleName/requestModuleName1";
355    CString result = "requestModuleName1";
356    CString entryPoint = ModulePathHelper::MakeNewRecord(thread, pf.get(), baseFilename, moduleRecordName,
357                                                             moduleRequestName);
358    EXPECT_EQ(result, entryPoint);
359
360    // start with BUNDLE_INSTALL_PATH, is bundle pack
361    baseFilename = "/data/storage/el1/bundle/";
362    moduleRecordName = "moduleTest1";
363    moduleRequestName = "@bundle:com.bundleName.test/moduleName/requestModuleName1";
364    result = "requestModuleName1";
365    entryPoint = ModulePathHelper::MakeNewRecord(thread, pf.get(), baseFilename, moduleRecordName,
366                                                             moduleRequestName);
367    EXPECT_EQ(result, entryPoint);
368}
369
370HWTEST_F_L0(EcmaModuleTest, FindPackageInTopLevelWithNamespace)
371{
372    CString baseFilename = "merge.abc";
373    const char *data = R"(
374        .language ECMAScript
375        .function any func_main_0(any a0, any a1, any a2) {
376            ldai 1
377            return
378        }
379    )";
380    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
381    Parser parser;
382    auto res = parser.Parse(data);
383    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
384    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
385
386    // start with pkg_modules, pos equal CString::npos
387    CString moduleRecordName = "pkg_modules@entry.@hw-agconnect.hmcore";
388    CString moduleRequestName = "@bundle:com.bundleName.test/moduleName/requestModuleName1";
389    CString entryPoint = ModulePathHelper::FindPackageInTopLevelWithNamespace(
390        pf.get(), moduleRequestName, moduleRecordName);
391    EXPECT_EQ(CString(), entryPoint);
392
393    // start with pkg_modules, pos not equal CString::npos
394    moduleRecordName = "pkg_modules@entry.@hw-agconnect.hmcore/test";
395    moduleRequestName = "@bundle:com.bundleName.test/moduleName/requestModuleName1";
396    entryPoint = ModulePathHelper::FindPackageInTopLevelWithNamespace(pf.get(), moduleRequestName, moduleRecordName);
397    EXPECT_EQ(CString(), entryPoint);
398
399    // moduleName has @
400    moduleRecordName = "@bundle:com.bundleName.test/@test";
401    moduleRequestName = "@bundle:com.bundleName.test/moduleName/requestModuleName1";
402    entryPoint = ModulePathHelper::FindPackageInTopLevelWithNamespace(pf.get(), moduleRequestName, moduleRecordName);
403    EXPECT_EQ(CString(), entryPoint);
404}
405
406HWTEST_F_L0(EcmaModuleTest, ParseOhpmPackage)
407{
408    CString baseFilename = "merge.abc";
409    const char *data = R"(
410        .language ECMAScript
411        .function any func_main_0(any a0, any a1, any a2) {
412            ldai 1
413            return
414        }
415    )";
416    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
417    Parser parser;
418    auto res = parser.Parse(data);
419    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
420    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
421
422    // start with pkg_modules
423    CString moduleRecordName = "pkg_modules@entry.@hw-agconnect.hmcore1";
424    CString moduleRequestName = "@bundle:com.bundleName.test/moduleName/requestModuleName1";
425    pf->InsertJSRecordInfo(moduleRecordName);
426    CString entryPoint = ModulePathHelper::ParseOhpmPackage(pf.get(), moduleRecordName, moduleRequestName);
427    EXPECT_EQ(CString(), entryPoint);
428
429    // start with pkg_modules, packageName has pkg_modules
430    moduleRecordName = "pkg_modules@entry.@hw-agconnect.hmcore2";
431    moduleRequestName = "@bundle:com.bundleName.test/moduleName/requestModuleName1";
432    CUnorderedMap<CString, JSPandaFile::JSRecordInfo*> &recordInfo =
433        const_cast<CUnorderedMap<CString, JSPandaFile::JSRecordInfo*>&>(pf->GetJSRecordInfo());
434    JSPandaFile::JSRecordInfo *info = new JSPandaFile::JSRecordInfo();
435    info->npmPackageName = moduleRecordName;
436    recordInfo.insert({moduleRecordName, info});
437    entryPoint = ModulePathHelper::ParseOhpmPackage(pf.get(), moduleRecordName, moduleRequestName);
438    EXPECT_EQ(CString(), entryPoint);
439
440    // delete info
441    delete info;
442    recordInfo.erase(moduleRecordName);
443}
444
445HWTEST_F_L0(EcmaModuleTest, FindPackageInTopLevel)
446{
447    CString baseFilename = "merge.abc";
448    const char *data = R"(
449        .language ECMAScript
450        .function any func_main_0(any a0, any a1, any a2) {
451            ldai 1
452            return
453        }
454    )";
455    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
456    Parser parser;
457    auto res = parser.Parse(data);
458    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
459    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
460
461    // start with packagePath
462    CString moduleRequestName = "@bundle:com.bundleName.test/moduleName/requestModuleName";
463    CString packagePath = "pkg_modules";
464    CString result = "pkg_modules/0/@bundle:com.bundleName.test/moduleName/requestModuleName";
465    pf->InsertJSRecordInfo(result);
466    CString entryPoint = ModulePathHelper::FindPackageInTopLevel(pf.get(), moduleRequestName, packagePath);
467    EXPECT_EQ(result, entryPoint);
468}
469
470HWTEST_F_L0(EcmaModuleTest, NeedTranstale)
471{
472    // start with @bundle
473    CString requestName = "@bundle:com.bundleName.test/moduleName/requestModuleName";
474    bool res = ModulePathHelper::NeedTranstale(requestName);
475    EXPECT_EQ(res, false);
476
477    // start with @package:
478    requestName = "@package:test";
479    res = ModulePathHelper::NeedTranstale(requestName);
480    EXPECT_EQ(res, false);
481
482    // start with .
483    requestName = "./test";
484    res = ModulePathHelper::NeedTranstale(requestName);
485    EXPECT_EQ(res, false);
486
487    // start with @, has :
488    requestName = "@test:";
489    res = ModulePathHelper::NeedTranstale(requestName);
490    EXPECT_EQ(res, false);
491
492    // start with @, don't has :
493    requestName = "@test";
494    res = ModulePathHelper::NeedTranstale(requestName);
495    EXPECT_EQ(res, true);
496
497    // other branches
498    requestName = "test";
499    res = ModulePathHelper::NeedTranstale(requestName);
500    EXPECT_EQ(res, true);
501}
502
503HWTEST_F_L0(EcmaModuleTest, TranstaleExpressionInput)
504{
505    CString baseFilename = "merge.abc";
506    const char *data = R"(
507        .language ECMAScript
508        .function any func_main_0(any a0, any a1, any a2) {
509            ldai 1
510            return
511        }
512    )";
513    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
514    Parser parser;
515    auto res = parser.Parse(data);
516    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
517    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
518
519    // start with @arkui-x.
520    CString requestPath = "@arkui-x.test/moduleName/requestModuleName";
521    ModulePathHelper::TranstaleExpressionInput(pf.get(), requestPath);
522    EXPECT_EQ(requestPath, "@ohos:test/moduleName/requestModuleName");
523}
524
525HWTEST_F_L0(EcmaModuleTest, ParseFileNameToVMAName2)
526{
527    // has .js
528    CString filename = "test.js";
529    CString res = ModulePathHelper::ParseFileNameToVMAName(filename);
530    EXPECT_EQ(res, "ArkTS Code");
531
532    // other branches
533    filename = "test.ts";
534    res = ModulePathHelper::ParseFileNameToVMAName(filename);
535    EXPECT_EQ(res, "ArkTS Code");
536}
537
538HWTEST_F_L0(EcmaModuleTest, GetRecordName1)
539{
540    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_module_base.abc";
541
542    JSNApi::EnableUserUncaughtErrorHandler(instance);
543
544    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_module_base");
545    EXPECT_TRUE(result);
546}
547
548HWTEST_F_L0(EcmaModuleTest, GetRecordName2)
549{
550    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_A.abc";
551
552    JSNApi::EnableUserUncaughtErrorHandler(instance);
553
554    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_A");
555    EXPECT_TRUE(result);
556}
557
558HWTEST_F_L0(EcmaModuleTest, GetExportObjectIndex)
559{
560    ThreadNativeScope nativeScope(thread);
561    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
562
563    JSNApi::EnableUserUncaughtErrorHandler(instance);
564
565    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
566    JSNApi::GetExportObject(instance, "module_test_module_test_B", "a");
567    EXPECT_TRUE(result);
568}
569
570HWTEST_F_L0(EcmaModuleTest, HostResolveImportedModule)
571{
572    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
573
574    JSNApi::EnableUserUncaughtErrorHandler(instance);
575
576    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
577    ObjectFactory *factory = instance->GetFactory();
578    JSHandle<SourceTextModule> module = factory->NewSourceTextModule();
579    JSHandle<JSTaggedValue> moduleRecord(thread, module.GetTaggedValue());
580    moduleManager->AddResolveImportedModule(baseFileName.c_str(), moduleRecord.GetTaggedValue());
581    JSHandle<JSTaggedValue> res = moduleManager->HostResolveImportedModule(baseFileName.c_str());
582
583    EXPECT_EQ(moduleRecord->GetRawData(), res.GetTaggedValue().GetRawData());
584}
585
586HWTEST_F_L0(EcmaModuleTest, HostResolveImportedModule2)
587{
588    CString recordName = "module_test_module_test_A";
589    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
590
591    CString baseFileName = MODULE_ABC_PATH "module_test_module_test_A.abc";
592    std::shared_ptr<JSPandaFile> jsPandaFile =
593        JSPandaFileManager::GetInstance()->LoadJSPandaFile(thread, baseFileName, JSPandaFile::ENTRY_MAIN_FUNCTION);
594    EXPECT_NE(jsPandaFile, nullptr);
595    JSHandle<JSTaggedValue> res1 = moduleManager->HostResolveImportedModule(jsPandaFile.get(), baseFileName);
596    EXPECT_NE(res1.GetTaggedValue(), JSTaggedValue::Undefined());
597    JSHandle<JSTaggedValue> res2 = moduleManager->HostResolveImportedModule(jsPandaFile.get(), baseFileName);
598    EXPECT_NE(res2.GetTaggedValue(), JSTaggedValue::Undefined());
599}
600
601HWTEST_F_L0(EcmaModuleTest, IsSharedModuleLoaded)
602{
603    CString recordName = "module_test_module_test_A";
604    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
605    bool res = moduleManager->IsSharedModuleLoaded(recordName);
606    EXPECT_EQ(res, false);
607}
608
609HWTEST_F_L0(EcmaModuleTest, GetModuleValueInner)
610{
611    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
612    JSNApi::EnableUserUncaughtErrorHandler(instance);
613    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
614    EXPECT_TRUE(result);
615    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
616    JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
617    JSHandle<JSTaggedValue> moduleRecord = JSHandle<JSTaggedValue>::Cast(module);
618
619    JSTaggedValue res1 = moduleManager->GetModuleValueInner(0, moduleRecord);
620    EXPECT_EQ(res1, JSTaggedValue::Hole());
621
622    JSTaggedValue res2 = moduleManager->GetModuleValueOutter(0, moduleRecord);
623    EXPECT_TRUE(res2.IsInt());
624}
625
626HWTEST_F_L0(EcmaModuleTest, GetModuleValueOutterInternal)
627{
628    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
629    JSNApi::EnableUserUncaughtErrorHandler(instance);
630    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
631    EXPECT_TRUE(result);
632    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
633    JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_B");
634    JSHandle<JSTaggedValue> moduleRecord = JSHandle<JSTaggedValue>::Cast(module);
635
636    // moduleEnvironment IsUndefined
637    JSTaggedValue res = moduleManager->GetModuleValueOutter(0, moduleRecord);
638    EXPECT_TRUE(res.IsSpecial());
639}
640
641HWTEST_F_L0(EcmaModuleTest, GetModuleNamespaceInternal)
642{
643    CString localName = "foo";
644
645    ObjectFactory* objFactory = thread->GetEcmaVM()->GetFactory();
646    JSHandle<JSTaggedValue> localNameHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
647    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
648
649    // moduleEnvironment IsUndefined
650    JSHandle<SourceTextModule> module = objFactory->NewSourceTextModule();
651    JSTaggedValue res1 = moduleManager->GetModuleNamespaceInternal(localNameHandle.GetTaggedValue(),
652        module.GetTaggedValue());
653    EXPECT_EQ(res1, thread->GlobalConstants()->GetUndefined());
654
655    // FindEntry fail
656    JSHandle<NameDictionary> map(NameDictionary::Create(thread, NameDictionary::ComputeHashTableSize(1)));
657    module->SetEnvironment(thread, map);
658    JSTaggedValue res2 = moduleManager->GetModuleNamespaceInternal(localNameHandle.GetTaggedValue(),
659        module.GetTaggedValue());
660    EXPECT_EQ(res2, thread->GlobalConstants()->GetUndefined());
661}
662
663HWTEST_F_L0(EcmaModuleTest, GetExportObjectIndex2)
664{
665    CString key = "module_test_module_test_A";
666    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
667    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
668    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
669
670    // EcmaModuleRecordNameString is empty
671    int res1 = moduleManager->GetExportObjectIndex(thread->GetEcmaVM(), module, key);
672    EXPECT_EQ(res1, 0);
673
674    // EcmaModuleRecordNameString is not empty
675    module->SetEcmaModuleRecordNameString("test");
676    int res2 = moduleManager->GetExportObjectIndex(thread->GetEcmaVM(), module, key);
677    EXPECT_EQ(res2, 0);
678}
679
680HWTEST_F_L0(EcmaModuleTest, GetModuleNameSpaceFromFile)
681{
682    CString recordName1 = "a";
683    CString recordName2 = "module_test_module_test_B";
684    CString baseFileName = MODULE_ABC_PATH "module_test_module_test_B.abc";
685    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
686
687    // ExecuteFromAbcFile is success
688    JSHandle<JSTaggedValue> res2 = moduleManager->GetModuleNameSpaceFromFile(thread, recordName2, baseFileName);
689    EXPECT_NE(res2, thread->GlobalConstants()->GetHandledUndefinedString());
690
691    // ExecuteFromAbcFile is fail
692    JSHandle<JSTaggedValue> res1 = moduleManager->GetModuleNameSpaceFromFile(thread, recordName1, baseFileName);
693    EXPECT_EQ(res1, thread->GlobalConstants()->GetHandledUndefinedString());
694}
695
696HWTEST_F_L0(EcmaModuleTest, TryGetImportedModule)
697{
698    // TryGetImportedModule can not found Module
699    CString moduleName = "moduleName";
700    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
701    JSHandle<JSTaggedValue> res1 = moduleManager->TryGetImportedModule(moduleName);
702    EXPECT_EQ(res1, thread->GlobalConstants()->GetHandledUndefined());
703
704    // TryGetImportedModule can found Module
705    ObjectFactory *factory = instance->GetFactory();
706    JSHandle<SourceTextModule> module = factory->NewSourceTextModule();
707    JSHandle<JSTaggedValue> moduleRecord(thread, module.GetTaggedValue());
708    moduleManager->AddResolveImportedModule(moduleName, moduleRecord.GetTaggedValue());
709    JSHandle<JSTaggedValue> res2 = moduleManager->TryGetImportedModule(moduleName);
710    EXPECT_EQ(res2, moduleRecord);
711}
712
713HWTEST_F_L0(EcmaModuleTest, PreventExtensions_IsExtensible)
714{
715    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
716    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
717    JSHandle<LocalExportEntry> localExportEntry1 = objectFactory->NewLocalExportEntry();
718    SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry1, 0, 2);
719    JSHandle<LocalExportEntry> localExportEntry2 = objectFactory->NewLocalExportEntry();
720    SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry2, 1, 2);
721    JSHandle<TaggedArray> localExportEntries(thread, module->GetLocalExportEntries());
722    CString baseFileName = "a.abc";
723    module->SetEcmaModuleFilenameString(baseFileName);
724    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
725    JSHandle<JSTaggedValue> moduleRecord = JSHandle<JSTaggedValue>::Cast(module);
726    moduleManager->AddResolveImportedModule(baseFileName, moduleRecord.GetTaggedValue());
727    JSHandle<ModuleNamespace> np =
728    ModuleNamespace::ModuleNamespaceCreate(thread, moduleRecord, localExportEntries);
729    EXPECT_FALSE(np->IsExtensible());
730    EXPECT_TRUE(ModuleNamespace::PreventExtensions());
731}
732
733HWTEST_F_L0(EcmaModuleTest, ConcatFileNameWithMerge1)
734{
735    CString baseFilename = "merge.abc";
736    const char *data = R"(
737        .language ECMAScript
738        .function any func_main_0(any a0, any a1, any a2) {
739            ldai 1
740            return
741        }
742    )";
743    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
744    Parser parser;
745    auto res = parser.Parse(data);
746    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
747    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
748
749    // Test moduleRequestName start with "@bundle"
750    CString moduleRecordName = "moduleTest1";
751    CString moduleRequestName = "@bundle:com.bundleName.test/moduleName/requestModuleName1";
752    CString result = "com.bundleName.test/moduleName/requestModuleName1";
753    CString entryPoint = ModulePathHelper::ConcatFileNameWithMerge(thread, pf.get(), baseFilename, moduleRecordName,
754                                                             moduleRequestName);
755    EXPECT_EQ(result, entryPoint);
756
757    // Test cross application
758    moduleRecordName = "@bundle:com.bundleName1.test/moduleName/requestModuleName1";
759    CString newBaseFileName = "/data/storage/el1/bundle/com.bundleName.test/moduleName/moduleName/ets/modules.abc";
760    ModulePathHelper::ConcatFileNameWithMerge(thread, pf.get(), baseFilename, moduleRecordName, moduleRequestName);
761    EXPECT_EQ(baseFilename, newBaseFileName);
762}
763
764HWTEST_F_L0(EcmaModuleTest, ConcatFileNameWithMerge2)
765{
766    CString baseFilename = "merge.abc";
767    const char *data = R"(
768        .language ECMAScript
769        .function any func_main_0(any a0, any a1, any a2) {
770            ldai 1
771            return
772        }
773    )";
774    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
775    Parser parser;
776    auto res = parser.Parse(data);
777    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
778    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
779
780    // Test moduleRequestName start with "./"
781    CString moduleRecordName = "moduleTest2";
782    CString moduleRequestName = "./requestModule.js";
783    CString result = "requestModule";
784    pf->InsertJSRecordInfo(result);
785    CString entryPoint = ModulePathHelper::ConcatFileNameWithMerge(thread, pf.get(), baseFilename, moduleRecordName,
786                                                             moduleRequestName);
787    EXPECT_EQ(result, entryPoint);
788
789    // Test moduleRecordName with "/"
790    moduleRecordName = "moduleName/moduleTest2";
791    moduleRequestName = "./requestModule.js";
792    result = "moduleName/requestModule";
793    pf->InsertJSRecordInfo(result);
794    entryPoint = ModulePathHelper::ConcatFileNameWithMerge(
795        thread, pf.get(), baseFilename, moduleRecordName, moduleRequestName);
796    EXPECT_EQ(result, entryPoint);
797}
798
799HWTEST_F_L0(EcmaModuleTest, ConcatFileNameWithMerge3)
800{
801    CString baseFilename = "merge.abc";
802    const char *data = R"(
803        .language ECMAScript
804        .function any func_main_0(any a0, any a1, any a2) {
805            ldai 1
806            return
807        }
808    )";
809    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
810    Parser parser;
811    auto res = parser.Parse(data);
812    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
813    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
814
815    // Test RecordName is not in JSPandaFile
816    CString moduleRecordName = "moduleTest3";
817    CString moduleRequestName = "./secord.js";
818    CString result = "secord";
819    CString requestFileName = "secord.abc";
820    CString entryPoint =
821        ModulePathHelper::ConcatFileNameWithMerge(thread, pf.get(), baseFilename, moduleRecordName, moduleRequestName);
822    EXPECT_EQ(baseFilename, requestFileName);
823    EXPECT_EQ(result, entryPoint);
824
825    // Test RecordName is not in JSPandaFile and baseFilename with "/" and moduleRequestName with "/"
826    baseFilename = "test/merge.abc";
827    std::unique_ptr<const File> pfPtr2 = pandasm::AsmEmitter::Emit(res.Value());
828    std::shared_ptr<JSPandaFile> pf2 = pfManager->NewJSPandaFile(pfPtr2.release(), baseFilename);
829
830    moduleRecordName = "moduleTest3";
831    moduleRequestName = "./test/secord.js";
832    result = "secord";
833    requestFileName = "test/test/secord.abc";
834    entryPoint = ModulePathHelper::ConcatFileNameWithMerge(thread, pf2.get(), baseFilename, moduleRecordName,
835                                                     moduleRequestName);
836    EXPECT_EQ(baseFilename, requestFileName);
837    EXPECT_EQ(result, entryPoint);
838}
839
840HWTEST_F_L0(EcmaModuleTest, ConcatFileNameWithMerge4)
841{
842    CString baseFilename = "merge.abc";
843    const char *data = R"(
844        .language ECMAScript
845        .function any func_main_0(any a0, any a1, any a2) {
846            ldai 1
847            return
848        }
849    )";
850    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
851    Parser parser;
852    auto res = parser.Parse(data);
853    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
854    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
855    CUnorderedMap<CString, JSPandaFile::JSRecordInfo*> &recordInfo =
856        const_cast<CUnorderedMap<CString, JSPandaFile::JSRecordInfo*>&>(pf->GetJSRecordInfo());
857
858    CString moduleRecordName = "node_modules/0/moduleTest4/index";
859    CString moduleRequestName = "json/index";
860    CString result = "node_modules/0/moduleTest4/node_modules/json/index";
861    JSPandaFile::JSRecordInfo *info = new JSPandaFile::JSRecordInfo();
862    info->npmPackageName = "node_modules/0/moduleTest4";
863    recordInfo.insert({moduleRecordName, info});
864    recordInfo.insert({result, info});
865    CString entryPoint = ModulePathHelper::ConcatFileNameWithMerge(
866        thread, pf.get(), baseFilename, moduleRecordName, moduleRequestName);
867    EXPECT_EQ(result, entryPoint);
868
869    // delete info
870    delete info;
871    recordInfo.erase(moduleRecordName);
872    recordInfo.erase(result);
873}
874
875
876HWTEST_F_L0(EcmaModuleTest, NormalizePath)
877{
878    CString res1 = "node_modules/0/moduleTest/index";
879    CString moduleRecordName1 = "node_modules///0//moduleTest/index";
880
881    CString res2 = "node_modules/0/moduleTest/index";
882    CString moduleRecordName2 = "./node_modules///0//moduleTest/index";
883
884    CString res3 = "node_modules/0/moduleTest/index";
885    CString moduleRecordName3 = "../node_modules/0/moduleTest///index";
886
887    CString res4 = "moduleTest/index";
888    CString moduleRecordName4 = "./node_modules/..//moduleTest////index";
889
890    CString res5 = "node_modules/moduleTest/index";
891    CString moduleRecordName5 = "node_modules/moduleTest/index/";
892
893    CString normalName1 = PathHelper::NormalizePath(moduleRecordName1);
894    CString normalName2 = PathHelper::NormalizePath(moduleRecordName2);
895    CString normalName3 = PathHelper::NormalizePath(moduleRecordName3);
896    CString normalName4 = PathHelper::NormalizePath(moduleRecordName4);
897    CString normalName5 = PathHelper::NormalizePath(moduleRecordName5);
898
899    EXPECT_EQ(res1, normalName1);
900    EXPECT_EQ(res2, normalName2);
901    EXPECT_EQ(res3, normalName3);
902    EXPECT_EQ(res4, normalName4);
903    EXPECT_EQ(res5, normalName5);
904}
905
906HWTEST_F_L0(EcmaModuleTest, ParseAbcPathAndOhmUrl)
907{
908    // old pages url
909    instance->SetBundleName("com.bundleName.test");
910    instance->SetModuleName("moduleName");
911    CString inputFileName = "moduleName/ets/pages/index.abc";
912    CString outFileName = "";
913    CString res1 = "com.bundleName.test/moduleName/ets/pages/index";
914    CString entryPoint;
915    ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
916    EXPECT_EQ(entryPoint, res1);
917    EXPECT_EQ(outFileName, "");
918
919    // new pages url
920    inputFileName = "@bundle:com.bundleName.test/moduleName/ets/pages/index.abc";
921    ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
922    EXPECT_EQ(entryPoint, res1);
923    EXPECT_EQ(outFileName, "/data/storage/el1/bundle/moduleName/ets/modules.abc");
924
925    // new pages url Intra-application cross hap
926    inputFileName = "@bundle:com.bundleName.test/moduleName1/ets/pages/index.abc";
927    CString outRes = "/data/storage/el1/bundle/moduleName1/ets/modules.abc";
928    CString res2 = "com.bundleName.test/moduleName1/ets/pages/index";
929    ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
930    EXPECT_EQ(entryPoint, res2);
931    EXPECT_EQ(outFileName, outRes);
932
933    // new pages url Cross-application
934    inputFileName = "@bundle:com.bundleName.test1/moduleName1/ets/pages/index.abc";
935    CString outRes1 = "/data/storage/el1/bundle/com.bundleName.test1/moduleName1/moduleName1/ets/modules.abc";
936    CString res3 = "com.bundleName.test1/moduleName1/ets/pages/index";
937    ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
938    EXPECT_EQ(entryPoint, res3);
939    EXPECT_EQ(outFileName, outRes1);
940
941    // worker url Intra-application cross hap
942    inputFileName = "/data/storage/el1/bundle/entry/ets/mainAbility.abc";
943    CString outRes2 = "/data/storage/el1/bundle/entry/ets/modules.abc";
944    CString res4 = "com.bundleName.test/entry/ets/mainAbility";
945    ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
946    EXPECT_EQ(entryPoint, res4);
947    EXPECT_EQ(outFileName, outRes2);
948
949    // worker url
950    outFileName = "";
951    inputFileName = "/data/storage/el1/bundle/moduleName/ets/mainAbility.abc";
952    CString res5 = "com.bundleName.test/moduleName/ets/mainAbility";
953    ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
954    EXPECT_EQ(entryPoint, res5);
955    EXPECT_EQ(outFileName, "/data/storage/el1/bundle/moduleName/ets/modules.abc");
956
957    CMap<CString, CMap<CString, CVector<CString>>> pkgList;
958    CMap<CString, CVector<CString>> entryList;
959    entryList["entry"] = {
960        "packageName", "entry",
961        "bundleName", "",
962        "moduleName", "",
963        "version", "",
964        "entryPath", "src/main/",
965        "isSO", "false"
966    };
967    entryList["har"] = {
968        "packageName", "har",
969        "bundleName", "",
970        "moduleName", "",
971        "version", "1.2.0",
972        "entryPath", "Index.ets",
973        "isSO", "false"
974    };
975    pkgList["entry"] = entryList;
976    instance->SetpkgContextInfoList(pkgList);
977
978    inputFileName = "com.bundleName.test/moduleName/ets/pages/index";
979    CString outRes3 = "/data/storage/el1/bundle/moduleName/ets/modules.abc";
980    CString res6 = "com.bundleName.test/com.bundleName.test/moduleName/ets/pages/index";
981    ModulePathHelper::ParseAbcPathAndOhmUrl(instance, inputFileName, outFileName, entryPoint);
982    EXPECT_EQ(entryPoint, res6);
983    EXPECT_EQ(outFileName, outRes3);
984}
985
986HWTEST_F_L0(EcmaModuleTest, CheckNativeModule)
987{
988    // load file
989    CString requestName1 = "@bundle:bundleName/moduleName/ets/index";
990
991    // load native modules
992    CString requestName2 = "@ohos:router";
993    CString requestName3 = "@app:bundleName/moduleName/lib*.so";
994    CString requestName4 = "@native:system.app";
995    CString requestName5 = "@xxx:internal";
996
997    // load npm Packages
998    CString requestName6 = "@package:pkg_modules/.ohpm/json5@2.2.3/pkg_modules/json5/dist/index";
999    CString requestName7 = "@ohos/common";
1000
1001    std::pair<bool, ModuleTypes> res1 = SourceTextModule::CheckNativeModule(requestName1);
1002    EXPECT_EQ(res1.first, false);
1003    EXPECT_EQ(res1.second, ModuleTypes::UNKNOWN);
1004
1005    std::pair<bool, ModuleTypes> res2 = SourceTextModule::CheckNativeModule(requestName2);
1006    EXPECT_EQ(res2.first, true);
1007    EXPECT_EQ(res2.second, ModuleTypes::OHOS_MODULE);
1008
1009    std::pair<bool, ModuleTypes> res3 = SourceTextModule::CheckNativeModule(requestName3);
1010    EXPECT_EQ(res3.first, true);
1011    EXPECT_EQ(res3.second, ModuleTypes::APP_MODULE);
1012
1013    std::pair<bool, ModuleTypes> res4 = SourceTextModule::CheckNativeModule(requestName4);
1014    EXPECT_EQ(res4.first, true);
1015    EXPECT_EQ(res4.second, ModuleTypes::NATIVE_MODULE);
1016
1017    std::pair<bool, ModuleTypes> res5 = SourceTextModule::CheckNativeModule(requestName5);
1018    EXPECT_EQ(res5.first, true);
1019    EXPECT_EQ(res5.second, ModuleTypes::INTERNAL_MODULE);
1020
1021    std::pair<bool, ModuleTypes> res6 = SourceTextModule::CheckNativeModule(requestName6);
1022    EXPECT_EQ(res6.first, false);
1023    EXPECT_EQ(res6.second, ModuleTypes::UNKNOWN);
1024
1025    std::pair<bool, ModuleTypes> res7 = SourceTextModule::CheckNativeModule(requestName7);
1026    EXPECT_EQ(res7.first, false);
1027    EXPECT_EQ(res7.second, ModuleTypes::UNKNOWN);
1028}
1029
1030HWTEST_F_L0(EcmaModuleTest, ResolveDirPath)
1031{
1032    CString inputFileName = "moduleName/ets/pages/index.abc";
1033    CString resName1 = "moduleName/ets/pages/";
1034    CString outFileName = PathHelper::ResolveDirPath(inputFileName);
1035    EXPECT_EQ(outFileName, resName1);
1036
1037    inputFileName = "moduleName\\ets\\pages\\index.abc";
1038    CString resName2 = "moduleName\\ets\\pages\\";
1039    outFileName = PathHelper::ResolveDirPath(inputFileName);
1040    EXPECT_EQ(outFileName, resName2);
1041
1042    inputFileName = "cjs";
1043    CString resName3 = "";
1044    outFileName = PathHelper::ResolveDirPath(inputFileName);
1045    EXPECT_EQ(outFileName, resName3);
1046}
1047
1048HWTEST_F_L0(EcmaModuleTest, DeleteNamespace)
1049{
1050    CString inputFileName = "moduleName@nameSpace";
1051    CString res1 = "moduleName";
1052    PathHelper::DeleteNamespace(inputFileName);
1053    EXPECT_EQ(inputFileName, res1);
1054
1055    inputFileName = "moduleName";
1056    CString res2 = "moduleName";
1057    PathHelper::DeleteNamespace(inputFileName);
1058    EXPECT_EQ(inputFileName, res2);
1059}
1060
1061HWTEST_F_L0(EcmaModuleTest, AdaptOldIsaRecord)
1062{
1063    CString inputFileName = "bundleName/moduleName@namespace/moduleName";
1064    CString res1 = "moduleName";
1065    PathHelper::AdaptOldIsaRecord(inputFileName);
1066    EXPECT_EQ(inputFileName, res1);
1067}
1068
1069HWTEST_F_L0(EcmaModuleTest, GetStrippedModuleName)
1070{
1071    CString inputFileName = "@ohos:hilog";
1072    CString res1 = "hilog";
1073    CString outFileName = PathHelper::GetStrippedModuleName(inputFileName);
1074    EXPECT_EQ(outFileName, res1);
1075}
1076
1077HWTEST_F_L0(EcmaModuleTest, GetInternalModulePrefix)
1078{
1079    CString inputFileName = "@ohos:hilog";
1080    CString res1 = "ohos";
1081    CString outFileName = PathHelper::GetInternalModulePrefix(inputFileName);
1082    EXPECT_EQ(outFileName, res1);
1083}
1084
1085HWTEST_F_L0(EcmaModuleTest, IsNativeModuleRequest)
1086{
1087    CString inputFileName = "json5";
1088    bool res1 = ModulePathHelper::IsNativeModuleRequest(inputFileName);
1089    EXPECT_TRUE(!res1);
1090
1091    inputFileName = "@ohos:hilog";
1092    bool res2 = ModulePathHelper::IsNativeModuleRequest(inputFileName);
1093    EXPECT_TRUE(res2);
1094
1095    inputFileName = "@app:xxxx";
1096    bool res3 = ModulePathHelper::IsNativeModuleRequest(inputFileName);
1097    EXPECT_TRUE(res3);
1098
1099    inputFileName = "@native:xxxx";
1100    bool res4 = ModulePathHelper::IsNativeModuleRequest(inputFileName);
1101    EXPECT_TRUE(res4);
1102}
1103
1104HWTEST_F_L0(EcmaModuleTest, IsImportFile)
1105{
1106    CString inputFileName = "./test";
1107    bool res1 = ModulePathHelper::IsImportFile(inputFileName);
1108    EXPECT_TRUE(res1);
1109    CString outFileName = ModulePathHelper::RemoveSuffix(inputFileName);
1110    EXPECT_EQ(outFileName, inputFileName);
1111
1112    inputFileName = "test";
1113    bool res2 = ModulePathHelper::IsImportFile(inputFileName);
1114    EXPECT_TRUE(!res2);
1115    outFileName = ModulePathHelper::RemoveSuffix(inputFileName);
1116    EXPECT_EQ(outFileName, inputFileName);
1117
1118    CString result = "test";
1119    inputFileName = "test.js";
1120    bool res3 = ModulePathHelper::IsImportFile(inputFileName);
1121    EXPECT_TRUE(res3);
1122    outFileName = ModulePathHelper::RemoveSuffix(inputFileName);
1123    EXPECT_EQ(outFileName, result);
1124
1125    inputFileName = "test.ts";
1126    bool res4 = ModulePathHelper::IsImportFile(inputFileName);
1127    EXPECT_TRUE(res4);
1128    outFileName = ModulePathHelper::RemoveSuffix(inputFileName);
1129    EXPECT_EQ(outFileName, result);
1130
1131    inputFileName = "test.ets";
1132    bool res5 = ModulePathHelper::IsImportFile(inputFileName);
1133    EXPECT_TRUE(res5);
1134    outFileName = ModulePathHelper::RemoveSuffix(inputFileName);
1135    EXPECT_EQ(outFileName, result);
1136
1137    inputFileName = "test.json";
1138    bool res6 = ModulePathHelper::IsImportFile(inputFileName);
1139    EXPECT_TRUE(res6);
1140    outFileName = ModulePathHelper::RemoveSuffix(inputFileName);
1141    EXPECT_EQ(outFileName, result);
1142}
1143
1144HWTEST_F_L0(EcmaModuleTest, GetModuleNameWithPath)
1145{
1146    CString inputPath1 = "com.example.application/entry";
1147    CString res1 = "entry";
1148    CString outFileName1 = ModulePathHelper::GetModuleNameWithPath(inputPath1);
1149    EXPECT_EQ(outFileName1, res1);
1150
1151    CString inputPath2 = "com.example.applicationentry";
1152    CString res2 = "";
1153    CString outFileName2 = ModulePathHelper::GetModuleNameWithPath(inputPath2);
1154    EXPECT_EQ(outFileName2, res2);
1155}
1156
1157HWTEST_F_L0(EcmaModuleTest, ConcatPandaFilePath)
1158{
1159    CString inputPath1 = "entry";
1160    CString res1 = "/data/storage/el1/bundle/entry/ets/modules.abc";
1161    CString outFileName1 = ModulePathHelper::ConcatPandaFilePath(inputPath1);
1162    EXPECT_EQ(outFileName1, res1);
1163
1164    CString inputPath2 = "";
1165    CString res2 = "";
1166    CString outFileName2 = ModulePathHelper::ConcatPandaFilePath(inputPath2);
1167    EXPECT_EQ(outFileName2, res2);
1168
1169    CString inputPath3 = "entry1";
1170    CString res3 = "/data/storage/el1/bundle/entry1/ets/modules.abc";
1171    CString outFileName3 = ModulePathHelper::ConcatPandaFilePath(inputPath3);
1172    EXPECT_EQ(outFileName3, res3);
1173}
1174
1175HWTEST_F_L0(EcmaModuleTest, ParseFileNameToVMAName)
1176{
1177    CString inputFileName = "test.abc";
1178    CString outFileName = ModulePathHelper::ParseFileNameToVMAName(inputFileName);
1179    CString exceptOutFileName = "ArkTS Code:test.abc";
1180    EXPECT_EQ(outFileName, exceptOutFileName);
1181
1182    inputFileName = "";
1183    outFileName = ModulePathHelper::ParseFileNameToVMAName(inputFileName);
1184    exceptOutFileName = "ArkTS Code";
1185    EXPECT_EQ(outFileName, exceptOutFileName);
1186
1187    inputFileName = "libutil.z.so/util.js";
1188    outFileName = ModulePathHelper::ParseFileNameToVMAName(inputFileName);
1189    exceptOutFileName = "ArkTS Code:libutil.z.so/util.js";
1190    EXPECT_EQ(outFileName, exceptOutFileName);
1191
1192    inputFileName = "libutil.HashMap.z.so/util.HashMap.js";
1193    outFileName = ModulePathHelper::ParseFileNameToVMAName(inputFileName);
1194    exceptOutFileName = "ArkTS Code:libhashmap.z.so/HashMap.js";
1195    EXPECT_EQ(outFileName, exceptOutFileName);
1196
1197    inputFileName = "/data/storage/el1/bundle/com.example.application/ets/modules.abc";
1198    outFileName = ModulePathHelper::ParseFileNameToVMAName(inputFileName);
1199    exceptOutFileName = "ArkTS Code:com.example.application/ets/modules.abc";
1200    EXPECT_EQ(outFileName, exceptOutFileName);
1201}
1202
1203HWTEST_F_L0(EcmaModuleTest, ConcatUnifiedOhmUrl)
1204{
1205    CString pkgName = "entry";
1206    CString path = "/Index";
1207    CString version = "1.0.0";
1208    CString outFileName = ModulePathHelper::ConcatUnifiedOhmUrl("", pkgName, "", path, version);
1209    CString exceptOutFileName = "&entry/src/main/Index&1.0.0";
1210    EXPECT_EQ(outFileName, exceptOutFileName);
1211
1212    CString path2 = "Index";
1213    outFileName = ModulePathHelper::ConcatUnifiedOhmUrl("", path2, version);
1214    exceptOutFileName = "&Index&1.0.0";
1215    EXPECT_EQ(outFileName, exceptOutFileName);
1216}
1217
1218HWTEST_F_L0(EcmaModuleTest, ConcatImportFileNormalizedOhmurl)
1219{
1220    CString recordPath = "&entry/ets/";
1221    CString requestName = "test";
1222    CString outFileName = ModulePathHelper::ConcatImportFileNormalizedOhmurl(recordPath, requestName, "");
1223    CString exceptOutFileName = "&entry/ets/test&";
1224    EXPECT_EQ(outFileName, exceptOutFileName);
1225}
1226
1227HWTEST_F_L0(EcmaModuleTest, ConcatNativeSoNormalizedOhmurl)
1228{
1229    CString pkgName = "libentry.so";
1230    CString outFileName = ModulePathHelper::ConcatNativeSoNormalizedOhmurl("", "", pkgName, "");
1231    CString exceptOutFileName = "@normalized:Y&&&libentry.so&";
1232    EXPECT_EQ(outFileName, exceptOutFileName);
1233}
1234
1235HWTEST_F_L0(EcmaModuleTest, ConcatNotSoNormalizedOhmurl)
1236{
1237    CString pkgName = "har";
1238    CString path = "Index";
1239    CString version = "1.0.0";
1240    CString outFileName = ModulePathHelper::ConcatNotSoNormalizedOhmurl("", "", pkgName, path, version);
1241    CString exceptOutFileName = "@normalized:N&&&har/Index&1.0.0";
1242    EXPECT_EQ(outFileName, exceptOutFileName);
1243}
1244
1245HWTEST_F_L0(EcmaModuleTest, TranslateExpressionToNormalized)
1246{
1247    instance->SetBundleName("com.example.myapplication");
1248    CString baseFilename = "merge.abc";
1249    const char *data = R"(
1250        .language ECMAScript
1251        .function any func_main_0(any a0, any a1, any a2) {
1252            ldai 1
1253            return
1254        }
1255    )";
1256    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
1257    Parser parser;
1258    auto res = parser.Parse(data);
1259    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
1260    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
1261
1262    CString requestPath = "@native:system.app";
1263    CString baseFileName = "";
1264    CString recordName = "";
1265    ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, recordName, requestPath);
1266    EXPECT_EQ(requestPath, "@native:system.app");
1267
1268    requestPath = "@ohos:hilog";
1269    ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, recordName, requestPath);
1270    EXPECT_EQ(requestPath, "@ohos:hilog");
1271
1272    requestPath = "@normalized:N&&&har/Index&1.0.0";
1273    ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, recordName, requestPath);
1274    EXPECT_EQ(requestPath, "@normalized:N&&&har/Index&1.0.0");
1275
1276    requestPath = "@arkui-x.bridge";
1277    CString result = ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, recordName,
1278        requestPath);
1279    EXPECT_EQ(result, "@ohos:bridge");
1280
1281    requestPath = "ets/Test";
1282    recordName = "&entry/ets/pages/Index&";
1283    pf->InsertJSRecordInfo("&entry/ets/Test&");
1284    result = ModulePathHelper::TranslateExpressionToNormalized(thread, pf.get(), baseFileName, recordName,
1285        requestPath);
1286    EXPECT_EQ(result, "&entry/ets/Test&");
1287}
1288
1289HWTEST_F_L0(EcmaModuleTest, TranslateExpressionToNormalized2)
1290{
1291    CMap<CString, CMap<CString, CVector<CString>>> pkgList;
1292    CMap<CString, CVector<CString>> entryList;
1293    entryList["entry"] = {
1294        "packageName", "entry",
1295        "bundleName", "",
1296        "moduleName", "",
1297        "version", "",
1298        "entryPath", "src/main/",
1299        "isSO", "false"
1300    };
1301    entryList["har"] = {
1302        "packageName", "har",
1303        "bundleName", "",
1304        "moduleName", "",
1305        "version", "1.2.0",
1306        "entryPath", "Index.ets",
1307        "isSO", "false"
1308    };
1309    pkgList["entry"] = entryList;
1310    instance->SetpkgContextInfoList(pkgList);
1311
1312    CString requestPath = "har";
1313    CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1314    CString result = ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, "",
1315        requestPath);
1316    EXPECT_EQ(result, "@normalized:N&&&har/Index&1.2.0");
1317
1318    requestPath = "har/src/main/Test";
1319    result = ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, "",
1320        requestPath);
1321    EXPECT_EQ(result, "@normalized:N&&&har/src/main/Test&1.2.0");
1322}
1323
1324HWTEST_F_L0(EcmaModuleTest, TranslateExpressionToNormalized3)
1325{
1326    instance->SetBundleName("com.example.myapplication");
1327    CString baseFilename = "merge.abc";
1328    const char *data = R"(
1329        .language ECMAScript
1330        .function any func_main_0(any a0, any a1, any a2) {
1331            ldai 1
1332            return
1333        }
1334    )";
1335    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
1336    Parser parser;
1337    auto res = parser.Parse(data);
1338    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
1339    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
1340
1341    CString requestPath = "./@normalized:N&&&har/Index&1.0.0";
1342    CString baseFileName = "";
1343    CString recordName = "";
1344    pf->InsertJSRecordInfo("@normalized:N&&&har/Index&1.0.0&");
1345    CString result = ModulePathHelper::TranslateExpressionToNormalized(thread, pf.get(), baseFileName, recordName,
1346        requestPath);
1347    EXPECT_EQ(result, "./@normalized:N&&&har/Index&1.0.0");
1348
1349    requestPath = "ets/Test";
1350    recordName = "&entry/ets/pages/Index&";
1351    result = ModulePathHelper::TranslateExpressionToNormalized(thread, pf.get(), baseFileName, recordName,
1352        requestPath);
1353    EXPECT_EQ(result, "&entry/ets/Test&");
1354}
1355
1356HWTEST_F_L0(EcmaModuleTest, TranslateExpressionToNormalized4)
1357{
1358    CMap<CString, CMap<CString, CVector<CString>>> pkgList;
1359    CMap<CString, CVector<CString>> entryList;
1360    entryList["entry"] = {
1361        "packageName", "entry",
1362        "bundleName", "",
1363        "moduleName", "",
1364        "version", "",
1365        "entryPath", "src/main/",
1366        "isSO", "false"
1367    };
1368    entryList["har"] = {
1369        "packageName", "har",
1370        "bundleName", "",
1371        "moduleName", "",
1372        "version", "1.2.0",
1373        "entryPath", "./Index.ets",
1374        "isSO", "true"
1375    };
1376    pkgList["entry"] = entryList;
1377    instance->SetpkgContextInfoList(pkgList);
1378
1379    // ConcatNormalizedOhmurlWithData testcase
1380    CString requestPath = "har";
1381    CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1382    CString result = ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, "",
1383        requestPath);
1384    EXPECT_EQ(result, "@normalized:Y&&&har&1.2.0");
1385}
1386
1387HWTEST_F_L0(EcmaModuleTest, TranslateExpressionToNormalized5)
1388{
1389    CMap<CString, CMap<CString, CVector<CString>>> pkgList;
1390    CMap<CString, CVector<CString>> entryList;
1391    entryList["har"] = {
1392        "packageName", "har",
1393        "bundleName", "",
1394        "moduleName", "",
1395        "version", "1.2.0",
1396        "entryPath", "./Index.ets",
1397        "isSO", "false"
1398    };
1399    pkgList["entry"] = entryList;
1400    instance->SetpkgContextInfoList(pkgList);
1401
1402    CMap<CString, CString> aliasMap;
1403    aliasMap["@ohos/library"] = "har";
1404    instance->SetPkgAliasList(aliasMap);
1405
1406    CString requestPath = "@ohos/library/src/main/ets/Test";
1407    CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1408    CString result = ModulePathHelper::TranslateExpressionToNormalized(thread, nullptr, baseFileName, "",
1409        requestPath);
1410    EXPECT_EQ(result, "@normalized:N&&&har/src/main/ets/Test&1.2.0");
1411}
1412
1413HWTEST_F_L0(EcmaModuleTest, TranslateNapiFileRequestPath)
1414{
1415    CString modulePath = "modulePath";
1416    CString requestName = "requestName";
1417    CString result = ModulePathHelper::TranslateNapiFileRequestPath(thread, modulePath, requestName);
1418    EXPECT_EQ(result, "modulePath/requestName");
1419
1420    CMap<CString, CMap<CString, CVector<CString>>> list;
1421    CMap<CString, CVector<CString>> childList;
1422    list["hsp"] = childList;
1423    instance->SetpkgContextInfoList(list);
1424
1425    result = ModulePathHelper::TranslateNapiFileRequestPath(thread, modulePath, requestName);
1426    EXPECT_EQ(result, "&/src/main/requestName&");
1427}
1428
1429HWTEST_F_L0(EcmaModuleTest, SplitNormalizedRecordName)
1430{
1431    CString requestPath = "&har/Index&1.0.0";
1432    CVector<CString> res = ModulePathHelper::SplitNormalizedRecordName(requestPath);
1433    int exceptCount = 5;
1434    EXPECT_EQ(res.size(), exceptCount);
1435    CString emptyStr = "";
1436    EXPECT_EQ(res[0], emptyStr);
1437    EXPECT_EQ(res[1], emptyStr);
1438    EXPECT_EQ(res[2], emptyStr);
1439
1440    CString importPath = "har/Index";
1441    EXPECT_EQ(res[3], importPath);
1442    CString version = "1.0.0";
1443    EXPECT_EQ(res[4], version);
1444}
1445
1446HWTEST_F_L0(EcmaModuleTest, SplitNormalizedRecordName2)
1447{
1448    CString requestPath = "har/Index";
1449    CVector<CString> res = ModulePathHelper::SplitNormalizedRecordName(requestPath);
1450    int exceptCount = 5;
1451    EXPECT_EQ(res.size(), exceptCount);
1452    CString emptyStr = "";
1453    EXPECT_EQ(res[0], emptyStr);
1454    EXPECT_EQ(res[1], emptyStr);
1455    EXPECT_EQ(res[2], emptyStr);
1456    EXPECT_EQ(res[3], emptyStr);
1457    CString importPath = "har/Index";
1458    EXPECT_EQ(res[4], importPath);
1459}
1460
1461HWTEST_F_L0(EcmaModuleTest, ConcatPreviewTestUnifiedOhmUrl)
1462{
1463    CString bundleName = "";
1464    CString pkgName = "entry";
1465    CString path = "/.test/testability/pages/Index";
1466    CString version = "";
1467    CString exceptOutUrl = "&entry/.test/testability/pages/Index&";
1468    CString res = ModulePathHelper::ConcatPreviewTestUnifiedOhmUrl(bundleName, pkgName, path, version);
1469    EXPECT_EQ(res, exceptOutUrl);
1470}
1471
1472HWTEST_F_L0(EcmaModuleTest, NeedTranslateToNormalized)
1473{
1474    CString requestName = "@ohos:hilog";
1475    bool res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1476    EXPECT_EQ(res, false);
1477
1478    requestName = "@app:com.example.myapplication/entry";
1479    res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1480    EXPECT_EQ(res, false);
1481
1482    requestName = "@bundle:com.example.myapplication/library";
1483    res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1484    EXPECT_EQ(res, false);
1485
1486    requestName = "@package:pkg_modules/.ohpm/json5@2.2.3/pkg_modules/json5/dist/index";
1487    res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1488    EXPECT_EQ(res, false);
1489
1490    requestName = "@normalized:N&&&har/Index&1.0.0";
1491    res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1492    EXPECT_EQ(res, false);
1493
1494    requestName = "json5";
1495    res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1496    EXPECT_EQ(res, true);
1497
1498    requestName = "library";
1499    res = ModulePathHelper::NeedTranslateToNormalized(requestName);
1500    EXPECT_EQ(res, true);
1501}
1502
1503HWTEST_F_L0(EcmaModuleTest, ModuleLogger) {
1504    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1505    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1506    CString baseFileName = "modules.abc";
1507    module1->SetEcmaModuleFilenameString(baseFileName);
1508    CString recordName1 = "a";
1509    module1->SetEcmaModuleRecordNameString(recordName1);
1510    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1511    module2->SetEcmaModuleFilenameString(baseFileName);
1512    CString recordName2 = "b";
1513    module2->SetEcmaModuleRecordNameString(recordName2);
1514    JSHandle<JSTaggedValue> moduleRequest = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("c"));
1515    JSHandle<JSTaggedValue> importName = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("ccc"));
1516    JSHandle<JSTaggedValue> localName = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("ccc"));
1517    JSHandle<ImportEntry> importEntry = objectFactory->NewImportEntry(moduleRequest, importName,
1518                                                                      localName, SharedTypes::UNSENDABLE_MODULE);
1519    SourceTextModule::AddImportEntry(thread, module2, importEntry, 0, 1);
1520    JSHandle<SourceTextModule> module3 = objectFactory->NewSourceTextModule();
1521    module2->SetEcmaModuleFilenameString(baseFileName);
1522    CString recordName3 = "c";
1523    module2->SetEcmaModuleRecordNameString(recordName3);
1524    ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
1525    moduleLogger->SetStartTime(recordName1);
1526    moduleLogger->SetEndTime(recordName1);
1527    moduleLogger->SetStartTime(recordName2);
1528    moduleLogger->SetEndTime(recordName2);
1529    moduleLogger->SetStartTime(recordName3);
1530    moduleLogger->InsertEntryPointModule(module1);
1531    moduleLogger->InsertParentModule(module1, module2);
1532    moduleLogger->InsertModuleLoadInfo(module2, module3, -1);
1533    moduleLogger->InsertModuleLoadInfo(module2, module3, 0);
1534    moduleLogger->PrintModuleLoadInfo();
1535    Local<JSValueRef> nativeFunc = SourceTextModule::GetRequireNativeModuleFunc(thread->GetEcmaVM(),
1536                                                                                module3->GetTypes());
1537    bool isFunc = nativeFunc->IsFunction(thread->GetEcmaVM());
1538    EXPECT_EQ(isFunc, false);
1539}
1540
1541HWTEST_F_L0(EcmaModuleTest, GetRequireNativeModuleFunc) {
1542    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1543    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
1544    uint16_t registerNum = module->GetRegisterCounts();
1545    module->SetStatus(ecmascript::ModuleStatus::INSTANTIATED);
1546    module->SetRegisterCounts(registerNum);
1547    Local<JSValueRef> nativeFunc = SourceTextModule::GetRequireNativeModuleFunc(thread->GetEcmaVM(),
1548                                                                                module->GetTypes());
1549    bool isFunc = nativeFunc->IsFunction(thread->GetEcmaVM());
1550    EXPECT_EQ(isFunc, false);
1551}
1552
1553/*
1554 * Feature: Module
1555 * Function: StoreModuleValue
1556 * SubFunction: StoreModuleValue/GetModuleValue
1557 * FunctionPoints: store a module export item in module
1558 * CaseDescription: Simulated implementation of "export foo as bar", set foo as "hello world",
1559 *                  use "import bar" in same js file
1560 */
1561HWTEST_F_L0(EcmaModuleTest, StoreModuleValue2)
1562{
1563    ObjectFactory* objFactory = thread->GetEcmaVM()->GetFactory();
1564    CString localName = "foo";
1565    CString exportName = "bar";
1566    CString value = "hello world";
1567    CString value2 = "hello world1";
1568    int32_t index = 1;
1569
1570    JSHandle<JSTaggedValue> localNameHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
1571    JSHandle<JSTaggedValue> exportNameHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(exportName));
1572    JSHandle<LocalExportEntry> localExportEntry =
1573        objFactory->NewLocalExportEntry(exportNameHandle, localNameHandle, LocalExportEntry::LOCAL_DEFAULT_INDEX,
1574                                        SharedTypes::UNSENDABLE_MODULE);
1575    JSHandle<SourceTextModule> module = objFactory->NewSourceTextModule();
1576    SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry, 0, 1);
1577
1578    JSHandle<JSTaggedValue> storeKey = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
1579    JSHandle<JSTaggedValue> valueHandle = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(value));
1580    JSHandle<JSTaggedValue> valueHandle1 = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(value2));
1581    module->StoreModuleValue(thread, storeKey, valueHandle);
1582    module->StoreModuleValue(thread, index, valueHandle1);
1583    JSHandle<JSTaggedValue> loadKey = JSHandle<JSTaggedValue>::Cast(objFactory->NewFromUtf8(localName));
1584    JSTaggedValue loadValue = module->GetModuleValue(thread, loadKey.GetTaggedValue(), false);
1585    JSTaggedValue loadValue1 = module->GetModuleValue(thread, index, false);
1586    EXPECT_EQ(valueHandle.GetTaggedValue(), loadValue);
1587    EXPECT_EQ(valueHandle1.GetTaggedValue(), loadValue1);
1588}
1589
1590HWTEST_F_L0(EcmaModuleTest, MakeAppArgs1) {
1591    std::vector<Local<JSValueRef>> arguments;
1592    CString soPath = "@normalized:Y&&&libentry.so&";
1593    CString moduleName = "entry";
1594    CString requestName = "@normalized:";
1595    arguments.emplace_back(StringRef::NewFromUtf8(thread->GetEcmaVM(), soPath.c_str()));
1596    SourceTextModule::MakeAppArgs(thread->GetEcmaVM(), arguments, soPath, moduleName, requestName);
1597    std::string res1 = arguments[0]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1598    std::string res2 = arguments[1]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1599    std::string res3 = arguments[2]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1600    EXPECT_TRUE(res1 == "entry");
1601    EXPECT_TRUE(res2 == "true");
1602    EXPECT_TRUE(res3 == "/entry");
1603}
1604
1605HWTEST_F_L0(EcmaModuleTest, MakeAppArgs2) {
1606    std::vector<Local<JSValueRef>> arguments;
1607    CString soPath = "@app:com.example.myapplication/entry";
1608    CString moduleName = "entry";
1609    CString requestName = "@app:";
1610    arguments.emplace_back(StringRef::NewFromUtf8(thread->GetEcmaVM(), soPath.c_str()));
1611    SourceTextModule::MakeAppArgs(thread->GetEcmaVM(), arguments, soPath, moduleName, requestName);
1612    std::string res1 = arguments[0]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1613    std::string res2 = arguments[1]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1614    std::string res3 = arguments[2]->ToString(thread->GetEcmaVM())->ToString(thread->GetEcmaVM());
1615    EXPECT_TRUE(res1 == "entry");
1616    EXPECT_TRUE(res2 == "true");
1617    EXPECT_TRUE(res3 == "@app:com.example.myapplication");
1618}
1619
1620HWTEST_F_L0(EcmaModuleTest, ConcatHspFileNameCrossBundle)
1621{
1622    CString bundleName = "com.example.application";
1623    CString moduleName = "entry";
1624    CString expectRes = "/data/storage/el1/bundle/com.example.application/entry/entry/ets/modules.abc";
1625    CString res = ModulePathHelper::ConcatHspFileNameCrossBundle(bundleName, moduleName);
1626    EXPECT_EQ(res, expectRes);
1627}
1628
1629HWTEST_F_L0(EcmaModuleTest, ConcatHspFileName)
1630{
1631    CString moduleName = "entry";
1632    CString expectRes = "/data/storage/el1/bundle/entry/ets/modules.abc";
1633    CString res = ModulePathHelper::ConcatHspFileName(moduleName);
1634    EXPECT_EQ(res, expectRes);
1635}
1636
1637HWTEST_F_L0(EcmaModuleTest, ParseNormalizedOhmUrl)
1638{
1639    CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1640    CString recordName = "&har/Index&1.0.0";
1641    CString requestName = "@normalized:N&&&har/src/main/page/Test&1.0.0";
1642    CString expectRes = "&har/src/main/page/Test&1.0.0";
1643    CString exceptBaseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1644    CString res = ModulePathHelper::ParseNormalizedOhmUrl(thread, baseFileName, recordName, requestName);
1645    EXPECT_EQ(res, expectRes);
1646    EXPECT_EQ(baseFileName, exceptBaseFileName);
1647
1648    baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1649    requestName = "@normalized:N&hsp&&hsp/src/main/page/Test&1.0.0";
1650    expectRes = "&hsp/src/main/page/Test&1.0.0";
1651    exceptBaseFileName = "/data/storage/el1/bundle/hsp/ets/modules.abc";
1652    CString res2 = ModulePathHelper::ParseNormalizedOhmUrl(thread, baseFileName, recordName, requestName);
1653    EXPECT_EQ(res2, expectRes);
1654    EXPECT_EQ(baseFileName, exceptBaseFileName);
1655
1656    baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1657    requestName = "@normalized:N&hsp&com.example.application&hsp/src/main/page/Test&1.0.0";
1658    exceptBaseFileName = "/data/storage/el1/bundle/com.example.application/hsp/hsp/ets/modules.abc";
1659    expectRes = "com.example.application&hsp/src/main/page/Test&1.0.0";
1660    CString res3 = ModulePathHelper::ParseNormalizedOhmUrl(thread, baseFileName, recordName, requestName);
1661    EXPECT_EQ(res3, expectRes);
1662    EXPECT_EQ(baseFileName, exceptBaseFileName);
1663
1664    baseFileName = "";
1665    recordName = "&har/Index&1.0.0";
1666    requestName = "@normalized:N&&&har/src/main/page/Test&1.0.0";
1667    CString res4 = ModulePathHelper::ParseNormalizedOhmUrl(thread, baseFileName, recordName, requestName);
1668    EXPECT_EQ(baseFileName, "");
1669}
1670
1671HWTEST_F_L0(EcmaModuleTest, GetModuleNameWithBaseFile)
1672{
1673    CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1674    CString expectRes = "entry";
1675    CString res = ModulePathHelper::GetModuleNameWithBaseFile(baseFileName);
1676    EXPECT_EQ(res, expectRes);
1677
1678    baseFileName = "/data/storage/el1/bundle/com.example.application/hsp/hsp/ets/modules.abc";
1679    expectRes = "hsp";
1680    res = ModulePathHelper::GetModuleNameWithBaseFile(baseFileName);
1681    EXPECT_EQ(res, expectRes);
1682}
1683
1684HWTEST_F_L0(EcmaModuleTest, GetBundleNameWithRecordName)
1685{
1686    CString recordName = "com.example.myapplication/library";
1687    CString expectRes = "com.example.myapplication";
1688    CString res = ModulePathHelper::GetBundleNameWithRecordName(instance, recordName);
1689    EXPECT_EQ(res, expectRes);
1690
1691    CMap<CString, CMap<CString, CVector<CString>>> list;
1692    CMap<CString, CVector<CString>> childList;
1693    list["hsp"] = childList;
1694    instance->SetpkgContextInfoList(list);
1695
1696    recordName = "&hsp&com.example.application&hsp/src/main/page/Test&1.0.0";
1697    expectRes = "com.example.application";
1698    res = ModulePathHelper::GetBundleNameWithRecordName(instance, recordName);
1699    EXPECT_EQ(res, expectRes);
1700
1701    instance->SetBundleName("com.example1.application");
1702    recordName = "&har/src/main/page/Test&1.0.0";
1703    expectRes = "com.example1.application";
1704    res = ModulePathHelper::GetBundleNameWithRecordName(instance, recordName);
1705    EXPECT_EQ(res, expectRes);
1706}
1707
1708HWTEST_F_L0(EcmaModuleTest, TransformToNormalizedOhmUrl)
1709{
1710    CMap<CString, CMap<CString, CVector<CString>>> pkgList;
1711    CMap<CString, CVector<CString>> entryList;
1712    entryList["entry"] = {
1713        "packageName", "entry",
1714        "bundleName", "",
1715        "moduleName", "",
1716        "version", "",
1717        "entryPath", "src/main/",
1718        "isSO", "false"
1719    };
1720    entryList["har"] = {
1721        "packageName", "har",
1722        "bundleName", "",
1723        "moduleName", "",
1724        "version", "1.2.0",
1725        "entryPath", "",
1726        "isSO", "false"
1727    };
1728    pkgList["entry"] = entryList;
1729    CMap<CString, CVector<CString>> ohosTestList;
1730    ohosTestList["ohosTest"] = {
1731        "packageName", "ohosTest",
1732        "bundleName", "",
1733        "moduleName", "",
1734        "version", "",
1735        "entryPath", "src/",
1736        "isSO", "false"
1737    };
1738    pkgList["ohosTest"] = ohosTestList;
1739    instance->SetpkgContextInfoList(pkgList);
1740
1741    CString inputFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1742    CString outBaseFileName = "";
1743    CString entryPoint = "ENTRY_MAIN_FUNCTION";
1744    CString res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1745    EXPECT_EQ(res, "ENTRY_MAIN_FUNCTION");
1746
1747    outBaseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1748    entryPoint = "com.example.myapplication/entry@har/ets/pages/Index";
1749    res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1750    EXPECT_EQ(res, "&har/src/main/ets/pages/Index&1.2.0");
1751
1752    outBaseFileName = "/data/storage/el1/bundle/ohosTest/ets/modules.abc";
1753    entryPoint = "com.example.myapplication/ohosTest/ets/pages/Index";
1754    res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1755    EXPECT_EQ(res, "&ohosTest/src/ets/pages/Index&");
1756
1757    outBaseFileName = "/data/storage/el1/bundle/entry/.test/ets/modules.abc";
1758    entryPoint = "com.example.myapplication/entry/.test/ets/pages/Index";
1759    res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1760    EXPECT_EQ(res, "&entry/.test/ets/pages/Index&");
1761}
1762
1763HWTEST_F_L0(EcmaModuleTest, TransformToNormalizedOhmUrl2)
1764{
1765    CString inputFileName = "/data/storage/el1/bundle/hsp/ets/modules.abc";
1766    CString outBaseFileName = "/data/storage/el1/bundle/com.example.application/hsp/hsp/ets/modules.abc";
1767    CString entryPoint = "com.example.myapplication/hsp/ets/pages/Index";
1768    CString res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1769    EXPECT_EQ(res, "com.example.myapplication/hsp/ets/pages/Index");
1770}
1771
1772HWTEST_F_L0(EcmaModuleTest, TransformToNormalizedOhmUrl3)
1773{
1774    // currentModuleName.size() is 0
1775    CString inputFileName = "/data/storage/el1/bundle";
1776    CString outBaseFileName = "/data/storage/el1/bundle";
1777    CString entryPoint = "com.example.myapplication/entry@har/ets/pages/Index";
1778    CString res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1779    EXPECT_EQ(res, "com.example.myapplication/entry@har/ets/pages/Index");
1780
1781    // pkgname.size() is 0
1782    CMap<CString, CString> list;
1783    list["har"] = "";
1784    instance->SetPkgNameList(list);
1785    inputFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1786    outBaseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1787    entryPoint = "com.example.myapplication/entry@har/ets/pages/Index";
1788    res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1789    EXPECT_EQ(res, entryPoint);
1790
1791    // oldEntryPoint equal ENTRY_MAIN_FUNCTION
1792    entryPoint = "_GLOBAL::func_main_0";
1793    res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1794    EXPECT_EQ(res, "_GLOBAL::func_main_0");
1795
1796    // oldEntryPoint is not equal ENTRY_MAIN_FUNCTION but start with &
1797    entryPoint = "&test";
1798    res = ModulePathHelper::TransformToNormalizedOhmUrl(instance, inputFileName, outBaseFileName, entryPoint);
1799    EXPECT_EQ(res, "&test");
1800}
1801
1802HWTEST_F_L0(EcmaModuleTest, TranslateExpressionInputWithEts)
1803{
1804    instance->SetBundleName("com.example.myapplication");
1805    CString baseFilename = "merge.abc";
1806    const char *data = R"(
1807        .language ECMAScript
1808        .function any func_main_0(any a0, any a1, any a2) {
1809            ldai 1
1810            return
1811        }
1812    )";
1813    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
1814    Parser parser;
1815    auto res = parser.Parse(data);
1816    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
1817    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
1818
1819    CString baseFileName = "/data/storage/el1/bundle/entry/ets/modules.abc";
1820    CString requestName = "ets/Test";
1821    CString recordName = "com.example.myapplication/entry/ets/pages/Index";
1822    CString expectRes = "com.example.myapplication/entry/ets/Test";
1823    CString result = ModulePathHelper::TranslateExpressionInputWithEts(thread, pf.get(), baseFileName, requestName);
1824    EXPECT_EQ(result, "");
1825
1826    pf->InsertJSRecordInfo(expectRes);
1827    result = ModulePathHelper::TranslateExpressionInputWithEts(thread, pf.get(), baseFileName, requestName);
1828    EXPECT_EQ(result, expectRes);
1829}
1830
1831HWTEST_F_L0(EcmaModuleTest, ReviseLoadedModuleCount1) {
1832    CString moduleName = "testModule";
1833    ModuleDeregister::ReviseLoadedModuleCount(thread, moduleName);
1834    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1835    bool res = moduleManager->IsLocalModuleLoaded(moduleName);
1836    EXPECT_EQ(res, false);
1837}
1838
1839HWTEST_F_L0(EcmaModuleTest, IncreaseRegisterCounts)
1840{
1841    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1842    JSNApi::EnableUserUncaughtErrorHandler(instance);
1843    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1844    EXPECT_TRUE(result);
1845    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1846    JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
1847    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1848    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1849    std::set<CString> increaseModule;
1850
1851    ModuleDeregister::IncreaseRegisterCounts(thread, module, increaseModule);
1852    EXPECT_EQ(module->GetRequestedModules().IsUndefined(), false);
1853
1854    module->SetRegisterCounts(INT8_MAX);
1855    ModuleDeregister::IncreaseRegisterCounts(thread, module, increaseModule);
1856    EXPECT_EQ(module->GetRequestedModules().IsUndefined(), false);
1857
1858    module2->SetRegisterCounts(INT8_MAX);
1859    ModuleDeregister::IncreaseRegisterCounts(thread, module2, increaseModule);
1860    EXPECT_EQ(module2->GetRequestedModules().IsUndefined(), true);
1861
1862    module2->SetLoadingTypes(LoadingTypes::STABLE_MODULE);
1863    ModuleDeregister::IncreaseRegisterCounts(thread, module2, increaseModule);
1864    bool res = module2->GetLoadingTypes() == LoadingTypes::STABLE_MODULE;
1865    EXPECT_EQ(res, true);
1866}
1867
1868HWTEST_F_L0(EcmaModuleTest, DecreaseRegisterCounts)
1869{
1870    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1871    JSNApi::EnableUserUncaughtErrorHandler(instance);
1872    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1873    EXPECT_TRUE(result);
1874    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1875    JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
1876    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1877    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1878    std::set<CString> decreaseModule;
1879
1880    ModuleDeregister::DecreaseRegisterCounts(thread, module, decreaseModule);
1881    bool res1 = module->GetLoadingTypes() != LoadingTypes::DYNAMITC_MODULE;
1882    EXPECT_EQ(res1, true);
1883
1884    module->SetRegisterCounts(INT8_MAX);
1885    ModuleDeregister::DecreaseRegisterCounts(thread, module, decreaseModule);
1886    EXPECT_EQ(module->GetRequestedModules().IsUndefined(), false);
1887
1888    module2->SetLoadingTypes(LoadingTypes::DYNAMITC_MODULE);
1889    ModuleDeregister::DecreaseRegisterCounts(thread, module2, decreaseModule);
1890    bool res2 = module2->GetLoadingTypes() != LoadingTypes::DYNAMITC_MODULE;
1891    EXPECT_EQ(res2, false);
1892}
1893
1894HWTEST_F_L0(EcmaModuleTest, GetSendableModuleValueImpl) {
1895    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1896    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1897    SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1898    int32_t index = 2;
1899    JSTaggedValue currentModule1 = module1.GetTaggedValue();
1900    JSTaggedValue res1 = manager1->GetSendableModuleValueImpl(
1901        thread, index, currentModule1);
1902    EXPECT_EQ(res1, thread->GlobalConstants()->GetUndefined());
1903
1904    SharedModuleManager* manager2 = SharedModuleManager::GetInstance();
1905    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1906    JSNApi::EnableUserUncaughtErrorHandler(instance);
1907    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1908    EXPECT_TRUE(result);
1909    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1910    JSHandle<SourceTextModule> module2 = moduleManager->HostGetImportedModule("module_test_module_test_C");
1911    JSTaggedValue currentModule2 = module2.GetTaggedValue();
1912    JSTaggedValue res2 = manager2->GetSendableModuleValueImpl(
1913        thread, index, currentModule2);
1914    EXPECT_NE(res2, thread->GlobalConstants()->GetUndefined());
1915}
1916
1917HWTEST_F_L0(EcmaModuleTest, GetLazySendableModuleValueImpl) {
1918    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1919    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1920    SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1921    int32_t index = 2;
1922    JSTaggedValue currentModule1 = module1.GetTaggedValue();
1923    JSTaggedValue res1 = manager1->GetLazySendableModuleValueImpl(
1924        thread, index, currentModule1);
1925    EXPECT_EQ(res1, thread->GlobalConstants()->GetUndefined());
1926}
1927
1928HWTEST_F_L0(EcmaModuleTest, ResolveImportedModuleWithMerge) {
1929    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1930    JSNApi::EnableUserUncaughtErrorHandler(instance);
1931    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1932    EXPECT_TRUE(result);
1933    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1934    JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
1935    module->SetSharedType(SharedTypes::SHARED_MODULE);
1936
1937    CString recordName2 = "testModule";
1938    SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1939    bool executeFromJob = false;
1940    JSHandle<JSTaggedValue> res = manager1->ResolveImportedModuleWithMerge(
1941        thread, baseFileName.c_str(), recordName2, executeFromJob);
1942    EXPECT_EQ(res.GetTaggedValue(), JSTaggedValue::Exception());
1943}
1944
1945HWTEST_F_L0(EcmaModuleTest, ResolveImportedModuleWithMerge2) {
1946    CString moduleName1;
1947    CString recordName1;
1948
1949    SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1950    bool executeFromJob = false;
1951    JSHandle<JSTaggedValue> res = manager1->ResolveImportedModuleWithMerge(
1952        thread, moduleName1, recordName1, executeFromJob);
1953    EXPECT_EQ(res.GetTaggedValue(), JSTaggedValue::Exception());
1954}
1955
1956HWTEST_F_L0(EcmaModuleTest, IsInstantiatedSModule) {
1957    SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
1958    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
1959    JSNApi::EnableUserUncaughtErrorHandler(instance);
1960    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
1961    EXPECT_TRUE(result);
1962    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
1963    JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
1964    bool res = manager1->IsInstantiatedSModule(thread, module);
1965    EXPECT_EQ(res, true);
1966}
1967
1968HWTEST_F_L0(EcmaModuleTest, ProcessModuleLoadInfoForESM)
1969{
1970    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
1971    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
1972    CString baseFileName = "modules.abc";
1973    module1->SetEcmaModuleFilenameString(baseFileName);
1974    CString recordName1 = "a";
1975    module1->SetEcmaModuleRecordNameString(recordName1);
1976    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
1977    JSHandle<ImportEntry> importEntry =
1978        objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
1979    SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
1980
1981    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
1982    module2->SetEcmaModuleFilenameString(baseFileName);
1983    CString recordName2 = "b";
1984    module2->SetEcmaModuleRecordNameString(recordName2);
1985    JSHandle<LocalExportEntry> localExportEntry =
1986        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
1987    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
1988    localExportEntries->Set(thread, 0, localExportEntry);
1989    module2->SetLocalExportEntries(thread, localExportEntries);
1990    module2->StoreModuleValue(thread, 0, val);
1991    module2->SetStatus(ModuleStatus::EVALUATED);
1992    ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
1993    thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
1994    // test ResolvedIndexBinding
1995    JSHandle<ResolvedIndexBinding> indexBinding =
1996        objectFactory->NewResolvedIndexBindingRecord(module2, 0);
1997    JSTaggedValue res1 = ModuleTools::ProcessModuleLoadInfo(thread, module1, indexBinding.GetTaggedValue(), 0);
1998    EXPECT_EQ(res1, val.GetTaggedValue());
1999
2000    JSTaggedValue res2 = ModuleTools::ProcessModuleNameSpaceLoadInfo(thread, module1, module2);
2001    EXPECT_NE(res2, JSTaggedValue::Exception());
2002
2003    // test HotReload
2004    thread->GetCurrentEcmaContext()->SetStageOfHotReload(StageOfHotReload::LOAD_END_EXECUTE_PATCHMAIN);
2005    JSTaggedValue res3 = ModuleTools::ProcessModuleLoadInfo(thread, module1, indexBinding.GetTaggedValue(), 0);
2006    EXPECT_EQ(res3, val.GetTaggedValue());
2007
2008    thread->GetCurrentEcmaContext()->AddPatchModule(recordName2, JSHandle<JSTaggedValue>::Cast(module2));
2009    JSTaggedValue res4 = ModuleTools::ProcessModuleLoadInfo(thread, module1, indexBinding.GetTaggedValue(), 0);
2010    EXPECT_EQ(res4, val.GetTaggedValue());
2011
2012    thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
2013    delete moduleLogger;
2014}
2015
2016HWTEST_F_L0(EcmaModuleTest, ProcessModuleLoadInfoForCJS)
2017{
2018    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2019    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
2020    CString baseFileName = "modules.abc";
2021    module1->SetEcmaModuleFilenameString(baseFileName);
2022    CString recordName1 = "a";
2023    module1->SetEcmaModuleRecordNameString(recordName1);
2024    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2025    JSHandle<ImportEntry> importEntry =
2026        objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
2027    SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
2028
2029    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
2030    module2->SetEcmaModuleFilenameString(baseFileName);
2031    CString recordName2 = "cjs";
2032    module2->SetEcmaModuleRecordNameString(recordName2);
2033    JSHandle<LocalExportEntry> localExportEntry =
2034        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2035    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2036    localExportEntries->Set(thread, 0, localExportEntry);
2037    module2->SetLocalExportEntries(thread, localExportEntries);
2038    module2->StoreModuleValue(thread, 0, val);
2039    module2->SetTypes(ModuleTypes::CJS_MODULE);
2040    module2->SetStatus(ModuleStatus::EVALUATED);
2041    JSHandle<CjsModule> moduleCjs = objectFactory->NewCjsModule();
2042    JSHandle<JSTaggedValue> recordName2Hdl =
2043        JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(recordName2.c_str()));
2044    JSHandle<JSTaggedValue> baseFileNameHdl =
2045        JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(baseFileName.c_str()));
2046    CjsModule::InitializeModule(thread, moduleCjs, recordName2Hdl, baseFileNameHdl);
2047    CjsModule::PutIntoCache(thread, moduleCjs, recordName2Hdl);
2048
2049    JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
2050    JSHandle<JSTaggedValue> resolution =
2051        JSHandle<JSTaggedValue>::Cast(objectFactory->NewResolvedBindingRecord(module2, val));
2052    envRec->Set(thread, 0, resolution);
2053    module1->SetEnvironment(thread, envRec);
2054
2055    ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
2056    thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
2057
2058    // test ResolvedBinding
2059    JSTaggedValue res1 = ModuleTools::ProcessModuleNameSpaceLoadInfo(thread, module1, module2);
2060    EXPECT_NE(res1, JSTaggedValue::Exception());
2061
2062    JSTaggedValue res2 = ModuleTools::ProcessModuleLoadInfo(thread, module1, resolution.GetTaggedValue(), 0);
2063    EXPECT_EQ(res2, JSTaggedValue::Exception());
2064    thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
2065    delete moduleLogger;
2066}
2067
2068HWTEST_F_L0(EcmaModuleTest, ProcessModuleLoadInfoForNativeModule)
2069{
2070    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2071    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
2072    CString baseFileName = "modules.abc";
2073    module1->SetEcmaModuleFilenameString(baseFileName);
2074    CString recordName1 = "a";
2075    module1->SetEcmaModuleRecordNameString(recordName1);
2076    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2077    JSHandle<ImportEntry> importEntry =
2078        objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
2079    SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
2080
2081    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
2082    module2->SetEcmaModuleFilenameString(baseFileName);
2083    CString recordName2 = "nativeModule";
2084    module2->SetEcmaModuleRecordNameString(recordName2);
2085    JSHandle<LocalExportEntry> localExportEntry =
2086        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2087    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2088    localExportEntries->Set(thread, 0, localExportEntry);
2089    module2->SetLocalExportEntries(thread, localExportEntries);
2090    module2->StoreModuleValue(thread, 0, val);
2091    module2->SetTypes(ModuleTypes::NATIVE_MODULE);
2092    module2->SetStatus(ModuleStatus::EVALUATED);
2093
2094    JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
2095    JSHandle<JSTaggedValue> resolution = JSHandle<JSTaggedValue>::Cast(
2096        objectFactory->NewResolvedBindingRecord(module2, val));
2097    envRec->Set(thread, 0, resolution);
2098    module1->SetEnvironment(thread, envRec);
2099
2100    ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
2101    thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
2102
2103    JSTaggedValue res1 = ModuleTools::ProcessModuleLoadInfo(thread, module1, resolution.GetTaggedValue(), 0);
2104    EXPECT_EQ(res1, JSTaggedValue::Exception());
2105
2106    JSTaggedValue res2 = ModuleTools::ProcessModuleNameSpaceLoadInfo(thread, module1, module2);
2107    EXPECT_NE(res2, JSTaggedValue::Exception());
2108    thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
2109    delete moduleLogger;
2110}
2111
2112HWTEST_F_L0(EcmaModuleTest, ResolvedBindingForLog)
2113{
2114    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2115    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
2116    CString baseFileName = "modules.abc";
2117    module1->SetEcmaModuleFilenameString(baseFileName);
2118    CString recordName1 = "a";
2119    module1->SetEcmaModuleRecordNameString(recordName1);
2120    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2121    JSHandle<ImportEntry> importEntry =
2122        objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
2123    SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
2124
2125    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
2126    module2->SetEcmaModuleFilenameString(baseFileName);
2127    CString recordName2 = "b";
2128    module2->SetEcmaModuleRecordNameString(recordName2);
2129    JSHandle<LocalExportEntry> localExportEntry =
2130        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2131    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2132    localExportEntries->Set(thread, 0, localExportEntry);
2133    module2->SetLocalExportEntries(thread, localExportEntries);
2134    module2->StoreModuleValue(thread, 0, val);
2135    module2->SetStatus(ModuleStatus::EVALUATED);
2136    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
2137    moduleManager->AddResolveImportedModule(recordName2, module2.GetTaggedValue());
2138
2139    ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
2140    thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
2141    // test ResolvedRecordIndexBinding
2142    JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName2);
2143    JSHandle<EcmaString> baseFileNameHdl = objectFactory->NewFromUtf8(baseFileName);
2144    JSHandle<ResolvedRecordIndexBinding> recordIndexBinding =
2145        objectFactory->NewSResolvedRecordIndexBindingRecord(recordNameHdl, baseFileNameHdl, 0);
2146    JSTaggedValue res1 = ModuleTools::ProcessModuleLoadInfo(thread, module1, recordIndexBinding.GetTaggedValue(), 0);
2147    EXPECT_EQ(res1, val.GetTaggedValue());
2148
2149    // test ResolvedRecordBinding
2150    JSHandle<ResolvedRecordBinding> nameBinding =
2151        objectFactory->NewSResolvedRecordBindingRecord(recordNameHdl, val);
2152    JSTaggedValue res2 = ModuleTools::ProcessModuleLoadInfo(thread, module1, nameBinding.GetTaggedValue(), 0);
2153    EXPECT_EQ(res2, JSTaggedValue::Exception());
2154    thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
2155    delete moduleLogger;
2156}
2157
2158HWTEST_F_L0(EcmaModuleTest, ToStringWithPrecision)
2159{
2160    std::string res = ModuleLogger::ToStringWithPrecision(4.550, 3);
2161    EXPECT_EQ(res, "4.55");
2162}
2163
2164HWTEST_F_L0(EcmaModuleTest, GetCurrentModuleName)
2165{
2166    ThreadNativeScope nativeScope(thread);
2167    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_module.abc";
2168    JSNApi::EnableUserUncaughtErrorHandler(instance);
2169    JSNApi::Execute(instance, baseFileName, "module_test_module_test_module");
2170    Local<ObjectRef> res = JSNApi::GetExportObject(instance, "module_test_module_test_module", "moduleName");
2171    JSHandle<JSTaggedValue> result = JSNApiHelper::ToJSHandle(res);
2172    CString moduleName = ConvertToString(result.GetTaggedValue());
2173    EXPECT_EQ(moduleName, "");
2174}
2175
2176HWTEST_F_L0(EcmaModuleTest, ReviseLoadedModuleCount2) {
2177    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2178    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
2179    CString recordName2 = "b";
2180    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
2181    moduleManager->AddResolveImportedModule(recordName2, module2.GetTaggedValue());
2182    module2->SetLoadingTypes(LoadingTypes::STABLE_MODULE);
2183
2184    ModuleDeregister::ReviseLoadedModuleCount(thread, recordName2);
2185    EXPECT_EQ(module2->GetLoadingTypes(), LoadingTypes::STABLE_MODULE);
2186}
2187
2188HWTEST_F_L0(EcmaModuleTest, IncreaseRegisterCounts2)
2189{
2190    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
2191    JSNApi::EnableUserUncaughtErrorHandler(instance);
2192    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
2193    EXPECT_TRUE(result);
2194    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
2195    JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
2196    std::set<CString> increaseModule;
2197    increaseModule.insert("module_test_module_test_B");
2198    increaseModule.insert("b");
2199    module->SetSharedType(SharedTypes::SHARED_MODULE);
2200    ModuleDeregister::IncreaseRegisterCounts(thread, module, increaseModule);
2201    EXPECT_EQ(module->GetRequestedModules().IsUndefined(), false);
2202}
2203
2204HWTEST_F_L0(EcmaModuleTest, DecreaseRegisterCounts2)
2205{
2206    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
2207    JSNApi::EnableUserUncaughtErrorHandler(instance);
2208    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
2209    EXPECT_TRUE(result);
2210    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
2211    JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
2212    std::set<CString> decreaseModule;
2213    decreaseModule.insert("module_test_module_test_B");
2214    decreaseModule.insert("b");
2215    module->SetSharedType(SharedTypes::SHARED_MODULE);
2216    ModuleDeregister::DecreaseRegisterCounts(thread, module, decreaseModule);
2217    EXPECT_EQ(module->GetRequestedModules().IsUndefined(), false);
2218}
2219
2220HWTEST_F_L0(EcmaModuleTest, GenerateSendableFuncModule)
2221{
2222    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2223    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2224    module->SetSharedType(SharedTypes::SHARED_MODULE);
2225    JSHandle<JSTaggedValue> moduleRecord = JSHandle<JSTaggedValue>::Cast(module);
2226    SendableClassModule::GenerateSendableFuncModule(thread, moduleRecord);
2227    JSHandle<SourceTextModule> currentModule = JSHandle<SourceTextModule>::Cast(moduleRecord);
2228    EXPECT_TRUE(SourceTextModule::IsModuleInSharedHeap(currentModule));
2229}
2230
2231HWTEST_F_L0(EcmaModuleTest, ConcatMergeFileNameToNormalized)
2232{
2233    CString baseFilename = "merge.abc";
2234    const char *data = R"(
2235        .language ECMAScript
2236        .function any func_main_0(any a0, any a1, any a2) {
2237            ldai 1
2238            return
2239        }
2240    )";
2241    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
2242    Parser parser;
2243    auto res = parser.Parse(data);
2244    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
2245    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
2246
2247    CString requestPath = "@normalized:N&&&har/Index&1.0.0";
2248    CString recordName = "";
2249    CString result = "&har/Index&1.0.0";
2250    CString entryPoint = ModulePathHelper::ConcatMergeFileNameToNormalized(thread, pf.get(), baseFilename, recordName,
2251        requestPath);
2252    EXPECT_EQ(result, entryPoint);
2253
2254    requestPath = "&index";
2255    result = "&index";
2256    entryPoint = ModulePathHelper::ConcatMergeFileNameToNormalized(thread, pf.get(), baseFilename, recordName,
2257        requestPath);
2258    EXPECT_EQ(result, entryPoint);
2259
2260    requestPath = "./@normalized:N&&&har/Index&1.0.0";
2261    result = "@normalized:N&&&har/Index&1.0.0&";
2262    pf->InsertJSRecordInfo(result);
2263    entryPoint = ModulePathHelper::ConcatMergeFileNameToNormalized(thread, pf.get(), baseFilename, recordName,
2264        requestPath);
2265    EXPECT_EQ(result, entryPoint);
2266}
2267
2268HWTEST_F_L0(EcmaModuleTest, ConcatImportFileNormalizedOhmurlWithRecordName)
2269{
2270    CString baseFilename = "merge.abc";
2271    const char *data = R"(
2272        .language ECMAScript
2273        .function any func_main_0(any a0, any a1, any a2) {
2274            ldai 1
2275            return
2276        }
2277    )";
2278    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
2279    Parser parser;
2280    auto res = parser.Parse(data);
2281    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
2282    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), baseFilename);
2283
2284    CString requestPath = "@normalized:N&&&har/Index&1.0.0";
2285    CString recordName = "";
2286    CString entryPoint = ModulePathHelper::ConcatImportFileNormalizedOhmurlWithRecordName(thread, pf.get(),
2287        baseFilename, recordName, requestPath);
2288    EXPECT_EQ(CString(), entryPoint);
2289
2290    requestPath = "@normalized:N&&&har/Index&1.0.0";
2291    CString result = "&har/Index&1:0.0";
2292    pf->InsertJSRecordInfo(result);
2293    entryPoint = ModulePathHelper::ConcatImportFileNormalizedOhmurlWithRecordName(thread, pf.get(), baseFilename,
2294        recordName, requestPath);
2295    EXPECT_EQ(result, entryPoint);
2296
2297    requestPath = "@normalized:N&&&har/Index&1.0.0";
2298    result = "@normalized:N&&&har/Index&1.0.0/index&";
2299    pf->InsertJSRecordInfo(result);
2300    entryPoint = ModulePathHelper::ConcatImportFileNormalizedOhmurlWithRecordName(thread, pf.get(), baseFilename,
2301        recordName, requestPath);
2302    EXPECT_EQ(result, entryPoint);
2303
2304    requestPath = "@normalized:N&&&har/Index&1.0.0";
2305    result = "@normalized:N&&&har/Index&1.0.0&";
2306    pf->InsertJSRecordInfo(result);
2307    entryPoint = ModulePathHelper::ConcatImportFileNormalizedOhmurlWithRecordName(thread, pf.get(), baseFilename,
2308        recordName, requestPath);
2309    EXPECT_EQ(result, entryPoint);
2310
2311    requestPath = "./@normalized:N&&&har/Index&1.0.0";
2312    entryPoint = ModulePathHelper::ConcatImportFileNormalizedOhmurlWithRecordName(thread, pf.get(), baseFilename,
2313        recordName, requestPath);
2314    EXPECT_EQ(result, entryPoint);
2315
2316    requestPath = "./Test2";
2317    recordName = "&entry/ets/pages/Index&";
2318    result = "&entry/ets/pages/Test2&";
2319    pf->InsertJSRecordInfo(result);
2320    entryPoint = ModulePathHelper::ConcatImportFileNormalizedOhmurlWithRecordName(thread, pf.get(), baseFilename,
2321        recordName, requestPath);
2322    EXPECT_EQ(result, entryPoint);
2323}
2324
2325HWTEST_F_L0(EcmaModuleTest, HostResolveImportedModuleWithMerge)
2326{
2327    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2328    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
2329
2330    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
2331    CString recordName2 = "@ohos:hilog";
2332    module2->SetEcmaModuleRecordNameString(recordName2);
2333    module2->SetTypes(ModuleTypes::NATIVE_MODULE);
2334
2335    JSHandle<JSTaggedValue> nativeName = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("@ohos:hilog"));
2336    JSHandle<JSTaggedValue> res1 =
2337        SourceTextModule::HostResolveImportedModuleWithMerge(thread, module1, nativeName, false);
2338    EXPECT_TRUE(res1->IsSourceTextModule());
2339
2340    thread->GetCurrentEcmaContext()->GetModuleManager()->AddResolveImportedModule(
2341        recordName2, module2.GetTaggedValue());
2342    JSHandle<JSTaggedValue> res2 =
2343        SourceTextModule::HostResolveImportedModuleWithMerge(thread, module1, nativeName, false);
2344    EXPECT_TRUE(res2->IsSourceTextModule());
2345}
2346
2347HWTEST_F_L0(EcmaModuleTest, SourceTextModuleHostResolveImportedModule)
2348{
2349    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2350    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
2351
2352    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
2353    CString recordName2 = "@ohos:hilog";
2354    module2->SetEcmaModuleRecordNameString(recordName2);
2355    module2->SetTypes(ModuleTypes::NATIVE_MODULE);
2356
2357    JSHandle<JSTaggedValue> nativeName = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("@ohos:hilog"));
2358    thread->GetCurrentEcmaContext()->GetModuleManager()->AddResolveImportedModule(
2359        recordName2, module2.GetTaggedValue());
2360    JSHandle<JSTaggedValue> res1 =
2361        SourceTextModule::HostResolveImportedModule(thread, module1, nativeName, false);
2362    EXPECT_TRUE(res1->IsSourceTextModule());
2363}
2364
2365HWTEST_F_L0(EcmaModuleTest, ResolveExportObject)
2366{
2367    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2368    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
2369
2370    JSHandle<JSTaggedValue> exportName = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("notExist"));
2371    JSHandle<NativeModuleFailureInfo> nativeModuleFailureInfo = objectFactory->NewNativeModuleFailureInfo();
2372    JSHandle<JSTaggedValue> res1 = SourceTextModule::ResolveExportObject(
2373        thread, module1, JSHandle<JSTaggedValue>::Cast(nativeModuleFailureInfo), exportName);
2374    EXPECT_TRUE(res1->IsResolvedIndexBinding());
2375
2376    JSHandle<JSFunction> ctor(thread->GetEcmaVM()->GetGlobalEnv()->GetObjectFunction());
2377    JSHandle<JSObject> obj(objectFactory->NewJSObjectByConstructor(ctor));
2378    JSHandle<TaggedArray> exportArr = objectFactory->NewTaggedArray(2);
2379    obj->SetProperties(thread, exportArr);
2380    JSHandle<JSHClass> jsHclass(thread, obj->GetJSHClass());
2381    JSHandle<LayoutInfo> layout = objectFactory->CreateLayoutInfo(0, MemSpaceType::OLD_SPACE, GrowMode::KEEP);
2382    jsHclass->SetLayout(thread, layout);
2383    JSHandle<JSTaggedValue> res2 = SourceTextModule::ResolveExportObject(
2384        thread, module1, JSHandle<JSTaggedValue>::Cast(obj), exportName);
2385    EXPECT_TRUE(res2->IsHole());
2386
2387    JSHandle<JSObject> obj1(objectFactory->NewJSObjectByConstructor(ctor));
2388    JSHandle<NameDictionary> dict = NameDictionary::Create(thread, NameDictionary::ComputeHashTableSize(2));
2389    obj1->SetProperties(thread, JSHandle<JSTaggedValue>::Cast(dict));
2390    JSHandle<JSTaggedValue> res3 = SourceTextModule::ResolveExportObject(
2391        thread, module1, JSHandle<JSTaggedValue>::Cast(obj1), exportName);
2392    EXPECT_TRUE(res3->IsHole());
2393}
2394
2395HWTEST_F_L0(EcmaModuleTest, ResolveNativeStarExport)
2396{
2397    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2398    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2399    CString recordName = "@ohos:hilog";
2400    module->SetEcmaModuleRecordNameString(recordName);
2401    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2402    JSHandle<LocalExportEntry> localExportEntry =
2403        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2404    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2405    localExportEntries->Set(thread, 0, localExportEntry);
2406    module->SetLocalExportEntries(thread, localExportEntries);
2407    module->StoreModuleValue(thread, 0, val);
2408    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2409
2410    JSHandle<JSTaggedValue> res1 = SourceTextModule::ResolveNativeStarExport(thread, module, val);
2411    EXPECT_TRUE(res1->IsNull());
2412
2413    module->SetStatus(ModuleStatus::EVALUATED);
2414    JSHandle<JSTaggedValue> res2 = SourceTextModule::ResolveNativeStarExport(thread, module, val);
2415    EXPECT_TRUE(res2->IsNull());
2416}
2417
2418HWTEST_F_L0(EcmaModuleTest, MakeInternalArgs)
2419{
2420    std::vector<Local<JSValueRef>> arguments;
2421    auto vm = thread->GetEcmaVM();
2422    CString soName = "@ohos:hilig";
2423    arguments.emplace_back(StringRef::NewFromUtf8(vm, soName.c_str()));
2424    SourceTextModule::MakeInternalArgs(vm, arguments, soName);
2425    EXPECT_TRUE(!thread->HasPendingException());
2426}
2427
2428HWTEST_F_L0(EcmaModuleTest, LoadNativeModuleImpl)
2429{
2430    auto vm = thread->GetEcmaVM();
2431    ObjectFactory *objectFactory = vm->GetFactory();
2432    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2433    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2434    JSHandle<LocalExportEntry> localExportEntry =
2435        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2436    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2437    localExportEntries->Set(thread, 0, localExportEntry);
2438    module->SetLocalExportEntries(thread, localExportEntries);
2439    module->StoreModuleValue(thread, 0, val);
2440    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2441    ModuleLogger *moduleLogger = new ModuleLogger(vm);
2442    thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
2443    // app module
2444    module->SetEcmaModuleRecordNameString("@app:bundleName/moduleName/lib*.so");
2445    SourceTextModule::LoadNativeModuleImpl(vm, thread, module, ModuleTypes::APP_MODULE);
2446    EXPECT_TRUE(!thread->HasPendingException());
2447
2448    // internal module
2449    Local<ObjectRef> globalObject = JSNApi::GetGlobalObject(vm);
2450    globalObject->Set(vm, StringRef::NewFromUtf8(vm, "requireNapi"),
2451        FunctionRef::New(const_cast<panda::EcmaVM*>(vm), MockRequireNapiUndefined));
2452    module->SetEcmaModuleRecordNameString("@hms:xxxxx");
2453    SourceTextModule::LoadNativeModuleImpl(vm, thread, module, ModuleTypes::INTERNAL_MODULE);
2454    EXPECT_TRUE(!thread->HasPendingException());
2455
2456    thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
2457    delete moduleLogger;
2458    SourceTextModule::LoadNativeModuleImpl(vm, thread, module, ModuleTypes::INTERNAL_MODULE);
2459    EXPECT_TRUE(!thread->HasPendingException());
2460}
2461
2462HWTEST_F_L0(EcmaModuleTest, LoadNativeModuleMayThrowError1)
2463{
2464    auto vm = thread->GetEcmaVM();
2465    ObjectFactory *objectFactory = vm->GetFactory();
2466    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2467    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2468    JSHandle<LocalExportEntry> localExportEntry =
2469        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2470    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2471    localExportEntries->Set(thread, 0, localExportEntry);
2472    module->SetEcmaModuleRecordNameString("@app:bundleName/moduleName/lib*.so");
2473    module->SetLocalExportEntries(thread, localExportEntries);
2474    module->StoreModuleValue(thread, 0, val);
2475    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2476    Local<JSValueRef> requireNapi = StringRef::NewFromUtf8(vm, "requireNapi");
2477    Local<ObjectRef> globalObject = JSNApi::GetGlobalObject(vm);
2478    globalObject->Set(vm, requireNapi, FunctionRef::New(const_cast<panda::EcmaVM*>(vm), MockRequireNapiFailure));
2479    SourceTextModule::LoadNativeModuleMayThrowError(thread, module, ModuleTypes::APP_MODULE);
2480    EXPECT_TRUE(thread->HasPendingException());
2481}
2482
2483HWTEST_F_L0(EcmaModuleTest, LoadNativeModuleMayThrowError2)
2484{
2485    auto vm = thread->GetEcmaVM();
2486    ObjectFactory *objectFactory = vm->GetFactory();
2487    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2488    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2489    JSHandle<LocalExportEntry> localExportEntry =
2490        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2491    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2492    localExportEntries->Set(thread, 0, localExportEntry);
2493    module->SetEcmaModuleRecordNameString("@app:bundleName/moduleName/lib*.so");
2494    module->SetLocalExportEntries(thread, localExportEntries);
2495    module->StoreModuleValue(thread, 0, val);
2496    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2497    Local<JSValueRef> requireNapi = StringRef::NewFromUtf8(vm, "requireNapi");
2498    Local<ObjectRef> globalObject = JSNApi::GetGlobalObject(vm);
2499    globalObject->Set(vm, requireNapi, FunctionRef::New(const_cast<panda::EcmaVM*>(vm), MockRequireNapiUndefined));
2500    SourceTextModule::LoadNativeModuleMayThrowError(thread, module, ModuleTypes::APP_MODULE);
2501    EXPECT_TRUE(thread->HasPendingException());
2502}
2503
2504HWTEST_F_L0(EcmaModuleTest, LoadNativeModuleMayThrowError3)
2505{
2506    auto vm = thread->GetEcmaVM();
2507    ObjectFactory *objectFactory = vm->GetFactory();
2508    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2509    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2510    JSHandle<LocalExportEntry> localExportEntry =
2511        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2512    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2513    localExportEntries->Set(thread, 0, localExportEntry);
2514    module->SetEcmaModuleRecordNameString("@app:bundleName/moduleName/lib*.so");
2515    module->SetLocalExportEntries(thread, localExportEntries);
2516    module->StoreModuleValue(thread, 0, val);
2517    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2518    Local<JSValueRef> requireNapi = StringRef::NewFromUtf8(vm, "requireNapi");
2519    Local<ObjectRef> globalObject = JSNApi::GetGlobalObject(vm);
2520    globalObject->Set(vm, requireNapi, FunctionRef::New(const_cast<panda::EcmaVM*>(vm), MockRequireNapiException));
2521    SourceTextModule::LoadNativeModuleMayThrowError(thread, module, ModuleTypes::APP_MODULE);
2522    EXPECT_TRUE(thread->HasPendingException());
2523}
2524
2525HWTEST_F_L0(EcmaModuleTest, LoadNativeModuleMayThrowError4)
2526{
2527    auto vm = thread->GetEcmaVM();
2528    ObjectFactory *objectFactory = vm->GetFactory();
2529    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2530    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2531    JSHandle<LocalExportEntry> localExportEntry =
2532        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2533    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2534    localExportEntries->Set(thread, 0, localExportEntry);
2535    module->SetEcmaModuleRecordNameString("@app:bundleName/moduleName/lib*.so");
2536    module->SetLocalExportEntries(thread, localExportEntries);
2537    module->StoreModuleValue(thread, 0, val);
2538    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2539    Local<JSValueRef> requireNapi = StringRef::NewFromUtf8(vm, "requireNapi");
2540    Local<ObjectRef> globalObject = JSNApi::GetGlobalObject(vm);
2541    globalObject->Set(vm, requireNapi, FunctionRef::New(const_cast<panda::EcmaVM*>(vm), MockRequireNapiValue));
2542    SourceTextModule::LoadNativeModuleMayThrowError(thread, module, ModuleTypes::APP_MODULE);
2543    EXPECT_TRUE(!thread->HasPendingException());
2544}
2545
2546HWTEST_F_L0(EcmaModuleTest, LoadNativeModule1)
2547{
2548    auto vm = thread->GetEcmaVM();
2549    ObjectFactory *objectFactory = vm->GetFactory();
2550    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2551    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2552    JSHandle<LocalExportEntry> localExportEntry =
2553        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2554    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2555    localExportEntries->Set(thread, 0, localExportEntry);
2556    module->SetEcmaModuleRecordNameString("@app:bundleName/moduleName/lib*.so");
2557    module->SetLocalExportEntries(thread, localExportEntries);
2558    module->StoreModuleValue(thread, 0, val);
2559    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2560    Local<JSValueRef> requireNapi = StringRef::NewFromUtf8(vm, "requireNapi");
2561    Local<ObjectRef> globalObject = JSNApi::GetGlobalObject(vm);
2562    globalObject->Set(vm, requireNapi, FunctionRef::New(const_cast<panda::EcmaVM*>(vm), MockRequireNapiValue));
2563    SourceTextModule::LoadNativeModule(thread, module, ModuleTypes::APP_MODULE);
2564    EXPECT_TRUE(!thread->HasPendingException());
2565}
2566
2567HWTEST_F_L0(EcmaModuleTest, LoadNativeModule2)
2568{
2569    auto vm = thread->GetEcmaVM();
2570    ObjectFactory *objectFactory = vm->GetFactory();
2571    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2572    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2573    JSHandle<LocalExportEntry> localExportEntry =
2574        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2575    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2576    localExportEntries->Set(thread, 0, localExportEntry);
2577    module->SetEcmaModuleRecordNameString("@app:bundleName/moduleName/lib*.so");
2578    module->SetLocalExportEntries(thread, localExportEntries);
2579    module->StoreModuleValue(thread, 0, val);
2580    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2581    Local<JSValueRef> requireNapi = StringRef::NewFromUtf8(vm, "requireNapi");
2582    Local<ObjectRef> globalObject = JSNApi::GetGlobalObject(vm);
2583    globalObject->Set(vm, requireNapi, FunctionRef::New(const_cast<panda::EcmaVM*>(vm), MockRequireNapiFailure));
2584    SourceTextModule::LoadNativeModule(thread, module, ModuleTypes::APP_MODULE);
2585    EXPECT_TRUE(!thread->HasPendingException());
2586}
2587
2588HWTEST_F_L0(EcmaModuleTest, EvaluateNativeModule1)
2589{
2590    auto vm = thread->GetEcmaVM();
2591    ObjectFactory *objectFactory = vm->GetFactory();
2592    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2593    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2594    module->SetStatus(ModuleStatus::EVALUATED);
2595    SourceTextModule::EvaluateNativeModule(thread, module, ModuleTypes::APP_MODULE);
2596    EXPECT_TRUE(!thread->HasPendingException());
2597}
2598
2599HWTEST_F_L0(EcmaModuleTest, EvaluateNativeModule2)
2600{
2601    auto vm = thread->GetEcmaVM();
2602    ObjectFactory *objectFactory = vm->GetFactory();
2603    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2604    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2605    JSHandle<LocalExportEntry> localExportEntry =
2606        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2607    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2608    localExportEntries->Set(thread, 0, localExportEntry);
2609    module->SetEcmaModuleRecordNameString("@app:bundleName/moduleName/lib*.so");
2610    module->SetLocalExportEntries(thread, localExportEntries);
2611    module->StoreModuleValue(thread, 0, val);
2612    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2613    module->SetStatus(ModuleStatus::INSTANTIATED);
2614    Local<JSValueRef> requireNapi = StringRef::NewFromUtf8(vm, "requireNapi");
2615    Local<ObjectRef> globalObject = JSNApi::GetGlobalObject(vm);
2616    globalObject->Set(vm, requireNapi, FunctionRef::New(const_cast<panda::EcmaVM*>(vm), MockRequireNapiFailure));
2617    SourceTextModule::EvaluateNativeModule(thread, module, ModuleTypes::APP_MODULE);
2618    EXPECT_TRUE(!thread->HasPendingException());
2619}
2620
2621HWTEST_F_L0(EcmaModuleTest, EvaluateNativeModule3)
2622{
2623    auto vm = thread->GetEcmaVM();
2624    ObjectFactory *objectFactory = vm->GetFactory();
2625    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2626    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2627    JSHandle<LocalExportEntry> localExportEntry =
2628        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2629    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2630    localExportEntries->Set(thread, 0, localExportEntry);
2631    module->SetEcmaModuleRecordNameString("@app:bundleName/moduleName/lib*.so");
2632    module->SetLocalExportEntries(thread, localExportEntries);
2633    module->StoreModuleValue(thread, 0, val);
2634    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2635    module->SetStatus(ModuleStatus::INSTANTIATED);
2636    Local<JSValueRef> requireNapi = StringRef::NewFromUtf8(vm, "requireNapi");
2637    Local<ObjectRef> globalObject = JSNApi::GetGlobalObject(vm);
2638    globalObject->Set(vm, requireNapi, FunctionRef::New(const_cast<panda::EcmaVM*>(vm), MockRequireNapiValue));
2639    SourceTextModule::EvaluateNativeModule(thread, module, ModuleTypes::APP_MODULE);
2640    EXPECT_TRUE(!thread->HasPendingException());
2641}
2642
2643
2644HWTEST_F_L0(EcmaModuleTest, InnerModuleInstantiation)
2645{
2646    auto vm = thread->GetEcmaVM();
2647    ObjectFactory *objectFactory = vm->GetFactory();
2648    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2649    module->SetEcmaModuleFilenameString("modules.abc");
2650    module->SetEcmaModuleRecordNameString("b");
2651    module->SetTypes(ModuleTypes::ECMA_MODULE);
2652    module->SetStatus(ModuleStatus::UNINSTANTIATED);
2653    module->SetIsNewBcVersion(false);
2654    CVector<JSHandle<SourceTextModule>> stack;
2655    int index = SourceTextModule::InnerModuleInstantiation(thread, JSHandle<ModuleRecord>::Cast(module), stack, 1, 0);
2656    EXPECT_EQ(index, 2);
2657}
2658
2659HWTEST_F_L0(EcmaModuleTest, ModuleDeclarationEnvironmentSetup)
2660{
2661    auto vm = thread->GetEcmaVM();
2662    ObjectFactory *objectFactory = vm->GetFactory();
2663    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2664    CString baseFileName = "modules.abc";
2665    CString recordName = "a";
2666    CString recordName1 = "@ohos:hilog";
2667    module->SetEcmaModuleFilenameString(baseFileName);
2668    module->SetEcmaModuleRecordNameString(recordName);
2669    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2670    module->SetStatus(ModuleStatus::UNINSTANTIATED);
2671    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2672    JSHandle<JSTaggedValue> moduleRequest =
2673        JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(recordName1.c_str()));
2674    JSHandle<JSTaggedValue> importName = val;
2675    JSHandle<JSTaggedValue> localName = val;
2676    JSHandle<ImportEntry> importEntry1 =
2677        objectFactory->NewImportEntry(moduleRequest, importName, localName, SharedTypes::UNSENDABLE_MODULE);
2678    SourceTextModule::AddImportEntry(thread, module, importEntry1, 0, 2);
2679    JSHandle<JSTaggedValue> starString = thread->GlobalConstants()->GetHandledStarString();
2680    JSHandle<ImportEntry> importEntry2 =
2681        objectFactory->NewImportEntry(moduleRequest, starString, localName, SharedTypes::UNSENDABLE_MODULE);
2682    SourceTextModule::AddImportEntry(thread, module, importEntry2, 1, 2);
2683
2684    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
2685    module1->SetEcmaModuleFilenameString(baseFileName);
2686    module1->SetEcmaModuleRecordNameString(recordName1);
2687    JSHandle<LocalExportEntry> localExportEntry =
2688        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2689    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2690    localExportEntries->Set(thread, 0, localExportEntry);
2691    module1->SetLocalExportEntries(thread, localExportEntries);
2692    module1->SetTypes(ModuleTypes::NATIVE_MODULE);
2693    module1->SetStatus(ModuleStatus::EVALUATED);
2694
2695    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
2696    moduleManager->AddResolveImportedModule(recordName.c_str(), module.GetTaggedValue());
2697    moduleManager->AddResolveImportedModule(recordName1.c_str(), module1.GetTaggedValue());
2698    CVector<JSHandle<SourceTextModule>> stack;
2699    SourceTextModule::ModuleDeclarationEnvironmentSetup(thread, module);
2700    EXPECT_TRUE(!thread->HasPendingException());
2701
2702    module->SetEcmaModuleRecordNameString("");
2703    SourceTextModule::ModuleDeclarationEnvironmentSetup(thread, module);
2704    EXPECT_TRUE(!thread->HasPendingException());
2705}
2706
2707HWTEST_F_L0(EcmaModuleTest, ModuleDeclarationArrayEnvironmentSetup)
2708{
2709    auto vm = thread->GetEcmaVM();
2710    ObjectFactory *objectFactory = vm->GetFactory();
2711    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2712    SourceTextModule::ModuleDeclarationArrayEnvironmentSetup(thread, module);
2713    EXPECT_TRUE(!thread->HasPendingException());
2714
2715    module->SetSharedType(SharedTypes::SHARED_MODULE);
2716    SourceTextModule::ModuleDeclarationArrayEnvironmentSetup(thread, module);
2717    EXPECT_TRUE(!thread->HasPendingException());
2718
2719    module->SetStatus(ModuleStatus::EVALUATED);
2720    SourceTextModule::ModuleDeclarationArrayEnvironmentSetup(thread, module);
2721    EXPECT_TRUE(!thread->HasPendingException());
2722
2723    module->SetSharedType(SharedTypes::UNSENDABLE_MODULE);
2724    SourceTextModule::ModuleDeclarationArrayEnvironmentSetup(thread, module);
2725    EXPECT_TRUE(!thread->HasPendingException());
2726}
2727
2728HWTEST_F_L0(EcmaModuleTest, Evaluate)
2729{
2730    auto vm = thread->GetEcmaVM();
2731    ObjectFactory *objectFactory = vm->GetFactory();
2732    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2733    CString recordName = "a";
2734    module->SetEcmaModuleRecordNameString(recordName);
2735    module->SetStatus(ModuleStatus::EVALUATED);
2736    module->SetCycleRoot(thread, module);
2737    SourceTextModule::Evaluate(thread, module, nullptr, 0, 0);
2738    EXPECT_TRUE(!thread->HasPendingException());
2739    SourceTextModule::Evaluate(thread, module, nullptr, 0, 1);
2740    EXPECT_TRUE(!thread->HasPendingException());
2741    ModuleLogger *moduleLogger = new ModuleLogger(vm);
2742    thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
2743    SourceTextModule::Evaluate(thread, module, nullptr, 0, 0);
2744    EXPECT_TRUE(!thread->HasPendingException());
2745    SourceTextModule::Evaluate(thread, module, nullptr, 0, 1);
2746    EXPECT_TRUE(!thread->HasPendingException());
2747    thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
2748    delete moduleLogger;
2749}
2750
2751HWTEST_F_L0(EcmaModuleTest, LoadNativeModule)
2752{
2753    auto vm = thread->GetEcmaVM();
2754    ObjectFactory *objectFactory = vm->GetFactory();
2755    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2756    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2757    JSHandle<LocalExportEntry> localExportEntry =
2758        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2759    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2760    localExportEntries->Set(thread, 0, localExportEntry);
2761    module->SetEcmaModuleRecordNameString("@app:bundleName/moduleName/lib*.so");
2762    module->SetLocalExportEntries(thread, localExportEntries);
2763    module->StoreModuleValue(thread, 0, val);
2764    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2765    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
2766    JSHandle<JSTaggedValue> res = moduleManager->LoadNativeModule(
2767        thread, "@app:bundleName/moduleName/lib*.so");
2768    EXPECT_EQ(res.GetTaggedValue(), JSTaggedValue::Undefined());
2769}
2770
2771HWTEST_F_L0(EcmaModuleTest, ExecuteNativeModuleMayThrowError)
2772{
2773    auto vm = thread->GetEcmaVM();
2774    ObjectFactory *objectFactory = vm->GetFactory();
2775    CString recordName = "@app:bundleName/moduleName/lib*.so";
2776    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2777    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2778    JSHandle<LocalExportEntry> localExportEntry =
2779        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2780    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2781    localExportEntries->Set(thread, 0, localExportEntry);
2782    module->SetEcmaModuleRecordNameString(recordName);
2783    module->SetLocalExportEntries(thread, localExportEntries);
2784    module->StoreModuleValue(thread, 0, val);
2785    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2786    module->SetStatus(ModuleStatus::EVALUATED);
2787    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
2788    JSHandle<JSTaggedValue> res = moduleManager->ExecuteNativeModuleMayThrowError(
2789        thread, recordName);
2790    EXPECT_EQ(res.GetTaggedValue(), JSTaggedValue::Undefined());
2791
2792    thread->GetCurrentEcmaContext()->GetModuleManager()->AddResolveImportedModule(
2793        recordName, module.GetTaggedValue());
2794    JSHandle<JSTaggedValue> res2 = moduleManager->ExecuteNativeModuleMayThrowError(
2795        thread, recordName);
2796    EXPECT_NE(res2.GetTaggedValue(), JSTaggedValue::Undefined());
2797}
2798
2799HWTEST_F_L0(EcmaModuleTest, ExecuteNativeModule)
2800{
2801    auto vm = thread->GetEcmaVM();
2802    CString recordName = "@app:bundleName/moduleName/lib*.so";
2803    ObjectFactory *objectFactory = vm->GetFactory();
2804    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2805    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2806    JSHandle<LocalExportEntry> localExportEntry =
2807        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2808    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2809    localExportEntries->Set(thread, 0, localExportEntry);
2810    module->SetEcmaModuleRecordNameString(recordName);
2811    module->SetLocalExportEntries(thread, localExportEntries);
2812    module->StoreModuleValue(thread, 0, val);
2813    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2814
2815    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
2816    module->SetStatus(ecmascript::ModuleStatus::INSTANTIATED);
2817    thread->GetCurrentEcmaContext()->GetModuleManager()->AddResolveImportedModule(
2818        recordName, module.GetTaggedValue());
2819    moduleManager->ExecuteNativeModule(thread, recordName);
2820    module->SetStatus(ModuleStatus::EVALUATED);
2821    JSHandle<JSTaggedValue> res = moduleManager->ExecuteNativeModule(thread, recordName);
2822    EXPECT_NE(res.GetTaggedValue(), JSTaggedValue::Undefined());
2823}
2824
2825HWTEST_F_L0(EcmaModuleTest, ExecuteNativeModule2)
2826{
2827    auto vm = thread->GetEcmaVM();
2828    CString recordName = "@app:bundleName/moduleName/lib*.so";
2829    ObjectFactory *objectFactory = vm->GetFactory();
2830    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2831    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2832    JSHandle<LocalExportEntry> localExportEntry =
2833        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
2834    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
2835    localExportEntries->Set(thread, 0, localExportEntry);
2836    module->SetEcmaModuleRecordNameString(recordName);
2837    module->SetLocalExportEntries(thread, localExportEntries);
2838    module->StoreModuleValue(thread, 0, val);
2839    module->SetTypes(ModuleTypes::NATIVE_MODULE);
2840
2841    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
2842    JSHandle<JSTaggedValue> res = moduleManager->ExecuteNativeModule(thread, recordName);
2843    EXPECT_NE(res.GetTaggedValue(), JSTaggedValue::Undefined());
2844}
2845
2846HWTEST_F_L0(EcmaModuleTest, GetResolvedRecordIndexBindingModule)
2847{
2848    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2849
2850    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
2851    std::string baseFileNameStr = MODULE_ABC_PATH "module_unexecute.abc";
2852    CString baseFileName = baseFileNameStr.c_str();
2853    module1->SetEcmaModuleFilenameString(baseFileName);
2854    CString recordName1 = "module_unexecute";
2855    module1->SetEcmaModuleRecordNameString(recordName1);
2856    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2857    JSHandle<ImportEntry> importEntry =
2858        objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
2859    SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
2860
2861    // test GetResolvedRecordIndexBindingModule
2862    JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName1);
2863    JSHandle<EcmaString> baseFileNameHdl = objectFactory->NewFromUtf8(baseFileName);
2864    JSHandle<ResolvedRecordIndexBinding> recordIndexBinding =
2865        objectFactory->NewSResolvedRecordIndexBindingRecord(recordNameHdl, baseFileNameHdl, 0);
2866
2867    JSHandle<SourceTextModule> resolvedModule = ecmascript::ModuleManagerHelper::
2868        GetResolvedRecordIndexBindingModule(thread, module1, recordIndexBinding);
2869    EXPECT_TRUE(resolvedModule->GetStatus() == ModuleStatus::EVALUATED);
2870}
2871
2872HWTEST_F_L0(EcmaModuleTest, GetResolvedRecordBindingModule)
2873{
2874    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2875    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
2876    std::string baseFileNameStr = MODULE_ABC_PATH "module_unexecute_A.abc";
2877    CString baseFileName = baseFileNameStr.c_str();
2878    module1->SetEcmaModuleFilenameString(baseFileName);
2879    CString recordName1 = "module_unexecute_A";
2880    module1->SetEcmaModuleRecordNameString(recordName1);
2881
2882    // test GetResolvedRecordBindingModule
2883    JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName1);
2884    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
2885    JSHandle<ResolvedRecordBinding> nameBinding =
2886        objectFactory->NewSResolvedRecordBindingRecord(recordNameHdl, val);
2887
2888    JSHandle<SourceTextModule> resolvedModule = ecmascript::ModuleManagerHelper::
2889        GetResolvedRecordBindingModule(thread, module1, nameBinding);
2890    EXPECT_TRUE(resolvedModule->GetStatus() == ModuleStatus::EVALUATED);
2891}
2892
2893HWTEST_F_L0(EcmaModuleTest, GetLazyModuleValueFromIndexBindingTest)
2894{
2895    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2896
2897    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
2898    std::string baseFileNameStr = MODULE_ABC_PATH "module_unexecute.abc";
2899    CString baseFileName = baseFileNameStr.c_str();
2900    module1->SetEcmaModuleFilenameString(baseFileName);
2901    CString recordName1 = "module_unexecute";
2902    module1->SetEcmaModuleRecordNameString(recordName1);
2903    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("stringOut"));
2904    JSHandle<ImportEntry> importEntry =
2905        objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
2906    SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
2907
2908    // test GetLazyModuleValueFromIndexBinding
2909    JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName1);
2910    JSHandle<EcmaString> baseFileNameHdl = objectFactory->NewFromUtf8(baseFileName);
2911    JSHandle<ResolvedRecordIndexBinding> recordIndexBinding =
2912        objectFactory->NewSResolvedRecordIndexBindingRecord(recordNameHdl, baseFileNameHdl, 0);
2913
2914    JSTaggedValue value = ecmascript::ModuleManagerHelper::GetLazyModuleValueFromIndexBinding(
2915        thread, module1, recordIndexBinding.GetTaggedValue());
2916
2917    EXPECT_TRUE(value.IsString());
2918}
2919
2920HWTEST_F_L0(EcmaModuleTest, GetLazyModuleValueFromRecordBindingTest)
2921{
2922    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2923    JSHandle<SourceTextModule> module1 = objectFactory->NewSSourceTextModule();
2924    std::string baseFileNameStr1 = MODULE_ABC_PATH "module_unexecute_C.abc";
2925    CString baseFileName1 = baseFileNameStr1.c_str();
2926    module1->SetEcmaModuleFilenameString(baseFileName1);
2927    CString recordName1 = "module_unexecute_C";
2928    module1->SetEcmaModuleRecordNameString(recordName1);
2929    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("default"));
2930
2931
2932    // test GetLazyModuleValueFromRecordBinding
2933    JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName1);
2934    JSHandle<ResolvedRecordBinding> nameBinding =
2935        objectFactory->NewSResolvedRecordBindingRecord(recordNameHdl, val);
2936
2937    JSTaggedValue resolvedModuleVal1 = ecmascript::ModuleManagerHelper::
2938        GetLazyModuleValueFromRecordBinding(thread, module1, nameBinding.GetTaggedValue());
2939    EXPECT_TRUE(resolvedModuleVal1.IsString());
2940}
2941
2942HWTEST_F_L0(EcmaModuleTest, ExecuteCjsModule)
2943{
2944    std::string baseFileName = MODULE_ABC_PATH "module_unexecute_C.abc";
2945    const CString baseFileNameStr = baseFileName.c_str();
2946    CString recordName = "module_unexecute_C";
2947    JSNApi::EnableUserUncaughtErrorHandler(instance);
2948    JSNApi::Execute(instance, baseFileName, "module_unexecute_C");
2949
2950    std::shared_ptr<JSPandaFile> jsPandaFile =
2951        JSPandaFileManager::GetInstance()->LoadJSPandaFile(thread, baseFileNameStr, recordName, false);
2952    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
2953    moduleManager->ExecuteCjsModule(thread, recordName, jsPandaFile.get());
2954    EXPECT_TRUE(moduleManager->IsEvaluatedModule(recordName));
2955}
2956
2957HWTEST_F_L0(EcmaModuleTest, GetModuleNamespace)
2958{
2959    CString localName1 = "foo";
2960    CString exportName1 = "bar";
2961    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2962    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2963    JSHandle<JSTaggedValue> localNameHandle1 = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(localName1));
2964    JSHandle<JSTaggedValue> exportNameHandle1 = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(exportName1));
2965    JSHandle<LocalExportEntry> localExportEntry1 =
2966        objectFactory->NewLocalExportEntry(exportNameHandle1, localNameHandle1, LocalExportEntry::LOCAL_DEFAULT_INDEX,
2967                                        SharedTypes::UNSENDABLE_MODULE);
2968    SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry1, 0, 1);
2969    JSHandle<JSTaggedValue> key = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(localName1));
2970    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
2971    JSHandle<JSFunction> ctor(thread->GetEcmaVM()->GetGlobalEnv()->GetObjectFunction());
2972    ctor->SetModule(thread, module);
2973    JSTaggedValue jsFunc = ctor.GetTaggedValue();
2974    JSTaggedValue res = moduleManager->GetModuleNamespace(key.GetTaggedValue(), jsFunc);
2975    EXPECT_EQ(res, JSTaggedValue::Undefined());
2976}
2977
2978HWTEST_F_L0(EcmaModuleTest, GetModuleValueInner3)
2979{
2980    CString localName1 = "foo";
2981    CString exportName1 = "bar";
2982    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
2983    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
2984    JSHandle<JSTaggedValue> localNameHandle1 = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(localName1));
2985    JSHandle<JSTaggedValue> exportNameHandle1 = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(exportName1));
2986    JSHandle<LocalExportEntry> localExportEntry1 =
2987        objectFactory->NewLocalExportEntry(exportNameHandle1, localNameHandle1, LocalExportEntry::LOCAL_DEFAULT_INDEX,
2988                                        SharedTypes::UNSENDABLE_MODULE);
2989    SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry1, 0, 1);
2990    JSHandle<JSTaggedValue> key = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(exportName1));
2991    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
2992    JSHandle<JSFunction> ctor(thread->GetEcmaVM()->GetGlobalEnv()->GetObjectFunction());
2993    ctor->SetModule(thread, module);
2994    JSTaggedValue jsFunc = ctor.GetTaggedValue();
2995    moduleManager->GetModuleValueInner(key.GetTaggedValue(), jsFunc);
2996    JSTaggedValue res = moduleManager->GetModuleValueOutter(key.GetTaggedValue(), jsFunc);
2997    EXPECT_EQ(res, JSTaggedValue::Undefined());
2998}
2999
3000HWTEST_F_L0(EcmaModuleTest, GetModuleValueOutter)
3001{
3002    CString localName1 = "foo";
3003    CString exportName1 = "bar";
3004    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3005    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3006    JSHandle<JSTaggedValue> localNameHandle1 = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(localName1));
3007    JSHandle<JSTaggedValue> exportNameHandle1 = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(exportName1));
3008    JSHandle<LocalExportEntry> localExportEntry1 =
3009        objectFactory->NewLocalExportEntry(exportNameHandle1, localNameHandle1, LocalExportEntry::LOCAL_DEFAULT_INDEX,
3010                                        SharedTypes::UNSENDABLE_MODULE);
3011    SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry1, 0, 1);
3012    JSHandle<JSTaggedValue> key = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(exportName1));
3013
3014
3015    JSHandle<JSFunction> ctor(thread->GetEcmaVM()->GetGlobalEnv()->GetObjectFunction());
3016    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3017
3018    JSHandle<NameDictionary> map(NameDictionary::Create(thread, NameDictionary::ComputeHashTableSize(1)));
3019    module->SetEnvironment(thread, map);
3020
3021    ctor->SetModule(thread, module);
3022    JSTaggedValue jsFunc = ctor.GetTaggedValue();
3023    moduleManager->GetModuleValueInner(key.GetTaggedValue(), jsFunc);
3024    JSTaggedValue res = moduleManager->GetModuleValueOutter(key.GetTaggedValue(), jsFunc);
3025    EXPECT_EQ(res, JSTaggedValue::Undefined());
3026}
3027
3028HWTEST_F_L0(EcmaModuleTest, StoreModuleValue3)
3029{
3030    CString localName1 = "foo";
3031    CString exportName1 = "bar";
3032    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3033    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3034    JSHandle<JSTaggedValue> localNameHandle1 = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(localName1));
3035    JSHandle<JSTaggedValue> exportNameHandle1 = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(exportName1));
3036    JSHandle<LocalExportEntry> localExportEntry1 =
3037        objectFactory->NewLocalExportEntry(exportNameHandle1, localNameHandle1, LocalExportEntry::LOCAL_DEFAULT_INDEX,
3038                                        SharedTypes::UNSENDABLE_MODULE);
3039    SourceTextModule::AddLocalExportEntry(thread, module, localExportEntry1, 0, 1);
3040    JSHandle<JSTaggedValue> key = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(exportName1));
3041    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3042
3043    JSHandle<JSFunction> ctor(thread->GetEcmaVM()->GetGlobalEnv()->GetObjectFunction());
3044    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3045
3046    JSHandle<NameDictionary> map(NameDictionary::Create(thread, NameDictionary::ComputeHashTableSize(1)));
3047    module->SetEnvironment(thread, map);
3048
3049    ctor->SetModule(thread, module);
3050    JSTaggedValue jsFunc = ctor.GetTaggedValue();
3051    moduleManager->StoreModuleValue(key.GetTaggedValue(), val.GetTaggedValue(), jsFunc);
3052    EXPECT_TRUE(!thread->HasPendingException());
3053}
3054
3055HWTEST_F_L0(EcmaModuleTest, GetLazyModuleValueFromRecordBinding)
3056{
3057    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3058    CString baseFileName = "modules.abc";
3059    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3060
3061    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
3062    module2->SetEcmaModuleFilenameString(baseFileName);
3063    CString recordName2 = "b";
3064    module2->SetEcmaModuleRecordNameString(recordName2);
3065    JSHandle<LocalExportEntry> localExportEntry =
3066        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
3067    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
3068    localExportEntries->Set(thread, 0, localExportEntry);
3069    module2->SetLocalExportEntries(thread, localExportEntries);
3070    module2->StoreModuleValue(thread, 0, val);
3071    module2->SetStatus(ModuleStatus::EVALUATED);
3072    module2->SetTypes(ModuleTypes::NATIVE_MODULE);
3073    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3074    moduleManager->AddResolveImportedModule(recordName2, module2.GetTaggedValue());
3075
3076    JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName2);
3077    JSHandle<ResolvedRecordBinding> nameBinding =
3078        objectFactory->NewSResolvedRecordBindingRecord(recordNameHdl, val);
3079    JSHandle<JSTaggedValue> key = JSHandle<JSTaggedValue>::Cast(nameBinding);
3080    ModuleManagerHelper::GetLazyModuleValueFromRecordBinding(thread, module2, key.GetTaggedValue());
3081    ModuleManagerHelper::GetModuleValueFromRecordBinding(thread, module2, key.GetTaggedValue());
3082    EXPECT_TRUE(!thread->HasPendingException());
3083}
3084
3085HWTEST_F_L0(EcmaModuleTest, ReplaceModuleThroughFeature1)
3086{
3087    auto vm = thread->GetEcmaVM();
3088    CString moduleName = "a";
3089    std::map<std::string, std::string> list;
3090    list.emplace(moduleName, moduleName);
3091    vm->SetMockModuleList(list);
3092    CString res = SourceTextModule::ReplaceModuleThroughFeature(thread, moduleName);
3093    EXPECT_EQ(res, moduleName);
3094}
3095
3096HWTEST_F_L0(EcmaModuleTest, ReplaceModuleThroughFeature2)
3097{
3098    auto vm = thread->GetEcmaVM();
3099    CString moduleName = "a";
3100    std::vector<panda::HmsMap> map;
3101    HmsMap tmp;
3102    tmp.targetPath = "a";
3103    tmp.originalPath = "a";
3104    map.push_back(tmp);
3105    vm->SetHmsModuleList(map);
3106    CString res = SourceTextModule::ReplaceModuleThroughFeature(thread, moduleName);
3107    EXPECT_EQ(res, moduleName);
3108}
3109
3110HWTEST_F_L0(EcmaModuleTest, CheckResolvedBinding)
3111{
3112    auto vm = thread->GetEcmaVM();
3113    ObjectFactory *objectFactory = vm->GetFactory();
3114    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3115    CString recordName = "a";
3116    module->SetEcmaModuleRecordNameString(recordName);
3117    module->SetStatus(ModuleStatus::EVALUATED);
3118    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3119    moduleManager->AddResolveImportedModule(recordName, module.GetTaggedValue());
3120
3121    SourceTextModule::CheckResolvedBinding(thread, module);
3122    EXPECT_TRUE(!thread->HasPendingException());
3123
3124    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
3125    CString recordName2 = "@ohos:hilog";
3126    module2->SetEcmaModuleRecordNameString(recordName2);
3127    module2->SetTypes(ModuleTypes::NATIVE_MODULE);
3128    module2->SetStatus(ModuleStatus::EVALUATED);
3129    moduleManager->AddResolveImportedModule(recordName2, module2.GetTaggedValue());
3130    JSHandle<JSTaggedValue> moduleName2 = JSHandle<JSTaggedValue>::Cast(
3131        objectFactory->NewFromUtf8(recordName2.c_str()));
3132    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3133    JSHandle<IndirectExportEntry> indirectExportEntry = objectFactory->NewIndirectExportEntry(val,
3134        moduleName2, val, SharedTypes::UNSENDABLE_MODULE);
3135    JSHandle<TaggedArray> indirectExportEntries = objectFactory->NewTaggedArray(1);
3136    indirectExportEntries->Set(thread, 0, indirectExportEntry);
3137    module->SetIndirectExportEntries(thread, indirectExportEntries);
3138    SourceTextModule::CheckResolvedBinding(thread, module);
3139    EXPECT_TRUE(thread->HasPendingException());
3140    thread->ClearException();
3141
3142    JSHandle<LocalExportEntry> localExportEntry =
3143        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
3144    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
3145    localExportEntries->Set(thread, 0, localExportEntry);
3146    module2->SetLocalExportEntries(thread, localExportEntries);
3147    SourceTextModule::CheckResolvedBinding(thread, module);
3148    EXPECT_TRUE(!thread->HasPendingException());
3149
3150    module->SetEcmaModuleRecordNameString("");
3151    module->SetEcmaModuleFilenameString(recordName);
3152    module2->SetLocalExportEntries(thread, thread->GlobalConstants()->GetUndefined());
3153    SourceTextModule::CheckResolvedBinding(thread, module);
3154    EXPECT_TRUE(thread->HasPendingException());
3155}
3156
3157HWTEST_F_L0(EcmaModuleTest, CheckResolvedIndexBinding)
3158{
3159    auto vm = thread->GetEcmaVM();
3160    ObjectFactory *objectFactory = vm->GetFactory();
3161    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3162    CString recordName = "a";
3163    module->SetEcmaModuleFilenameString(recordName);
3164    module->SetStatus(ModuleStatus::EVALUATED);
3165    CString recordName2 = "@ohos:hilog";
3166    JSHandle<JSTaggedValue> moduleName2 = JSHandle<JSTaggedValue>::Cast(
3167        objectFactory->NewFromUtf8(recordName2.c_str()));
3168    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3169    JSHandle<IndirectExportEntry> indirectExportEntry = objectFactory->NewIndirectExportEntry(val,
3170        moduleName2, val, SharedTypes::UNSENDABLE_MODULE);
3171    JSHandle<TaggedArray> indirectExportEntries = objectFactory->NewTaggedArray(1);
3172    indirectExportEntries->Set(thread, 0, indirectExportEntry);
3173    module->SetIndirectExportEntries(thread, indirectExportEntries);
3174    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3175    moduleManager->AddResolveImportedModule(recordName, module.GetTaggedValue());
3176
3177    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
3178    module2->SetEcmaModuleRecordNameString(recordName2);
3179    module2->SetTypes(ModuleTypes::NATIVE_MODULE);
3180    module2->SetStatus(ModuleStatus::EVALUATED);
3181    moduleManager->AddResolveImportedModule(recordName2, module2.GetTaggedValue());
3182    SourceTextModule::CheckResolvedIndexBinding(thread, module);
3183    EXPECT_TRUE(thread->HasPendingException());
3184}
3185
3186HWTEST_F_L0(EcmaModuleTest, SetExportName)
3187{
3188    auto vm = thread->GetEcmaVM();
3189    ObjectFactory *objectFactory = vm->GetFactory();
3190    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3191    CString recordName = "a";
3192    module->SetEcmaModuleFilenameString(recordName);
3193    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
3194    CString recordName2 = "@ohos:hilog";
3195    module2->SetEcmaModuleFilenameString(recordName2);
3196    JSHandle<JSTaggedValue> moduleName2 = JSHandle<JSTaggedValue>::Cast(
3197        objectFactory->NewFromUtf8(recordName2.c_str()));
3198    CVector<std::string> exportNames;
3199    JSHandle<TaggedArray> exportStarSet = objectFactory->NewTaggedArray(2);
3200    SourceTextModule::SetExportName(thread, moduleName2, module, exportNames, exportStarSet);
3201    EXPECT_TRUE(thread->HasPendingException());
3202}
3203
3204HWTEST_F_L0(EcmaModuleTest, IsCircular)
3205{
3206    CList<CString> referenceList;
3207    CString moduleName = "a";
3208    bool res1 = SourceTextModule::IsCircular(referenceList, moduleName);
3209    EXPECT_EQ(res1, false);
3210
3211    referenceList.push_back(moduleName);
3212    referenceList.push_back("b");
3213    bool res2 = SourceTextModule::IsCircular(referenceList, moduleName);
3214    EXPECT_EQ(res2, true);
3215
3216    bool res3 = SourceTextModule::IsCircular(referenceList, "c");
3217    EXPECT_EQ(res3, false);
3218}
3219
3220HWTEST_F_L0(EcmaModuleTest, SearchCircularImport)
3221{
3222    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3223    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3224    CString baseFileName = "modules.abc";
3225    module->SetEcmaModuleFilenameString(baseFileName);
3226    CString recordName = "a";
3227    CString recordName2 = "@ohos:hilog";
3228    module->SetEcmaModuleRecordNameString(recordName);
3229    JSHandle<TaggedArray> requestArr = objectFactory->NewTaggedArray(1);
3230    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8(recordName2.c_str()));
3231    requestArr->Set(thread, 0, val.GetTaggedValue());
3232    module->SetRequestedModules(thread, requestArr);
3233
3234    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
3235    module2->SetEcmaModuleRecordNameString(recordName2);
3236    module2->SetTypes(ModuleTypes::NATIVE_MODULE);
3237    module2->SetStatus(ModuleStatus::EVALUATED);
3238    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3239    moduleManager->AddResolveImportedModule(recordName2, module2.GetTaggedValue());
3240
3241    CList<CString> referenceList;
3242    referenceList.push_back(recordName);
3243    referenceList.push_back("b");
3244    referenceList.push_back(recordName2);
3245    SourceTextModule::SearchCircularImport(thread, recordName, module, referenceList, recordName2, true);
3246    EXPECT_TRUE(!thread->HasPendingException());
3247}
3248
3249HWTEST_F_L0(EcmaModuleTest, IsDynamicModule)
3250{
3251    bool res = SourceTextModule::IsDynamicModule(LoadingTypes::DYNAMITC_MODULE);
3252    EXPECT_EQ(res, true);
3253}
3254
3255HWTEST_F_L0(EcmaModuleTest, StoreModuleValue4)
3256{
3257    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3258    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3259    module->SetEcmaModuleRecordNameString("a");
3260    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3261    JSHandle<LocalExportEntry> localExportEntry =
3262        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
3263    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
3264    localExportEntries->Set(thread, 0, localExportEntry);
3265    module->SetLocalExportEntries(thread, localExportEntries);
3266    module->SetSharedType(SharedTypes::SHARED_MODULE);
3267    module->StoreModuleValue(thread, 0, val);
3268    EXPECT_TRUE(!thread->HasPendingException());
3269}
3270
3271HWTEST_F_L0(EcmaModuleTest, GetModuleValue1)
3272{
3273    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3274    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3275    module->GetModuleValue(thread, 0, true);
3276    EXPECT_TRUE(thread->HasPendingException());
3277}
3278
3279HWTEST_F_L0(EcmaModuleTest, ModuleExecution)
3280{
3281    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3282    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3283    JSHandle<TaggedArray> arr = objectFactory->NewTaggedArray(1);
3284    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3285    JSHandle<ImportEntry> importEntry = objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
3286    module->SetImportEntries(thread, arr);
3287    module->AddImportEntry(thread, module, importEntry, 2, 3);
3288    EXPECT_TRUE(!thread->HasPendingException());
3289}
3290
3291HWTEST_F_L0(EcmaModuleTest, AddAsyncParentModule)
3292{
3293    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3294    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
3295    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
3296    SourceTextModule::AddAsyncParentModule(thread, module1, module2);
3297    EXPECT_TRUE(!thread->HasPendingException());
3298    SourceTextModule::AddAsyncParentModule(thread, module1, module2);
3299    EXPECT_TRUE(!thread->HasPendingException());
3300}
3301
3302HWTEST_F_L0(EcmaModuleTest, AsyncModuleExecutionFulfilled)
3303{
3304    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3305    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3306    module->SetStatus(ModuleStatus::EVALUATED);
3307    module->SetEvaluationError(0);
3308    SourceTextModule::AsyncModuleExecutionFulfilled(thread, module);
3309    EXPECT_TRUE(!thread->HasPendingException());
3310
3311    SourceTextModule::AsyncModuleExecutionRejected(thread, module, JSTaggedValue::Exception());
3312    EXPECT_TRUE(!thread->HasPendingException());
3313}
3314
3315HWTEST_F_L0(EcmaModuleTest, GatherAvailableAncestors)
3316{
3317    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3318    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
3319    JSHandle<SourceTextModule> module2 = objectFactory->NewSourceTextModule();
3320    module2->SetPendingAsyncDependencies(1);
3321    module2->SetCycleRoot(thread, module2);
3322    SourceTextModule::AddAsyncParentModule(thread, module1, module2);
3323    SourceTextModule::AsyncParentCompletionSet execList1;
3324    module2->SetEvaluationError(0);
3325    SourceTextModule::GatherAvailableAncestors(thread, module1, execList1);
3326    EXPECT_TRUE(!thread->HasPendingException());
3327
3328    execList1.insert(module2);
3329    SourceTextModule::GatherAvailableAncestors(thread, module1, execList1);
3330    EXPECT_TRUE(!thread->HasPendingException());
3331
3332    module2->SetEvaluationError(SourceTextModule::UNDEFINED_INDEX);
3333    SourceTextModule::GatherAvailableAncestors(thread, module1, execList1);
3334    EXPECT_TRUE(!thread->HasPendingException());
3335
3336    SourceTextModule::AsyncParentCompletionSet execList2;
3337    module2->SetStatus(ModuleStatus::EVALUATING_ASYNC);
3338    module2->SetAsyncEvaluatingOrdinal(3);
3339    SourceTextModule::GatherAvailableAncestors(thread, module1, execList2);
3340    EXPECT_TRUE(!thread->HasPendingException());
3341
3342    SourceTextModule::AsyncParentCompletionSet execList3;
3343    module2->SetPendingAsyncDependencies(2);
3344    SourceTextModule::GatherAvailableAncestors(thread, module1, execList3);
3345    EXPECT_TRUE(!thread->HasPendingException());
3346
3347    module2->SetHasTLA(true);
3348    SourceTextModule::GatherAvailableAncestors(thread, module1, execList3);
3349    EXPECT_TRUE(!thread->HasPendingException());
3350}
3351
3352HWTEST_F_L0(EcmaModuleTest, ExecuteCjsModuleTest)
3353{
3354    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3355    CString baseFileName = "modules.abc";
3356    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3357    module->SetEcmaModuleFilenameString(baseFileName);
3358    CString recordName = "modules.abc";
3359    module->SetEcmaModuleRecordNameString(recordName);
3360    module->SetStatus(ModuleStatus::EVALUATED);
3361    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3362    moduleManager->AddResolveImportedModule(recordName, module.GetTaggedValue());
3363
3364    const char *data = R"(
3365        .language ECMAScript
3366        .function any func_main_0(any a0, any a1, any a2) {
3367            ldai 1
3368            return
3369        }
3370    )";
3371    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
3372    Parser parser;
3373    auto res = parser.Parse(data);
3374    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
3375    std::shared_ptr<JSPandaFile> jsPandaFile = pfManager->NewJSPandaFile(pfPtr.release(), baseFileName);
3376
3377    CString recordName2 = "testModule";
3378    moduleManager->ExecuteCjsModule(thread, recordName2, jsPandaFile.get());
3379    EXPECT_TRUE(!thread->HasPendingException());
3380}
3381
3382HWTEST_F_L0(EcmaModuleTest, ExecuteCjsModuleTest2)
3383{
3384    const char *fileName = "__JSPandaFileExecutorTest1.abc";
3385    const char *data = R"(
3386        .language ECMAScript
3387        .function any func_main_0(any a0, any a1, any a2) {
3388            ldai 1
3389            return
3390        }
3391    )";
3392    JSPandaFileManager *pfManager = JSPandaFileManager::GetInstance();
3393    Parser parser;
3394    auto res = parser.Parse(data);
3395    std::unique_ptr<const File> pfPtr = pandasm::AsmEmitter::Emit(res.Value());
3396    std::shared_ptr<JSPandaFile> pf = pfManager->NewJSPandaFile(pfPtr.release(), CString(fileName));
3397    const uint8_t *typeDesc = utf::CStringAsMutf8("L_GLOBAL;");
3398    const File *file = pf->GetPandaFile();
3399    File::EntityId classId = file->GetClassId(typeDesc);
3400    ClassDataAccessor cda(*file, classId);
3401    std::vector<File::EntityId> methodId {};
3402    cda.EnumerateMethods([&](panda_file::MethodDataAccessor &mda) {
3403        methodId.push_back(mda.GetMethodId());
3404    });
3405    pf->UpdateMainMethodIndex(methodId[0].GetOffset());
3406    MethodLiteral *method = new MethodLiteral(methodId[0]);
3407    method->Initialize(pf.get());
3408    pf->SetMethodLiteralToMap(method);
3409    pfManager->AddJSPandaFile(pf);
3410    CString recordName = "testModule";
3411    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3412    moduleManager->ExecuteCjsModule(thread, recordName, pf.get());
3413    EXPECT_TRUE(!thread->HasPendingException());
3414}
3415
3416
3417HWTEST_F_L0(EcmaModuleTest, GetLazyModuleValueOutter)
3418{
3419    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3420    CString baseFileName = "modules.abc";
3421    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3422    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3423    module->SetEcmaModuleFilenameString(baseFileName);
3424    CString recordName = "cjs";
3425    module->SetEcmaModuleRecordNameString(recordName);
3426    module->SetTypes(ModuleTypes::NATIVE_MODULE);
3427    module->SetStatus(ModuleStatus::EVALUATED);
3428    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3429    moduleManager->AddResolveImportedModule(recordName, module.GetTaggedValue());
3430    JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
3431    JSHandle<JSTaggedValue> resolution =
3432        JSHandle<JSTaggedValue>::Cast(objectFactory->NewResolvedBindingRecord(module, val));
3433    envRec->Set(thread, 0, resolution);
3434    module->SetEnvironment(thread, envRec);
3435    JSHandle<JSFunction> ctor(thread->GetEcmaVM()->GetGlobalEnv()->GetObjectFunction());
3436    ctor->SetModule(thread, module);
3437    JSTaggedValue jsFunc = ctor.GetTaggedValue();
3438    moduleManager->GetLazyModuleValueOutter(0, jsFunc);
3439    EXPECT_TRUE(thread->HasPendingException());
3440}
3441
3442HWTEST_F_L0(EcmaModuleTest, GetLazyModuleValueOutter2)
3443{
3444    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3445    CString baseFileName = "modules.abc";
3446    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3447    module->SetEcmaModuleFilenameString(baseFileName);
3448    CString recordName = "cjs";
3449    module->SetEcmaModuleRecordNameString(recordName);
3450    module->SetTypes(ModuleTypes::CJS_MODULE);
3451    module->SetStatus(ModuleStatus::EVALUATED);
3452    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3453    moduleManager->AddResolveImportedModule(recordName, module.GetTaggedValue());
3454
3455    JSHandle<JSFunction> ctor(thread->GetEcmaVM()->GetGlobalEnv()->GetObjectFunction());
3456    ctor->SetModule(thread, module);
3457    JSTaggedValue jsFunc = ctor.GetTaggedValue();
3458    moduleManager->GetLazyModuleValueOutter(0, jsFunc);
3459    EXPECT_TRUE(!thread->HasPendingException());
3460
3461    JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName);
3462    JSHandle<EcmaString> baseFileNameHdl = objectFactory->NewFromUtf8(baseFileName);
3463    JSHandle<ResolvedRecordIndexBinding> recordIndexBinding =
3464        objectFactory->NewSResolvedRecordIndexBindingRecord(recordNameHdl, baseFileNameHdl, 0);
3465    JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
3466    JSHandle<JSTaggedValue> resolution = JSHandle<JSTaggedValue>::Cast(recordIndexBinding);
3467    envRec->Set(thread, 0, resolution);
3468    module->SetEnvironment(thread, envRec);
3469    ctor->SetModule(thread, module);
3470    jsFunc = ctor.GetTaggedValue();
3471    moduleManager->GetLazyModuleValueOutter(0, jsFunc);
3472    EXPECT_TRUE(thread->HasPendingException());
3473}
3474
3475HWTEST_F_L0(EcmaModuleTest, GetLazyModuleValueOutter3)
3476{
3477    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3478    CString baseFileName = "modules.abc";
3479    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3480    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3481    module->SetEcmaModuleFilenameString(baseFileName);
3482    CString recordName = "cjs";
3483    module->SetEcmaModuleRecordNameString(recordName);
3484    module->SetTypes(ModuleTypes::CJS_MODULE);
3485    module->SetStatus(ModuleStatus::EVALUATED);
3486    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3487    moduleManager->AddResolveImportedModule(recordName, module.GetTaggedValue());
3488    JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName);
3489    JSHandle<ResolvedRecordBinding> nameBinding =
3490        objectFactory->NewSResolvedRecordBindingRecord(recordNameHdl, val);
3491
3492    JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
3493    JSHandle<JSTaggedValue> resolution = JSHandle<JSTaggedValue>::Cast(nameBinding);
3494    envRec->Set(thread, 0, resolution);
3495    module->SetEnvironment(thread, envRec);
3496    JSHandle<JSFunction> ctor(thread->GetEcmaVM()->GetGlobalEnv()->GetObjectFunction());
3497    ctor->SetModule(thread, module);
3498    JSTaggedValue jsFunc = ctor.GetTaggedValue();
3499    moduleManager->GetLazyModuleValueOutter(0, jsFunc);
3500    EXPECT_TRUE(thread->HasPendingException());
3501}
3502
3503HWTEST_F_L0(EcmaModuleTest, GetModuleValueOutter1)
3504{
3505    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3506    CString baseFileName = "modules.abc";
3507    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3508    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3509    module->SetEcmaModuleFilenameString(baseFileName);
3510    CString recordName = "cjs";
3511    module->SetEcmaModuleRecordNameString(recordName);
3512    module->SetTypes(ModuleTypes::NATIVE_MODULE);
3513    module->SetStatus(ModuleStatus::EVALUATED);
3514    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3515    moduleManager->AddResolveImportedModule(recordName, module.GetTaggedValue());
3516    JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
3517    JSHandle<JSTaggedValue> resolution =
3518        JSHandle<JSTaggedValue>::Cast(objectFactory->NewResolvedBindingRecord(module, val));
3519    envRec->Set(thread, 0, resolution);
3520    module->SetEnvironment(thread, envRec);
3521    JSHandle<JSFunction> ctor(thread->GetEcmaVM()->GetGlobalEnv()->GetObjectFunction());
3522    ctor->SetModule(thread, module);
3523    JSTaggedValue jsFunc = ctor.GetTaggedValue();
3524    moduleManager->GetModuleValueOutter(0, jsFunc);
3525    EXPECT_TRUE(thread->HasPendingException());
3526}
3527
3528HWTEST_F_L0(EcmaModuleTest, GetModuleValueOutter2)
3529{
3530    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3531    CString baseFileName = "modules.abc";
3532    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3533    module->SetEcmaModuleFilenameString(baseFileName);
3534    CString recordName = "cjs";
3535    module->SetEcmaModuleRecordNameString(recordName);
3536    module->SetTypes(ModuleTypes::CJS_MODULE);
3537    module->SetStatus(ModuleStatus::EVALUATED);
3538    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3539    moduleManager->AddResolveImportedModule(recordName, module.GetTaggedValue());
3540    EXPECT_TRUE(!thread->HasPendingException());
3541
3542    JSHandle<JSFunction> ctor(thread->GetEcmaVM()->GetGlobalEnv()->GetObjectFunction());
3543    ctor->SetModule(thread, module);
3544    JSTaggedValue jsFunc = ctor.GetTaggedValue();
3545    moduleManager->GetModuleValueOutter(0, jsFunc);
3546
3547    JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName);
3548    JSHandle<EcmaString> baseFileNameHdl = objectFactory->NewFromUtf8(baseFileName);
3549    JSHandle<ResolvedRecordIndexBinding> recordIndexBinding =
3550        objectFactory->NewSResolvedRecordIndexBindingRecord(recordNameHdl, baseFileNameHdl, 0);
3551    JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
3552    JSHandle<JSTaggedValue> resolution = JSHandle<JSTaggedValue>::Cast(recordIndexBinding);
3553    envRec->Set(thread, 0, resolution);
3554    module->SetEnvironment(thread, envRec);
3555    ctor->SetModule(thread, module);
3556    jsFunc = ctor.GetTaggedValue();
3557    moduleManager->GetModuleValueOutter(0, jsFunc);
3558    EXPECT_TRUE(thread->HasPendingException());
3559}
3560
3561HWTEST_F_L0(EcmaModuleTest, GetModuleValueOutter3)
3562{
3563    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3564    CString baseFileName = "modules.abc";
3565    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3566    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3567    module->SetEcmaModuleFilenameString(baseFileName);
3568    CString recordName = "cjs";
3569    module->SetEcmaModuleRecordNameString(recordName);
3570    module->SetTypes(ModuleTypes::CJS_MODULE);
3571    module->SetStatus(ModuleStatus::EVALUATED);
3572    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3573    moduleManager->AddResolveImportedModule(recordName, module.GetTaggedValue());
3574    JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName);
3575    JSHandle<ResolvedRecordBinding> nameBinding =
3576        objectFactory->NewSResolvedRecordBindingRecord(recordNameHdl, val);
3577
3578    JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
3579    JSHandle<JSTaggedValue> resolution = JSHandle<JSTaggedValue>::Cast(nameBinding);
3580    envRec->Set(thread, 0, resolution);
3581    module->SetEnvironment(thread, envRec);
3582    JSHandle<JSFunction> ctor(thread->GetEcmaVM()->GetGlobalEnv()->GetObjectFunction());
3583    ctor->SetModule(thread, module);
3584    JSTaggedValue jsFunc = ctor.GetTaggedValue();
3585    moduleManager->GetModuleValueOutter(0, jsFunc);
3586    EXPECT_TRUE(thread->HasPendingException());
3587}
3588
3589HWTEST_F_L0(EcmaModuleTest, GetSendableModuleValueImpl2) {
3590    SharedModuleManager* manager = SharedModuleManager::GetInstance();
3591    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3592    CString baseFileName = "modules.abc";
3593    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3594    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3595    module->SetEcmaModuleFilenameString(baseFileName);
3596    CString recordName = "cjs";
3597    module->SetEcmaModuleRecordNameString(recordName);
3598    module->SetTypes(ModuleTypes::CJS_MODULE);
3599    module->SetStatus(ModuleStatus::EVALUATED);
3600    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3601    moduleManager->AddResolveImportedModule(recordName, module.GetTaggedValue());
3602    JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName);
3603    JSHandle<ResolvedRecordBinding> nameBinding =
3604        objectFactory->NewSResolvedRecordBindingRecord(recordNameHdl, val);
3605    JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
3606    JSHandle<JSTaggedValue> resolution = JSHandle<JSTaggedValue>::Cast(nameBinding);
3607    envRec->Set(thread, 0, resolution);
3608    module->SetEnvironment(thread, envRec);
3609    manager->GetSendableModuleValueImpl(thread, 0, module.GetTaggedValue());
3610    EXPECT_TRUE(thread->HasPendingException());
3611}
3612
3613HWTEST_F_L0(EcmaModuleTest, GetLazySendableModuleValueImpl2) {
3614    SharedModuleManager* manager = SharedModuleManager::GetInstance();
3615    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3616    CString baseFileName = "modules.abc";
3617    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3618    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3619    module->SetEcmaModuleFilenameString(baseFileName);
3620    CString recordName = "cjs";
3621    module->SetEcmaModuleRecordNameString(recordName);
3622    module->SetTypes(ModuleTypes::CJS_MODULE);
3623    module->SetStatus(ModuleStatus::EVALUATED);
3624    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3625    moduleManager->AddResolveImportedModule(recordName, module.GetTaggedValue());
3626    JSHandle<EcmaString> recordNameHdl = objectFactory->NewFromUtf8(recordName);
3627    JSHandle<ResolvedRecordBinding> nameBinding =
3628        objectFactory->NewSResolvedRecordBindingRecord(recordNameHdl, val);
3629    JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
3630    JSHandle<JSTaggedValue> resolution = JSHandle<JSTaggedValue>::Cast(nameBinding);
3631    envRec->Set(thread, 0, resolution);
3632    module->SetEnvironment(thread, envRec);
3633    manager->GetLazySendableModuleValueImpl(thread, 0, module.GetTaggedValue());
3634    EXPECT_TRUE(thread->HasPendingException());
3635}
3636
3637HWTEST_F_L0(EcmaModuleTest, GenerateSendableFuncModule2)
3638{
3639    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3640    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3641    module->SetTypes(ModuleTypes::NATIVE_MODULE);
3642    JSHandle<JSTaggedValue> moduleRecord = JSHandle<JSTaggedValue>::Cast(module);
3643    SendableClassModule::GenerateSendableFuncModule(thread, moduleRecord);
3644    JSHandle<SourceTextModule> currentModule = JSHandle<SourceTextModule>::Cast(moduleRecord);
3645    EXPECT_FALSE(SourceTextModule::IsModuleInSharedHeap(currentModule));
3646}
3647
3648HWTEST_F_L0(EcmaModuleTest, CloneEnvForSModule1)
3649{
3650    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3651    JSHandle<SourceTextModule> module1 = objectFactory->NewSourceTextModule();
3652    CString baseFileName = "modules.abc";
3653    module1->SetEcmaModuleFilenameString(baseFileName);
3654    CString recordName1 = "a";
3655    module1->SetEcmaModuleRecordNameString(recordName1);
3656    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3657    JSHandle<ImportEntry> importEntry =
3658        objectFactory->NewImportEntry(val, val, val, SharedTypes::UNSENDABLE_MODULE);
3659    SourceTextModule::AddImportEntry(thread, module1, importEntry, 0, 1);
3660    JSHandle<TaggedArray> envRec = objectFactory->NewTaggedArray(1);
3661    JSHandle<JSTaggedValue> resolution = JSHandle<JSTaggedValue>::Cast(
3662        objectFactory->NewResolvedBindingRecord(module1, val));
3663    envRec->Set(thread, 0, resolution);
3664    module1->SetEnvironment(thread, envRec);
3665    module1->SetTypes(ModuleTypes::NATIVE_MODULE);
3666    JSHandle<TaggedArray> elements = JSSharedModule::CloneEnvForSModule(thread, module1, envRec);
3667    EXPECT_TRUE(elements->GetLength() == 1U);
3668}
3669
3670HWTEST_F_L0(EcmaModuleTest, InsertInSModuleManager) {
3671    SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
3672    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3673    JSHandle<SourceTextModule> module1 = objectFactory->NewSSourceTextModule();
3674    CString recordName = "test";
3675    module1->SetEcmaModuleRecordNameString(recordName);
3676    manager1->InsertInSModuleManager(thread, recordName, module1);
3677    EXPECT_FALSE(thread->HasPendingException());
3678}
3679
3680HWTEST_F_L0(EcmaModuleTest, findModuleMutexWithLock) {
3681    SharedModuleManager* manager1 = SharedModuleManager::GetInstance();
3682    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3683    JSHandle<SourceTextModule> module1 = objectFactory->NewSSourceTextModule();
3684    std::string baseFileNameStr = MODULE_ABC_PATH "module_unexecute.abc";
3685    CString baseFileName = baseFileNameStr.c_str();
3686    module1->SetEcmaModuleFilenameString(baseFileName);
3687    CString recordName1 = "module_unexecute";
3688    module1->SetEcmaModuleRecordNameString(recordName1);
3689    manager1->InsertInSModuleManager(thread, recordName1, module1);
3690    manager1->findModuleMutexWithLock(thread, module1);
3691    EXPECT_FALSE(thread->HasPendingException());
3692}
3693
3694HWTEST_F_L0(EcmaModuleTest, GetRecordName3)
3695{
3696    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_module_base.abc";
3697
3698    JSNApi::EnableUserUncaughtErrorHandler(instance);
3699
3700    int arkProperties = thread->GetEcmaVM()->GetJSOptions().GetArkProperties();
3701    thread->GetEcmaVM()->GetJSOptions().SetArkProperties(arkProperties | ArkProperties::ENABLE_ESM_TRACE);
3702    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_module_base");
3703    EXPECT_TRUE(result);
3704}
3705
3706HWTEST_F_L0(EcmaModuleTest, GetExportObjectIndex3)
3707{
3708    ThreadNativeScope nativeScope(thread);
3709    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
3710
3711    JSNApi::EnableUserUncaughtErrorHandler(instance);
3712
3713    ModuleLogger *moduleLogger = new ModuleLogger(thread->GetEcmaVM());
3714    thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
3715    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
3716    JSNApi::GetExportObject(instance, "module_test_module_test_B", "a");
3717    EXPECT_TRUE(result);
3718    thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
3719    delete moduleLogger;
3720}
3721
3722HWTEST_F_L0(EcmaModuleTest, GetModuleValueOutterInternal2)
3723{
3724    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
3725    JSNApi::EnableUserUncaughtErrorHandler(instance);
3726    int arkProperties = thread->GetEcmaVM()->GetJSOptions().GetArkProperties();
3727    thread->GetEcmaVM()->GetJSOptions().SetArkProperties(arkProperties | ArkProperties::ENABLE_ESM_TRACE);
3728    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
3729    EXPECT_TRUE(result);
3730}
3731
3732HWTEST_F_L0(EcmaModuleTest, RemoveModule)
3733{
3734    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
3735    JSNApi::EnableUserUncaughtErrorHandler(instance);
3736    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
3737    EXPECT_TRUE(result);
3738    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3739    thread->GetEcmaVM()->GetJSOptions().SetIsWorker(false);
3740
3741    JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
3742    module->SetTypes(ModuleTypes::APP_MODULE);
3743
3744    JSHandle<JSTaggedValue> res = moduleManager->TryGetImportedModule("module_test_module_test_C");
3745    EXPECT_NE(res, thread->GlobalConstants()->GetHandledUndefined());
3746    ModuleDeregister::RemoveModule(thread, module);
3747
3748    res = moduleManager->TryGetImportedModule("module_test_module_test_C");
3749    EXPECT_EQ(res, thread->GlobalConstants()->GetHandledUndefined());
3750}
3751
3752HWTEST_F_L0(EcmaModuleTest, RemoveModule2)
3753{
3754    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
3755    JSNApi::EnableUserUncaughtErrorHandler(instance);
3756    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
3757    EXPECT_TRUE(result);
3758    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3759    thread->GetEcmaVM()->GetJSOptions().SetIsWorker(false);
3760
3761    JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
3762    module->SetTypes(ModuleTypes::OHOS_MODULE);
3763
3764    JSHandle<JSTaggedValue> res = moduleManager->TryGetImportedModule("module_test_module_test_C");
3765    EXPECT_NE(res, thread->GlobalConstants()->GetHandledUndefined());
3766    ModuleDeregister::RemoveModule(thread, module);
3767
3768    res = moduleManager->TryGetImportedModule("module_test_module_test_C");
3769    EXPECT_EQ(res, thread->GlobalConstants()->GetHandledUndefined());
3770}
3771
3772HWTEST_F_L0(EcmaModuleTest, IsEvaluatedModule)
3773{
3774    std::string baseFileName = MODULE_ABC_PATH "module_test_module_test_C.abc";
3775    JSNApi::EnableUserUncaughtErrorHandler(instance);
3776    bool result = JSNApi::Execute(instance, baseFileName, "module_test_module_test_C");
3777    EXPECT_TRUE(result);
3778    ModuleManager *moduleManager = thread->GetCurrentEcmaContext()->GetModuleManager();
3779    JSHandle<SourceTextModule> module = moduleManager->HostGetImportedModule("module_test_module_test_C");
3780    StateVisit stateVisit;
3781    bool res = SourceTextModule::IsEvaluatedModule(thread, stateVisit, module);
3782    EXPECT_TRUE(res);
3783}
3784
3785HWTEST_F_L0(EcmaModuleTest, ResolveNativeStarExport2)
3786{
3787    ObjectFactory *objectFactory = thread->GetEcmaVM()->GetFactory();
3788    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3789    CString recordName = "@ohos:hilog";
3790    module->SetEcmaModuleRecordNameString(recordName);
3791    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3792    JSHandle<LocalExportEntry> localExportEntry =
3793        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
3794    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
3795    localExportEntries->Set(thread, 0, localExportEntry);
3796    module->SetLocalExportEntries(thread, localExportEntries);
3797    module->StoreModuleValue(thread, 0, val);
3798    module->SetTypes(ModuleTypes::NATIVE_MODULE);
3799
3800    int arkProperties = thread->GetEcmaVM()->GetJSOptions().GetArkProperties();
3801    thread->GetEcmaVM()->GetJSOptions().SetArkProperties(arkProperties | ArkProperties::ENABLE_ESM_TRACE);
3802    JSHandle<JSTaggedValue> res1 = SourceTextModule::ResolveNativeStarExport(thread, module, val);
3803    EXPECT_TRUE(res1->IsNull());
3804}
3805
3806HWTEST_F_L0(EcmaModuleTest, LoadNativeModuleImpl2)
3807{
3808    auto vm = thread->GetEcmaVM();
3809    ObjectFactory *objectFactory = vm->GetFactory();
3810    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3811    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3812    JSHandle<LocalExportEntry> localExportEntry =
3813        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
3814    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
3815    localExportEntries->Set(thread, 0, localExportEntry);
3816    module->SetLocalExportEntries(thread, localExportEntries);
3817    module->StoreModuleValue(thread, 0, val);
3818    module->SetTypes(ModuleTypes::NATIVE_MODULE);
3819    ModuleLogger *moduleLogger = new ModuleLogger(vm);
3820    thread->GetCurrentEcmaContext()->SetModuleLogger(moduleLogger);
3821
3822    // internal module
3823    Local<ObjectRef> globalObject = JSNApi::GetGlobalObject(vm);
3824    globalObject->Set(vm, StringRef::NewFromUtf8(vm, "requireNapi"),
3825        FunctionRef::New(const_cast<panda::EcmaVM*>(vm), MockRequireNapiUndefined));
3826    module->SetEcmaModuleRecordNameString("@hms:xxxxx");
3827    int arkProperties = thread->GetEcmaVM()->GetJSOptions().GetArkProperties();
3828    thread->GetEcmaVM()->GetJSOptions().SetArkProperties(arkProperties | ArkProperties::ENABLE_ESM_TRACE);
3829    SourceTextModule::LoadNativeModuleImpl(vm, thread, module, ModuleTypes::INTERNAL_MODULE);
3830    EXPECT_TRUE(!thread->HasPendingException());
3831    thread->GetCurrentEcmaContext()->SetModuleLogger(nullptr);
3832    delete moduleLogger;
3833}
3834
3835HWTEST_F_L0(EcmaModuleTest, LoadNativeModule3)
3836{
3837    auto vm = thread->GetEcmaVM();
3838    ObjectFactory *objectFactory = vm->GetFactory();
3839    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3840    JSHandle<JSTaggedValue> val = JSHandle<JSTaggedValue>::Cast(objectFactory->NewFromUtf8("val"));
3841    JSHandle<LocalExportEntry> localExportEntry =
3842        objectFactory->NewLocalExportEntry(val, val, 0, SharedTypes::UNSENDABLE_MODULE);
3843    JSHandle<TaggedArray> localExportEntries = objectFactory->NewTaggedArray(1);
3844    localExportEntries->Set(thread, 0, localExportEntry);
3845    module->SetEcmaModuleRecordNameString("@app:bundleName/moduleName/lib*.so");
3846    module->SetLocalExportEntries(thread, localExportEntries);
3847    module->StoreModuleValue(thread, 0, val);
3848    module->SetTypes(ModuleTypes::NATIVE_MODULE);
3849    Local<JSValueRef> requireNapi = StringRef::NewFromUtf8(vm, "requireNapi");
3850    Local<ObjectRef> globalObject = JSNApi::GetGlobalObject(vm);
3851    globalObject->Set(vm, requireNapi, FunctionRef::New(const_cast<panda::EcmaVM*>(vm), MockRequireNapiValue));
3852    int arkProperties = thread->GetEcmaVM()->GetJSOptions().GetArkProperties();
3853    thread->GetEcmaVM()->GetJSOptions().SetArkProperties(arkProperties | ArkProperties::ENABLE_ESM_TRACE);
3854    SourceTextModule::LoadNativeModule(thread, module, ModuleTypes::APP_MODULE);
3855    EXPECT_TRUE(!thread->HasPendingException());
3856}
3857
3858HWTEST_F_L0(EcmaModuleTest, EvaluateForConcurrent)
3859{
3860    // Mock create sendable function
3861    auto objectFactory = thread->GetEcmaVM()->GetFactory();
3862    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3863
3864    uint32_t methodOffset = 100;
3865    MethodLiteral *methodLiteral = new MethodLiteral(EntityId(methodOffset));
3866    methodLiteral->SetIsShared(true);
3867    JSHandle<Method> method = objectFactory->NewSMethod(methodLiteral);
3868
3869    module->SetStatus(ModuleStatus::INSTANTIATED);
3870    int res = SourceTextModule::EvaluateForConcurrent(thread, module, method);
3871    EXPECT_EQ(res, SourceTextModule::UNDEFINED_INDEX);
3872
3873    module->SetStatus(ModuleStatus::EVALUATED);
3874    res = SourceTextModule::EvaluateForConcurrent(thread, module, method);
3875    EXPECT_EQ(res, SourceTextModule::UNDEFINED_INDEX);
3876
3877    JSHandle<JSObject> error = objectFactory->GetJSError(
3878        base::ErrorType::RANGE_ERROR, "Stack overflow!", StackCheck::NO);
3879    thread->SetException(error.GetTaggedValue());
3880    res = SourceTextModule::EvaluateForConcurrent(thread, module, method);
3881    EXPECT_EQ(res, 0);
3882}
3883
3884HWTEST_F_L0(EcmaModuleTest, ModuleDeclarationArrayEnvironmentSetup2)
3885{
3886    auto vm = thread->GetEcmaVM();
3887    ObjectFactory *objectFactory = vm->GetFactory();
3888    JSHandle<SourceTextModule> module = objectFactory->NewSourceTextModule();
3889    int arkProperties = thread->GetEcmaVM()->GetJSOptions().GetArkProperties();
3890    thread->GetEcmaVM()->GetJSOptions().SetArkProperties(arkProperties | ArkProperties::ENABLE_ESM_TRACE);
3891    SourceTextModule::ModuleDeclarationArrayEnvironmentSetup(thread, module);
3892    EXPECT_TRUE(!thread->HasPendingException());
3893
3894    module->SetStatus(ModuleStatus::EVALUATED);
3895    SourceTextModule::ModuleDeclarationArrayEnvironmentSetup(thread, module);
3896    EXPECT_TRUE(!thread->HasPendingException());
3897}
3898}  // namespace panda::test
3899