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