1 /*
2 * Copyright (c) 2021 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 "ecmascript/builtins/builtins_map.h"
17
18 #include "ecmascript/base/builtins_base.h"
19 #include "ecmascript/ecma_runtime_call_info.h"
20 #include "ecmascript/ecma_string.h"
21 #include "ecmascript/ecma_vm.h"
22 #include "ecmascript/global_env.h"
23 #include "ecmascript/js_array.h"
24 #include "ecmascript/js_handle.h"
25 #include "ecmascript/js_hclass.h"
26 #include "ecmascript/js_map.h"
27 #include "ecmascript/js_map_iterator.h"
28 #include "ecmascript/js_object-inl.h"
29 #include "ecmascript/js_tagged_value.h"
30 #include "ecmascript/js_thread.h"
31 #include "ecmascript/object_factory.h"
32 #include "ecmascript/tagged_array-inl.h"
33 #include "ecmascript/tests/test_helper.h"
34
35 using namespace panda::ecmascript;
36 using namespace panda::ecmascript::builtins;
37
38 namespace panda::test {
39 using BuiltinsMap = ecmascript::builtins::BuiltinsMap;
40 using JSMap = ecmascript::JSMap;
41
42 class BuiltinsMapTest : public BaseTestWithScope<false> {
43 public:
44 class TestClass : public base::BuiltinsBase {
45 public:
TestFunc(EcmaRuntimeCallInfo * argv)46 static JSTaggedValue TestFunc(EcmaRuntimeCallInfo *argv)
47 {
48 int num = GetCallArg(argv, 0)->GetInt();
49 JSArray *jsArray = JSArray::Cast(GetThis(argv)->GetTaggedObject());
50 int length = jsArray->GetArrayLength() + num;
51 jsArray->SetArrayLength(argv->GetThread(), length);
52 return JSTaggedValue::Undefined();
53 }
54 };
55 };
56
CreateBuiltinsMap(JSThread * thread)57 JSMap *CreateBuiltinsMap(JSThread *thread)
58 {
59 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
60 JSHandle<JSFunction> newTarget(env->GetBuiltinsMapFunction());
61 // 4 : test case
62 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue(*newTarget), 4);
63 ecmaRuntimeCallInfo->SetFunction(newTarget.GetTaggedValue());
64 ecmaRuntimeCallInfo->SetThis(JSTaggedValue::Undefined());
65
66 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
67 JSTaggedValue result = BuiltinsMap::MapConstructor(ecmaRuntimeCallInfo);
68 TestHelper::TearDownFrame(thread, prev);
69
70 EXPECT_TRUE(result.IsECMAObject());
71 JSMap *jsMap = JSMap::Cast(reinterpret_cast<TaggedObject *>(result.GetRawData()));
72 return jsMap;
73 }
74
75 enum class AlgorithmType {
76 SET,
77 FOR_EACH,
78 HAS,
79 };
80
MapAlgorithm(JSThread * thread,JSTaggedValue thisArg,std::vector<JSTaggedValue> & args,int32_t argLen,AlgorithmType type)81 JSTaggedValue MapAlgorithm(JSThread *thread, JSTaggedValue thisArg, std::vector<JSTaggedValue>& args,
82 int32_t argLen, AlgorithmType type)
83 {
84 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), argLen);
85 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
86 ecmaRuntimeCallInfo->SetThis(thisArg);
87 for (size_t i = 0; i < args.size(); i++) {
88 ecmaRuntimeCallInfo->SetCallArg(i, args[i]);
89 }
90 auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
91 JSTaggedValue result;
92 switch (type) {
93 case AlgorithmType::SET:
94 result = BuiltinsMap::Set(ecmaRuntimeCallInfo);
95 break;
96 case AlgorithmType::FOR_EACH:
97 result = BuiltinsMap::ForEach(ecmaRuntimeCallInfo);
98 break;
99 case AlgorithmType::HAS:
100 result = BuiltinsMap::Has(ecmaRuntimeCallInfo);
101 break;
102 default:
103 break;
104 }
105 TestHelper::TearDownFrame(thread, prev);
106 return result;
107 }
108
109 // new Map("abrupt").toString()
HWTEST_F_L0(BuiltinsMapTest,CreateAndGetSize)110 HWTEST_F_L0(BuiltinsMapTest, CreateAndGetSize)
111 {
112 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
113 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
114 JSHandle<JSFunction> newTarget(env->GetBuiltinsMapFunction());
115 JSHandle<JSMap> map(thread, CreateBuiltinsMap(thread));
116
117 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
118 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
119 ecmaRuntimeCallInfo->SetThis(map.GetTaggedValue());
120 ecmaRuntimeCallInfo->SetCallArg(0, JSTaggedValue::Undefined());
121
122 {
123 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
124 JSTaggedValue result = BuiltinsMap::GetSize(ecmaRuntimeCallInfo);
125 TestHelper::TearDownFrame(thread, prev);
126
127 EXPECT_EQ(result.GetRawData(), JSTaggedValue(0).GetRawData());
128 }
129 JSHandle<TaggedArray> array(factory->NewTaggedArray(5));
130 for (int i = 0; i < 5; i++) {
131 JSHandle<TaggedArray> internalArray(factory->NewTaggedArray(2));
132 internalArray->Set(thread, 0, JSTaggedValue(i));
133 internalArray->Set(thread, 1, JSTaggedValue(i));
134 auto arr = JSArray::CreateArrayFromList(thread, internalArray);
135 array->Set(thread, i, arr);
136 }
137 JSHandle<JSArray> values = JSArray::CreateArrayFromList(thread, array);
138 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
139 ecmaRuntimeCallInfo1->SetFunction(newTarget.GetTaggedValue());
140 ecmaRuntimeCallInfo1->SetThis(map.GetTaggedValue());
141 ecmaRuntimeCallInfo1->SetCallArg(0, values.GetTaggedValue());
142 ecmaRuntimeCallInfo1->SetNewTarget(newTarget.GetTaggedValue());
143 {
144 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
145 JSTaggedValue result1 = BuiltinsMap::MapConstructor(ecmaRuntimeCallInfo1);
146 TestHelper::TearDownFrame(thread, prev);
147
148 EXPECT_EQ(JSMap::Cast(reinterpret_cast<TaggedObject *>(result1.GetRawData()))->GetSize(), 5);
149 }
150 }
151
HWTEST_F_L0(BuiltinsMapTest,SetAndHas)152 HWTEST_F_L0(BuiltinsMapTest, SetAndHas)
153 {
154 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
155 // create jsMap
156 JSHandle<JSMap> map(thread, CreateBuiltinsMap(thread));
157 JSHandle<JSTaggedValue> key(factory->NewFromASCII("key"));
158
159 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
160 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
161 ecmaRuntimeCallInfo->SetThis(map.GetTaggedValue());
162 ecmaRuntimeCallInfo->SetCallArg(0, key.GetTaggedValue());
163 ecmaRuntimeCallInfo->SetCallArg(1, JSTaggedValue(static_cast<int32_t>(1)));
164
165 JSMap *jsMap;
166 {
167 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
168 JSTaggedValue result1 = BuiltinsMap::Has(ecmaRuntimeCallInfo);
169
170 EXPECT_EQ(result1.GetRawData(), JSTaggedValue::False().GetRawData());
171
172 // test Set()
173 JSTaggedValue result2 = BuiltinsMap::Set(ecmaRuntimeCallInfo);
174
175 EXPECT_TRUE(result2.IsECMAObject());
176 jsMap = JSMap::Cast(reinterpret_cast<TaggedObject *>(result2.GetRawData()));
177 EXPECT_EQ(jsMap->GetSize(), 1);
178 }
179
180 // test Has()
181 std::vector<JSTaggedValue> args{key.GetTaggedValue(), JSTaggedValue(static_cast<int32_t>(1))}; // 1:value
182 auto result3 = MapAlgorithm(thread, JSTaggedValue(jsMap), args, 8, AlgorithmType::HAS); // 8: arg len
183 EXPECT_EQ(result3.GetRawData(), JSTaggedValue::True().GetRawData());
184 }
185
HWTEST_F_L0(BuiltinsMapTest,ForEach)186 HWTEST_F_L0(BuiltinsMapTest, ForEach)
187 {
188 // generate a map has 5 entries{key1:0,key2:1,key3:2,key4:3,key5:4}
189 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
190 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
191 JSHandle<JSMap> map(thread, CreateBuiltinsMap(thread));
192 char keyArray[] = "key0";
193 for (uint32_t i = 0; i < 5; i++) {
194 keyArray[3] = '1' + i;
195 JSHandle<JSTaggedValue> key(factory->NewFromASCII(keyArray));
196 std::vector<JSTaggedValue> args{key.GetTaggedValue(), JSTaggedValue(static_cast<int32_t>(i))};
197 auto result1 = MapAlgorithm(thread, map.GetTaggedValue(), args, 8, AlgorithmType::SET);
198
199 EXPECT_TRUE(result1.IsECMAObject());
200 JSMap *jsMap = JSMap::Cast(reinterpret_cast<TaggedObject *>(result1.GetRawData()));
201 EXPECT_EQ(jsMap->GetSize(), static_cast<int>(i) + 1);
202 }
203 JSHandle<JSArray> jsArray(JSArray::ArrayCreate(thread, JSTaggedNumber(0)));
204 JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestFunc));
205
206 std::vector<JSTaggedValue> args{func.GetTaggedValue(), jsArray.GetTaggedValue()};
207 auto result2 = MapAlgorithm(thread, map.GetTaggedValue(), args, 8, AlgorithmType::FOR_EACH);
208
209 EXPECT_EQ(result2.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
210 EXPECT_EQ(jsArray->GetArrayLength(), 10U);
211 }
212
HWTEST_F_L0(BuiltinsMapTest,DeleteAndRemove)213 HWTEST_F_L0(BuiltinsMapTest, DeleteAndRemove)
214 {
215 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
216 // create jsMap
217 JSHandle<JSMap> map(thread, CreateBuiltinsMap(thread));
218
219 // add 40 keys
220 char keyArray[] = "key0";
221 for (uint32_t i = 0; i < 40; i++) {
222 keyArray[3] = '1' + i;
223 JSHandle<JSTaggedValue> key(thread, factory->NewFromASCII(keyArray).GetTaggedValue());
224 std::vector<JSTaggedValue> args{key.GetTaggedValue(), JSTaggedValue(static_cast<int32_t>(i))};
225 auto result1 = MapAlgorithm(thread, map.GetTaggedValue(), args, 8, AlgorithmType::SET);
226
227 EXPECT_TRUE(result1.IsECMAObject());
228 JSMap *jsMap = JSMap::Cast(reinterpret_cast<TaggedObject *>(result1.GetRawData()));
229 EXPECT_EQ(jsMap->GetSize(), static_cast<int>(i) + 1);
230 }
231 // whether jsMap has delete key
232 keyArray[3] = '1' + 8;
233 JSHandle<JSTaggedValue> deleteKey(factory->NewFromASCII(keyArray));
234
235 auto ecmaRuntimeCallInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
236 ecmaRuntimeCallInfo1->SetFunction(JSTaggedValue::Undefined());
237 ecmaRuntimeCallInfo1->SetThis(map.GetTaggedValue());
238 ecmaRuntimeCallInfo1->SetCallArg(0, deleteKey.GetTaggedValue());
239
240 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
241 JSTaggedValue result2 = BuiltinsMap::Has(ecmaRuntimeCallInfo1);
242 TestHelper::TearDownFrame(thread, prev);
243
244 EXPECT_EQ(result2.GetRawData(), JSTaggedValue::True().GetRawData());
245
246 // delete
247 [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
248 JSTaggedValue result3 = BuiltinsMap::Delete(ecmaRuntimeCallInfo1);
249 TestHelper::TearDownFrame(thread, prev1);
250 EXPECT_EQ(result3.GetRawData(), JSTaggedValue::True().GetRawData());
251
252 // check deleteKey is deleted
253 [[maybe_unused]] auto prev2 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
254 JSTaggedValue result4 = BuiltinsMap::Has(ecmaRuntimeCallInfo1);
255 TestHelper::TearDownFrame(thread, prev2);
256 EXPECT_EQ(result4.GetRawData(), JSTaggedValue::False().GetRawData());
257 [[maybe_unused]] auto prev3 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
258 JSTaggedValue result5 = BuiltinsMap::GetSize(ecmaRuntimeCallInfo1);
259 TestHelper::TearDownFrame(thread, prev3);
260 EXPECT_EQ(result5.GetRawData(), JSTaggedValue(39).GetRawData());
261
262 // clear
263 [[maybe_unused]] auto prev4 = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo1);
264 JSTaggedValue result6 = BuiltinsMap::Clear(ecmaRuntimeCallInfo1);
265 TestHelper::TearDownFrame(thread, prev4);
266 EXPECT_EQ(result6.GetRawData(), JSTaggedValue::VALUE_UNDEFINED);
267 EXPECT_EQ(map->GetSize(), 0);
268 }
269
HWTEST_F_L0(BuiltinsMapTest,Species)270 HWTEST_F_L0(BuiltinsMapTest, Species)
271 {
272 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
273 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
274 JSHandle<JSTaggedValue> map(thread, CreateBuiltinsMap(thread));
275
276 // test species
277 JSHandle<JSTaggedValue> speciesSymbol = env->GetSpeciesSymbol();
278 EXPECT_TRUE(!speciesSymbol.GetTaggedValue().IsUndefined());
279
280 JSHandle<JSFunction> newTarget(env->GetBuiltinsMapFunction());
281
282 JSTaggedValue value =
283 JSObject::GetProperty(thread, JSHandle<JSTaggedValue>(newTarget), speciesSymbol).GetValue().GetTaggedValue();
284 JSHandle<JSTaggedValue> valueHandle(thread, value);
285 EXPECT_EQ(value, newTarget.GetTaggedValue());
286
287 // to string tag
288 JSHandle<JSTaggedValue> toStringTagSymbol = env->GetToStringTagSymbol();
289 JSHandle<EcmaString> stringTag(JSObject::GetProperty(thread, map, toStringTagSymbol).GetValue());
290 JSHandle<EcmaString> str = factory->NewFromASCII("Map");
291 EXPECT_TRUE(!stringTag.GetTaggedValue().IsUndefined());
292 EXPECT_TRUE(EcmaStringAccessor::StringsAreEqual(*str, *stringTag));
293
294 JSHandle<JSFunction> constructor = JSHandle<JSFunction>::Cast(JSTaggedValue::ToObject(thread, valueHandle));
295 EXPECT_EQ(JSTaggedValue::GetPrototype(thread, map), constructor->GetFunctionPrototype());
296
297 JSHandle<JSTaggedValue> key1(factory->NewFromASCII("set"));
298 JSTaggedValue value1 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
299 EXPECT_FALSE(value1.IsUndefined());
300
301 JSHandle<JSTaggedValue> key2(factory->NewFromASCII("has"));
302 JSTaggedValue value2 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
303 EXPECT_FALSE(value2.IsUndefined());
304
305 JSHandle<JSTaggedValue> key3(factory->NewFromASCII("clear"));
306 JSTaggedValue value3 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
307 EXPECT_FALSE(value3.IsUndefined());
308
309 JSHandle<JSTaggedValue> key4(factory->NewFromASCII("size"));
310 JSTaggedValue value4 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
311 EXPECT_FALSE(value4.IsUndefined());
312
313 JSHandle<JSTaggedValue> key5(factory->NewFromASCII("delete"));
314 JSTaggedValue value5 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
315 EXPECT_FALSE(value5.IsUndefined());
316
317 JSHandle<JSTaggedValue> key6(factory->NewFromASCII("forEach"));
318 JSTaggedValue value6 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
319 EXPECT_FALSE(value6.IsUndefined());
320
321 JSHandle<JSTaggedValue> key7(factory->NewFromASCII("get"));
322 JSTaggedValue value7 = JSObject::GetProperty(thread, map, key1).GetValue().GetTaggedValue();
323 EXPECT_FALSE(value7.IsUndefined());
324 }
325
HWTEST_F_L0(BuiltinsMapTest,GetIterator)326 HWTEST_F_L0(BuiltinsMapTest, GetIterator)
327 {
328 JSHandle<JSTaggedValue> map(thread, CreateBuiltinsMap(thread));
329 auto ecmaRuntimeCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
330 ecmaRuntimeCallInfo->SetFunction(JSTaggedValue::Undefined());
331 ecmaRuntimeCallInfo->SetThis(map.GetTaggedValue());
332 [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, ecmaRuntimeCallInfo);
333
334 // test Values()
335 JSTaggedValue result = BuiltinsMap::Values(ecmaRuntimeCallInfo);
336 JSHandle<JSMapIterator> iter(thread, result);
337 EXPECT_TRUE(iter->IsJSMapIterator());
338 EXPECT_EQ(IterationKind::VALUE, iter->GetIterationKind());
339 EXPECT_EQ(JSMap::Cast(map.GetTaggedValue().GetTaggedObject())->GetLinkedMap(), iter->GetIteratedMap());
340
341 // test Keys()
342 JSTaggedValue result1 = BuiltinsMap::Keys(ecmaRuntimeCallInfo);
343 JSHandle<JSMapIterator> iter1(thread, result1);
344 EXPECT_TRUE(iter1->IsJSMapIterator());
345 EXPECT_EQ(IterationKind::KEY, iter1->GetIterationKind());
346
347 // test entries()
348 JSTaggedValue result2 = BuiltinsMap::Entries(ecmaRuntimeCallInfo);
349 JSHandle<JSMapIterator> iter2(thread, result2);
350 EXPECT_TRUE(iter2->IsJSMapIterator());
351 EXPECT_EQ(IterationKind::KEY_AND_VALUE, iter2->GetIterationKind());
352 TestHelper::TearDownFrame(thread, prev);
353 }
354 } // namespace panda::test
355