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
29using namespace panda::ecmascript;
30using namespace panda::ecmascript::builtins;
31
32namespace panda::test {
33using BuiltinsSharedMap = ecmascript::builtins::BuiltinsSharedMap;
34
35class BuiltinsSharedMapTest : public BaseTestWithScope<false> {
36public:
37    class TestClass : public base::BuiltinsBase {
38    public:
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
50JSSharedMap *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
69HWTEST_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
112HWTEST_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
134HWTEST_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
156HWTEST_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
164enum class AlgorithmType {
165    SET,
166    FOR_EACH,
167    HAS,
168};
169
170JSTaggedValue 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
198HWTEST_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
231HWTEST_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
263HWTEST_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
290HWTEST_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}
346HWTEST_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
395HWTEST_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
423HWTEST_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