1 /*
2  * Copyright (c) 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 #include "ecmascript/ecma_vm.h"
16 #include "ecmascript/global_env.h"
17 #include "ecmascript/js_map.h"
18 #include "ecmascript/js_array.h"
19 #include "ecmascript/js_hclass.h"
20 #include "ecmascript/js_iterator.h"
21 #include "ecmascript/js_tagged_value-inl.h"
22 #include "ecmascript/tests/test_helper.h"
23 #include "ecmascript/builtins/builtins_async_generator.h"
24 #include "ecmascript/builtins/builtins_shared_map.h"
25 #include "ecmascript/linked_hash_table.h"
26 #include "ecmascript/shared_objects/js_shared_map.h"
27 #include "ecmascript/shared_objects/js_shared_map_iterator.h"
28 
29 using namespace panda::ecmascript;
30 using namespace panda::ecmascript::builtins;
31 
32 namespace panda::test {
33 using BuiltinsSharedMap = ecmascript::builtins::BuiltinsSharedMap;
34 
35 class BuiltinsSharedMapTest : public BaseTestWithScope<false> {
36 public:
37     class TestClass : public base::BuiltinsBase {
38     public:
TestFunc(EcmaRuntimeCallInfo *argv)39         static JSTaggedValue TestFunc(EcmaRuntimeCallInfo *argv)
40         {
41             int num = GetCallArg(argv, 0)->GetInt();
42             JSArray *jsArray = JSArray::Cast(GetThis(argv)->GetTaggedObject());
43             int length = jsArray->GetArrayLength() + num;
44             jsArray->SetArrayLength(argv->GetThread(), length);
45             return JSTaggedValue::Undefined();
46         }
47     };
48 };
49 
CreateSBuiltinsMap(JSThread *thread)50 JSSharedMap *CreateSBuiltinsMap(JSThread *thread)
51 {
52     JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
53     JSHandle<JSFunction> newTarget(env->GetSBuiltininMapFunction());
54     // 4 : test case
55     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*newTarget), 4);
56     ecmaRuntimeCallInfo->SetFunction(newTarget.GetTaggedValue());
57     ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
58 
59     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
60     JSTaggedValue result = BuiltinsSharedMap::Constructor(ecmaRuntimeCallInfo);
61     TestHelper::TearDownFrame(thread, prev);
62 
63     EXPECT_TRUE(result.IsECMAObject());
64     JSSharedMap *jsSMap = JSSharedMap::Cast(reinterpret_cast<TaggedObject *>(result.GetRawData()));
65     return jsSMap;
66 }
67 
68 
HWTEST_F_L0(BuiltinsSharedMapTest, CreateAndGetSize)69 HWTEST_F_L0(BuiltinsSharedMapTest, CreateAndGetSize)
70 {
71     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
72     JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
73     JSHandle<JSFunction> newTarget(env->GetSBuiltininMapFunction());
74     JSHandle<JSSharedMap> map(thread, CreateSBuiltinsMap(thread));
75 
76     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
77     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
78     ecmaRuntimeCallInfo->SetThis(map.GetTaggedValue());
79     ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Undefined());
80 
81     {
82         [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
83         JSTaggedValue result = BuiltinsSharedMap::GetSize(ecmaRuntimeCallInfo);
84         TestHelper::TearDownFrame(thread, prev);
85 
86         EXPECT_EQ(result.GetRawData(), JSTaggedValue(0).GetRawData());
87     }
88     JSHandle<TaggedArray> array(factory->NewTaggedArray(5));
89     for (int i = 0; i < 5; i++) {
90         JSHandle<TaggedArray> internalArray(factory->NewTaggedArray(2));
91         internalArray->Set(thread, 0, JSTaggedValue(i));
92         internalArray->Set(thread, 1, JSTaggedValue(i));
93         auto arr = JSArray::CreateArrayFromList(thread, internalArray);
94         array->Set(thread, i, arr);
95     }
96     JSHandle<JSArray> values = JSArray::CreateArrayFromList(thread, array);
97     auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
98     ecmaRuntimeCallInfo1->SetFunction(newTarget.GetTaggedValue());
99     ecmaRuntimeCallInfo1->SetThis(map.GetTaggedValue());
100     ecmaRuntimeCallInfo1->SetCallArg(0, values.GetTaggedValue());
101     ecmaRuntimeCallInfo1->SetNewTarget(newTarget.GetTaggedValue());
102     {
103         [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
104         JSTaggedValue result1 = BuiltinsSharedMap::Constructor(ecmaRuntimeCallInfo1);
105         TestHelper::TearDownFrame(thread, prev);
106         JSHandle<JSSharedMap> map1(thread, JSSharedMap::Cast(reinterpret_cast<TaggedObject *>(result1.GetRawData())));
107         EXPECT_EQ(JSSharedMap::GetSize(thread, map1), 5);
108     }
109 }
110 
111 
HWTEST_F_L0(BuiltinsSharedMapTest, GetKeyTest001)112 HWTEST_F_L0(BuiltinsSharedMapTest, GetKeyTest001)
113 {
114     constexpr uint32_t NODE_NUMBERS = 8;
115     JSHandle<JSSharedMap> map(thread, CreateSBuiltinsMap(thread));
116     for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
117         auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
118         callInfo->SetFunction(JSTaggedValue::Undefined());
119         callInfo->SetThis(map.GetTaggedValue());
120         callInfo->SetCallArg(0, JSTaggedValue(i));
121         callInfo->SetCallArg(1, JSTaggedValue(i));
122 
123         [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
124         JSTaggedValue result = BuiltinsSharedMap::Set(callInfo);
125         TestHelper::TearDownFrame(thread, prev);
126         EXPECT_TRUE(result.IsJSSharedMap());
127         JSHandle<JSSharedMap> jsSMap(thread, JSSharedMap::Cast(reinterpret_cast<TaggedObject *>(result.GetRawData())));
128         EXPECT_EQ(JSSharedMap::GetSize(thread, jsSMap), i + 1);
129     }
130     JSTaggedValue result = JSSharedMap::GetKey(thread, map, 0);
131     EXPECT_NE(result.GetRawData(), JSTaggedValue::Exception().GetRawData());
132 }
133 
HWTEST_F_L0(BuiltinsSharedMapTest, GetValueTest001)134 HWTEST_F_L0(BuiltinsSharedMapTest, GetValueTest001)
135 {
136     constexpr uint32_t NODE_NUMBERS = 8;
137     JSHandle<JSSharedMap> map(thread, CreateSBuiltinsMap(thread));
138     for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
139         auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
140         callInfo->SetFunction(JSTaggedValue::Undefined());
141         callInfo->SetThis(map.GetTaggedValue());
142         callInfo->SetCallArg(0, JSTaggedValue(i));
143         callInfo->SetCallArg(1, JSTaggedValue(i));
144 
145         [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
146         JSTaggedValue result = BuiltinsSharedMap::Set(callInfo);
147         TestHelper::TearDownFrame(thread, prev);
148         EXPECT_TRUE(result.IsJSSharedMap());
149         JSHandle<JSSharedMap> jsSMap(thread, JSSharedMap::Cast(reinterpret_cast<TaggedObject *>(result.GetRawData())));
150         EXPECT_EQ(JSSharedMap::GetSize(thread, jsSMap), i + 1);
151     }
152     JSTaggedValue result = JSSharedMap::GetValue(thread, map, 0);
153     EXPECT_NE(result.GetRawData(), JSTaggedValue::Exception().GetRawData());
154 }
155 
HWTEST_F_L0(BuiltinsSharedMapTest, DeleteTest001)156 HWTEST_F_L0(BuiltinsSharedMapTest, DeleteTest001)
157 {
158     JSHandle<JSSharedMap> map(thread, CreateSBuiltinsMap(thread));
159     JSHandle<JSTaggedValue> key(thread, JSTaggedValue(10));
160     bool result = JSSharedMap::Delete(thread, map, key);
161     ASSERT_EQ(result, false);
162 }
163 
164 enum class AlgorithmType {
165     SET,
166     FOR_EACH,
167     HAS,
168 };
169 
MapAlgorithm(JSThread *thread, JSTaggedValue thisArg, std::vector<JSTaggedValue>& args, int32_t argLen, AlgorithmType type)170 JSTaggedValue MapAlgorithm(JSThread *thread, JSTaggedValue thisArg, std::vector<JSTaggedValue>& args,
171     int32_t argLen, AlgorithmType type)
172 {
173     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), argLen);
174     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
175     ecmaRuntimeCallInfo->SetThis(thisArg);
176     for (size_t i = 0; i < args.size(); i++) {
177         ecmaRuntimeCallInfo->SetCallArg(i, args[i]);
178     }
179     auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
180     JSTaggedValue result;
181     switch (type) {
182         case AlgorithmType::SET:
183             result = BuiltinsSharedMap::Set(ecmaRuntimeCallInfo);
184             break;
185         case AlgorithmType::FOR_EACH:
186             result = BuiltinsSharedMap::ForEach(ecmaRuntimeCallInfo);
187             break;
188         case AlgorithmType::HAS:
189             result = BuiltinsSharedMap::Has(ecmaRuntimeCallInfo);
190             break;
191         default:
192             break;
193     }
194     TestHelper::TearDownFrame(thread, prev);
195     return result;
196 }
197 
HWTEST_F_L0(BuiltinsSharedMapTest, SetAndHas)198 HWTEST_F_L0(BuiltinsSharedMapTest, SetAndHas)
199 {
200     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
201     // create jsSMap
202     JSHandle<JSSharedMap> map(thread, CreateSBuiltinsMap(thread));
203     JSHandle<JSTaggedValue> key(factory->NewFromASCII("key"));
204 
205     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
206     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
207     ecmaRuntimeCallInfo->SetThis(map.GetTaggedValue());
208     ecmaRuntimeCallInfo->SetCallArg(0, key.GetTaggedValue());
209     ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
210 
211     // JSSharedMap *jsSMap;
212     {
213         [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
214         JSTaggedValue result1 = BuiltinsSharedMap::Has(ecmaRuntimeCallInfo);
215 
216         EXPECT_EQ(result1.GetRawData(), JSTaggedValue::False().GetRawData());
217 
218         // test Set()
219         JSTaggedValue result2 = BuiltinsSharedMap::Set(ecmaRuntimeCallInfo);
220 
221         EXPECT_TRUE(result2.IsECMAObject());
222         JSHandle<JSSharedMap> jsSMap(thread, JSSharedMap::Cast(reinterpret_cast<TaggedObject *>(result2.GetRawData())));
223         EXPECT_EQ(JSSharedMap::GetSize(thread, jsSMap), 1);
224 
225         std::vector<JSTaggedValue> args{key.GetTaggedValue(), JSTaggedValue(static_cast<int32_t>(1))}; // 1:value
226         auto result3 = MapAlgorithm(thread, jsSMap.GetTaggedValue(), args, 8, AlgorithmType::HAS); // 8: arg len
227         EXPECT_EQ(result3.GetRawData(), JSTaggedValue::True().GetRawData());
228     }
229 }
230 
HWTEST_F_L0(BuiltinsSharedMapTest, SetAndGet)231 HWTEST_F_L0(BuiltinsSharedMapTest, SetAndGet)
232 {
233     constexpr uint32_t NODE_NUMBERS = 8;
234     JSHandle<JSSharedMap> map(thread, CreateSBuiltinsMap(thread));
235     for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
236         auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
237         callInfo->SetFunction(JSTaggedValue::Undefined());
238         callInfo->SetThis(map.GetTaggedValue());
239         callInfo->SetCallArg(0, JSTaggedValue(i));
240         callInfo->SetCallArg(1, JSTaggedValue(i));
241 
242         [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
243         JSTaggedValue result = BuiltinsSharedMap::Set(callInfo);
244         TestHelper::TearDownFrame(thread, prev);
245         EXPECT_TRUE(result.IsJSSharedMap());
246         JSHandle<JSSharedMap> jsSMap(thread, JSSharedMap::Cast(reinterpret_cast<TaggedObject *>(result.GetRawData())));
247         EXPECT_EQ(JSSharedMap::GetSize(thread, jsSMap), i + 1);
248     }
249 
250     for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
251         auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
252         callInfo->SetFunction(JSTaggedValue::Undefined());
253         callInfo->SetThis(map.GetTaggedValue());
254         callInfo->SetCallArg(0, JSTaggedValue(i));
255 
256         [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
257         JSTaggedValue result = BuiltinsSharedMap::Get(callInfo);
258         TestHelper::TearDownFrame(thread, prev);
259         EXPECT_EQ(result, JSTaggedValue(i));
260     }
261 }
262 
HWTEST_F_L0(BuiltinsSharedMapTest, ForEach)263 HWTEST_F_L0(BuiltinsSharedMapTest, ForEach)
264 {
265     // generate a map has 5 entries{key1:0,key2:1,key3:2,key4:3,key5:4}
266     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
267     JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
268     JSHandle<JSSharedMap> map(thread, CreateSBuiltinsMap(thread));
269     char keyArray[] = "key0";
270     for (uint32_t i = 0; i < 5; i++) {
271         keyArray[3] = '1' + i;
272         JSHandle<JSTaggedValue> key(factory->NewFromASCII(keyArray));
273         std::vector<JSTaggedValue> args{key.GetTaggedValue(), JSTaggedValue(static_cast<int32_t>(i))};
274         auto result1 = MapAlgorithm(thread, map.GetTaggedValue(), args, 8, AlgorithmType::SET);
275 
276         EXPECT_TRUE(result1.IsECMAObject());
277         JSHandle<JSSharedMap> jsSMap(thread, JSSharedMap::Cast(reinterpret_cast<TaggedObject *>(result1.GetRawData())));
278         EXPECT_EQ(JSSharedMap::GetSize(thread, jsSMap), static_cast<int>(i) + 1);
279     }
280     JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
281     JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFunc));
282 
283     std::vector<JSTaggedValue> args{func.GetTaggedValue(), jsArray.GetTaggedValue()};
284     auto result2 = MapAlgorithm(thread, map.GetTaggedValue(), args, 8, AlgorithmType::FOR_EACH);
285 
286     EXPECT_EQ(result2.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
287     EXPECT_EQ(jsArray->GetArrayLength(), 10U);
288 }
289 
HWTEST_F_L0(BuiltinsSharedMapTest, DeleteAndRemove)290 HWTEST_F_L0(BuiltinsSharedMapTest, DeleteAndRemove)
291 {
292     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
293     // create jsSMap
294     JSHandle<JSSharedMap> map(thread, CreateSBuiltinsMap(thread));
295 
296     // add 40 keys
297     char keyArray[] = "key0";
298     for (uint32_t i = 0; i < 40; i++) {
299         keyArray[3] = '1' + i;
300         JSHandle<JSTaggedValue> key(thread, factory->NewFromASCII(keyArray).GetTaggedValue());
301         std::vector<JSTaggedValue> args{key.GetTaggedValue(), JSTaggedValue(static_cast<int32_t>(i))};
302         auto result1 = MapAlgorithm(thread, map.GetTaggedValue(), args, 8, AlgorithmType::SET);
303 
304         EXPECT_TRUE(result1.IsECMAObject());
305         JSHandle<JSSharedMap> jsSMap(thread, JSSharedMap::Cast(reinterpret_cast<TaggedObject *>(result1.GetRawData())));
306         EXPECT_EQ(JSSharedMap::GetSize(thread, jsSMap), static_cast<int>(i) + 1);
307     }
308     // whether jsSMap has delete key
309     keyArray[3] = '1' + 8;
310     JSHandle<JSTaggedValue> deleteKey(factory->NewFromASCII(keyArray));
311 
312     auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
313     ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
314     ecmaRuntimeCallInfo1->SetThis(map.GetTaggedValue());
315     ecmaRuntimeCallInfo1->SetCallArg(0, deleteKey.GetTaggedValue());
316 
317     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
318     JSTaggedValue result2 = BuiltinsSharedMap::Has(ecmaRuntimeCallInfo1);
319     TestHelper::TearDownFrame(thread, prev);
320 
321     EXPECT_EQ(result2.GetRawData(), JSTaggedValue::True().GetRawData());
322 
323     // delete
324     [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
325     JSTaggedValue result3 = BuiltinsSharedMap::Delete(ecmaRuntimeCallInfo1);
326     TestHelper::TearDownFrame(thread, prev1);
327     EXPECT_EQ(result3.GetRawData(), JSTaggedValue::True().GetRawData());
328 
329     // check deleteKey is deleted
330     [[maybe_unused]] auto prev2 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
331     JSTaggedValue result4 = BuiltinsSharedMap::Has(ecmaRuntimeCallInfo1);
332     TestHelper::TearDownFrame(thread, prev2);
333     EXPECT_EQ(result4.GetRawData(), JSTaggedValue::False().GetRawData());
334     [[maybe_unused]] auto prev3 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
335     JSTaggedValue result5 = BuiltinsSharedMap::GetSize(ecmaRuntimeCallInfo1);
336     TestHelper::TearDownFrame(thread, prev3);
337     EXPECT_EQ(result5.GetRawData(), JSTaggedValue(39).GetRawData());
338 
339     // clear
340     [[maybe_unused]] auto prev4 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
341     JSTaggedValue result6 = BuiltinsSharedMap::Clear(ecmaRuntimeCallInfo1);
342     TestHelper::TearDownFrame(thread, prev4);
343     EXPECT_EQ(result6.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
344     EXPECT_EQ(JSSharedMap::GetSize(thread, map), 0);
345 }
HWTEST_F_L0(BuiltinsSharedMapTest, Species)346 HWTEST_F_L0(BuiltinsSharedMapTest, Species)
347 {
348     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
349     JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
350     JSHandle<JSTaggedValue> map(thread, CreateSBuiltinsMap(thread));
351 
352     // test species
353     JSHandle<JSTaggedValue> speciesSymbol = env->GetSpeciesSymbol();
354     EXPECT_TRUE(!speciesSymbol.GetTaggedValue().IsUndefined());
355 
356     JSHandle<JSFunction> newTarget(env->GetSBuiltininMapFunction());
357 
358     JSTaggedValue value =
359         JSObject::GetProperty(thread, JSHandle<JSTaggedValue>(newTarget), speciesSymbol).GetValue().GetTaggedValue();
360     JSHandle<JSTaggedValue> valueHandle(thread, value);
361     EXPECT_EQ(value, newTarget.GetTaggedValue());
362 
363     JSHandle<JSFunction> constructor = JSHandle<JSFunction>::Cast(JSTaggedValue::ToObject(thread, valueHandle));
364     EXPECT_EQ(JSTaggedValue::GetPrototype(thread, map), constructor->GetFunctionPrototype());
365 
366     JSHandle<JSTaggedValue> key1(factory->NewFromASCII("set"));
367     JSTaggedValue value1 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
368     EXPECT_FALSE(value1.IsUndefined());
369 
370     JSHandle<JSTaggedValue> key2(factory->NewFromASCII("has"));
371     JSTaggedValue value2 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
372     EXPECT_FALSE(value2.IsUndefined());
373 
374     JSHandle<JSTaggedValue> key3(factory->NewFromASCII("clear"));
375     JSTaggedValue value3 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
376     EXPECT_FALSE(value3.IsUndefined());
377 
378     JSHandle<JSTaggedValue> key4(factory->NewFromASCII("size"));
379     JSTaggedValue value4 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
380     EXPECT_FALSE(value4.IsUndefined());
381 
382     JSHandle<JSTaggedValue> key5(factory->NewFromASCII("delete"));
383     JSTaggedValue value5 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
384     EXPECT_FALSE(value5.IsUndefined());
385 
386     JSHandle<JSTaggedValue> key6(factory->NewFromASCII("forEach"));
387     JSTaggedValue value6 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
388     EXPECT_FALSE(value6.IsUndefined());
389 
390     JSHandle<JSTaggedValue> key7(factory->NewFromASCII("get"));
391     JSTaggedValue value7 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
392     EXPECT_FALSE(value7.IsUndefined());
393 }
394 
HWTEST_F_L0(BuiltinsSharedMapTest, GetIterator)395 HWTEST_F_L0(BuiltinsSharedMapTest, GetIterator)
396 {
397     JSHandle<JSTaggedValue> map(thread, CreateSBuiltinsMap(thread));
398     auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
399     ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
400     ecmaRuntimeCallInfo->SetThis(map.GetTaggedValue());
401     [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
402 
403     // test Values()
404     JSTaggedValue result = BuiltinsSharedMap::Values(ecmaRuntimeCallInfo);
405     JSHandle<JSSharedMapIterator> iter(thread, result);
406     EXPECT_TRUE(result.IsJSSharedMapIterator());
407     EXPECT_EQ(IterationKind::VALUE, iter->GetIterationKind());
408 
409     // test Keys()
410     JSTaggedValue result1 = BuiltinsSharedMap::Keys(ecmaRuntimeCallInfo);
411     JSHandle<JSSharedMapIterator> iter1(thread, result1);
412     EXPECT_TRUE(result1.IsJSSharedMapIterator());
413     EXPECT_EQ(IterationKind::KEY, iter1->GetIterationKind());
414 
415     // test entries()
416     JSTaggedValue result2 = BuiltinsSharedMap::Entries(ecmaRuntimeCallInfo);
417     JSHandle<JSSharedMapIterator> iter2(thread, result2);
418     EXPECT_TRUE(result2.IsJSSharedMapIterator());
419     EXPECT_EQ(IterationKind::KEY_AND_VALUE, iter2->GetIterationKind());
420     TestHelper::TearDownFrame(thread, prev);
421 }
422 
HWTEST_F_L0(BuiltinsSharedMapTest, NextInternalTest001)423 HWTEST_F_L0(BuiltinsSharedMapTest, NextInternalTest001)
424 {
425     JSTaggedValue result2 =
426         JSSharedMapIterator::NextInternal(thread, JSHandle<JSTaggedValue>(thread, JSTaggedValue::Undefined()));
427     EXPECT_EQ(result2.IsJSSharedSetIterator(), false);
428 }
429 }
430