1 /*
2 * Copyright (c) 2022 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/ecma_string.h"
17 #include "ecmascript/containers/containers_private.h"
18 #include "ecmascript/ecma_string.h"
19 #include "ecmascript/ecma_vm.h"
20 #include "ecmascript/global_env.h"
21 #include "ecmascript/js_api/js_api_lightweightmap.h"
22 #include "ecmascript/js_api/js_api_lightweightmap_iterator.h"
23 #include "ecmascript/js_function.h"
24 #include "ecmascript/js_handle.h"
25 #include "ecmascript/js_iterator.h"
26 #include "ecmascript/js_object-inl.h"
27 #include "ecmascript/js_tagged_value.h"
28 #include "ecmascript/object_factory.h"
29 #include "ecmascript/tests/ecma_test_common.h"
30
31 using namespace panda;
32
33 using namespace panda::ecmascript;
34
35 using namespace panda::ecmascript::containers;
36
37 namespace panda::test {
38 class JSAPILightWeightMapTest : public BaseTestWithScope<false> {
39 public:
40 const static int DEFAULT_SIZE = 8;
41
42 protected:
CreateLightWeightMap()43 JSAPILightWeightMap *CreateLightWeightMap()
44 {
45 return EcmaContainerCommon::CreateLightWeightMap(thread);
46 }
47
TestCommon(JSMutableHandle<JSTaggedValue> & value,std::string & myValue,uint32_t numbers)48 JSHandle<JSAPILightWeightMap> TestCommon(JSMutableHandle<JSTaggedValue>& value, std::string& myValue,
49 uint32_t numbers)
50 {
51 JSMutableHandle<JSTaggedValue> key(thread, JSTaggedValue::Undefined());
52 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
53 std::string myKey("mykey");
54 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
55 for (uint32_t i = 0; i < numbers; i++) {
56 std::string ikey = myKey + std::to_string(i);
57 std::string ivalue = myValue + std::to_string(i);
58 key.Update(factory->NewFromStdString(ikey).GetTaggedValue());
59 value.Update(factory->NewFromStdString(ivalue).GetTaggedValue());
60 JSAPILightWeightMap::Set(thread, lwm, key, value);
61 EXPECT_TRUE(JSAPILightWeightMap::GetIndexOfKey(thread, lwm, key) != -1);
62 EXPECT_TRUE(JSAPILightWeightMap::GetIndexOfValue(thread, lwm, value) != -1);
63 uint32_t length = lwm->GetLength();
64 EXPECT_EQ(length, i + 1);
65 }
66 return lwm;
67 }
68
RemoveCommon(std::vector<JSHandle<JSTaggedValue>> & keys,std::vector<JSHandle<JSTaggedValue>> & values)69 JSHandle<JSAPILightWeightMap> RemoveCommon(std::vector<JSHandle<JSTaggedValue>>& keys,
70 std::vector<JSHandle<JSTaggedValue>>& values)
71 {
72 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
73 JSHandle<TaggedArray> valueArray(thread,
74 JSTaggedValue(TaggedArray::Cast(lwm->GetValues(thread).GetTaggedObject())));
75
76 for (int i = 1; i <= 3; i++) { // 3: key value count; 1: start key
77 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(i));
78 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(i + 1));
79 JSAPILightWeightMap::Set(thread, lwm, key, value);
80 keys.push_back(key);
81 values.push_back(value);
82 }
83 return lwm;
84 }
85 };
86
HWTEST_F_L0(JSAPILightWeightMapTest,LightWeightMapCreate)87 HWTEST_F_L0(JSAPILightWeightMapTest, LightWeightMapCreate)
88 {
89 JSAPILightWeightMap *lightWeightMap = CreateLightWeightMap();
90 EXPECT_TRUE(lightWeightMap != nullptr);
91 }
92
HWTEST_F_L0(JSAPILightWeightMapTest,SetHasKeyGetHasValue)93 HWTEST_F_L0(JSAPILightWeightMapTest, SetHasKeyGetHasValue)
94 {
95 JSAPILightWeightMap *lightWeightMap = CreateLightWeightMap();
96
97 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(1));
98 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(2));
99 JSHandle<JSAPILightWeightMap> lwm(thread, lightWeightMap);
100 JSAPILightWeightMap::Set(thread, lwm, key, value);
101 EXPECT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread,
102 JSAPILightWeightMap::Get(thread, lwm, key)), value));
103
104 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(2));
105 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(3));
106 JSAPILightWeightMap::Set(thread, lwm, key1, value1);
107
108 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(3));
109 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(4));
110 JSAPILightWeightMap::Set(thread, lwm, key2, value2);
111
112 // test species
113 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
114 JSHandle<JSTaggedValue> key3 = env->GetSpeciesSymbol();
115 JSHandle<JSTaggedValue> value3(thread, JSTaggedValue(5));
116 JSAPILightWeightMap::Set(thread, lwm, key3, value3);
117
118 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(10));
119 JSHandle<JSTaggedValue> value4(thread, JSTaggedValue(10));
120 JSAPILightWeightMap::Set(thread, lwm, key4, value4);
121 EXPECT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread,
122 JSAPILightWeightMap::Get(thread, lwm, key4)), value4));
123
124 // change value on Existed key
125 JSHandle<JSTaggedValue> value5(thread, JSTaggedValue(100));
126 JSAPILightWeightMap::Set(thread, lwm, key4, value5);
127 EXPECT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread,
128 JSAPILightWeightMap::Get(thread, lwm, key4)), value5));
129
130 EXPECT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread,
131 JSAPILightWeightMap::Get(thread, lwm, key)), value));
132
133 EXPECT_EQ(JSAPILightWeightMap::HasKey(thread, lwm, key1), JSTaggedValue::True());
134 EXPECT_EQ(JSAPILightWeightMap::HasKey(thread, lwm, key), JSTaggedValue::True());
135 EXPECT_EQ(JSAPILightWeightMap::HasKey(thread, lwm, key3), JSTaggedValue::True());
136 EXPECT_EQ(JSAPILightWeightMap::HasKey(thread, lwm, value), JSTaggedValue::True());
137 }
138
HWTEST_F_L0(JSAPILightWeightMapTest,GetIndexOfKeyAndGetIndexOfValue)139 HWTEST_F_L0(JSAPILightWeightMapTest, GetIndexOfKeyAndGetIndexOfValue)
140 {
141 constexpr uint32_t NODE_NUMBERS = 8;
142 JSMutableHandle<JSTaggedValue> value(thread, JSTaggedValue::Undefined());
143 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
144 std::string myValue("myvalue");
145 auto lwm = TestCommon(value, myValue, NODE_NUMBERS);
146 std::string ivalue = myValue + std::to_string(NODE_NUMBERS);
147 value.Update(factory->NewFromStdString(ivalue).GetTaggedValue());
148 EXPECT_TRUE(JSAPILightWeightMap::GetIndexOfValue(thread, lwm, value) == -1);
149 }
150
HWTEST_F_L0(JSAPILightWeightMapTest,IsEmptyGetKeyAtGetValue)151 HWTEST_F_L0(JSAPILightWeightMapTest, IsEmptyGetKeyAtGetValue)
152 {
153 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
154
155 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(1));
156 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(2));
157 JSAPILightWeightMap::Set(thread, lwm, key, value);
158
159 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(2));
160 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(3));
161 JSAPILightWeightMap::Set(thread, lwm, key1, value1);
162
163 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(3));
164 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(4));
165 JSAPILightWeightMap::Set(thread, lwm, key2, value2);
166
167 JSHandle<JSTaggedValue> result =
168 JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::GetValueAt(thread, lwm, 0));
169 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, value));
170 result = JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::GetValueAt(thread, lwm, 1));
171 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, value1));
172 result = JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::GetValueAt(thread, lwm, 2));
173 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, value2));
174
175 result = JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::GetKeyAt(thread, lwm, 0));
176 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, key));
177 result = JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::GetKeyAt(thread, lwm, 1));
178 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, key1));
179 result = JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::GetKeyAt(thread, lwm, 2));
180 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, key2));
181
182 EXPECT_EQ(lwm->IsEmpty(), JSTaggedValue::False());
183 JSAPILightWeightMap::Clear(thread, lwm);
184 EXPECT_EQ(lwm->IsEmpty(), JSTaggedValue::True());
185 }
186
HWTEST_F_L0(JSAPILightWeightMapTest,Remove)187 HWTEST_F_L0(JSAPILightWeightMapTest, Remove)
188 {
189 std::vector<JSHandle<JSTaggedValue>> keys{};
190 std::vector<JSHandle<JSTaggedValue>> values{};
191 auto lwm = RemoveCommon(keys, values);
192
193 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(4));
194
195 JSHandle<JSTaggedValue> result =
196 JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::Remove(thread, lwm, keys[2])); // 2 : key index
197 JSHandle<JSTaggedValue> resultNoExist =
198 JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::Remove(thread, lwm, key3));
199 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, values[2])); // 2 : value index
200 bool isKeyExist = true;
201 if (resultNoExist->IsUndefined()) {
202 isKeyExist = false;
203 }
204 EXPECT_FALSE(isKeyExist);
205 }
206
HWTEST_F_L0(JSAPILightWeightMapTest,RemoveAt)207 HWTEST_F_L0(JSAPILightWeightMapTest, RemoveAt)
208 {
209 std::vector<JSHandle<JSTaggedValue>> keys{};
210 std::vector<JSHandle<JSTaggedValue>> values{};
211 auto lwm = RemoveCommon(keys, values);
212 int32_t removeIndex = JSAPILightWeightMap::GetIndexOfKey(thread, lwm, keys[1]); // 1 : key
213 EXPECT_EQ(JSAPILightWeightMap::RemoveAt(thread, lwm, removeIndex), JSTaggedValue::True());
214 JSHandle<JSTaggedValue> result(thread, JSAPILightWeightMap::Get(thread, lwm, keys[1])); // 1 : key
215 bool isSuccessRemove = false;
216 if (result->IsUndefined()) {
217 isSuccessRemove = true;
218 }
219 EXPECT_TRUE(isSuccessRemove);
220 EXPECT_EQ(JSAPILightWeightMap::HasValue(thread, lwm, values[1]), JSTaggedValue::False());
221 EXPECT_TRUE(lwm->GetLength() == 2);
222
223 EXPECT_EQ(JSAPILightWeightMap::RemoveAt(thread, lwm, -1), JSTaggedValue::False());
224 EXPECT_EQ(JSAPILightWeightMap::RemoveAt(thread, lwm, 10), JSTaggedValue::False());
225 }
226
HWTEST_F_L0(JSAPILightWeightMapTest,SetValueAt)227 HWTEST_F_L0(JSAPILightWeightMapTest, SetValueAt)
228 {
229 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
230
231 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(1));
232 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(2));
233 JSAPILightWeightMap::Set(thread, lwm, key, value);
234 EXPECT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread,
235 JSAPILightWeightMap::Get(thread, lwm, key)), value));
236
237 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(2));
238 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(3));
239 JSAPILightWeightMap::Set(thread, lwm, key1, value1);
240
241 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(3));
242 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(4));
243 JSAPILightWeightMap::Set(thread, lwm, key2, value2);
244
245 JSHandle<JSTaggedValue> value3(thread, JSTaggedValue(5));
246
247 int32_t index = JSAPILightWeightMap::GetIndexOfKey(thread, lwm, key);
248 JSAPILightWeightMap::SetValueAt(thread, lwm, index, value3);
249 EXPECT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread,
250 JSAPILightWeightMap::Get(thread, lwm, key)), value3));
251 }
252
HWTEST_F_L0(JSAPILightWeightMapTest,GetStateOfKey)253 HWTEST_F_L0(JSAPILightWeightMapTest, GetStateOfKey)
254 {
255 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
256
257 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
258 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(1));
259 JSAPILightWeightMap::Set(thread, lwm, key1, value1);
260 KeyState keyState1 = JSAPILightWeightMap::GetStateOfKey(thread, lwm, key1);
261 EXPECT_TRUE(keyState1.existed);
262
263 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
264 KeyState keyState2 = JSAPILightWeightMap::GetStateOfKey(thread, lwm, key2);
265 EXPECT_FALSE(keyState2.existed);
266
267 // hash Collision
268 std::vector<double> setVector = {0.0, 1224.0, 1285.0, 1463.0, 4307.0, 5135.0,
269 5903.0, 6603.0, 6780.0, 8416.0, 9401.0, 9740.0};
270 for (uint32_t i = 0; i < setVector.size() - 1; i++) {
271 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(setVector[i]));
272 JSHandle<JSTaggedValue> value3(thread, JSTaggedValue(setVector[i]));
273 JSAPILightWeightMap::Set(thread, lwm, key3, value3);
274 }
275
276 // check
277 for (uint32_t i = 0; i < setVector.size() - 1; i++) {
278 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(setVector[i]));
279 KeyState keyState4 = JSAPILightWeightMap::GetStateOfKey(thread, lwm, key4);
280 EXPECT_TRUE(keyState4.existed);
281 }
282 JSHandle<JSTaggedValue> key5(thread, JSTaggedValue(setVector[setVector.size() - 1]));
283 KeyState keyState5 = JSAPILightWeightMap::GetStateOfKey(thread, lwm, key5);
284 EXPECT_FALSE(keyState5.existed);
285
286 JSHandle<JSTaggedValue> key6(thread, JSTaggedValue(0));
287 KeyState keyState6 = JSAPILightWeightMap::GetStateOfKey(thread, lwm, key6);
288 EXPECT_TRUE(keyState6.existed);
289 }
290
HWTEST_F_L0(JSAPILightWeightMapTest,IncreaseCapacityTo)291 HWTEST_F_L0(JSAPILightWeightMapTest, IncreaseCapacityTo)
292 {
293 constexpr uint32_t NODE_NUMBERS = 10;
294 JSMutableHandle<JSTaggedValue> value(thread, JSTaggedValue::Undefined());
295 std::string myValue("myvalue");
296 auto lwm = TestCommon(value, myValue, NODE_NUMBERS);
297 EXPECT_EQ(JSAPILightWeightMap::IncreaseCapacityTo(thread, lwm, 15), JSTaggedValue::True());
298 EXPECT_EQ(JSAPILightWeightMap::IncreaseCapacityTo(thread, lwm, 9), JSTaggedValue::False());
299 }
300
HWTEST_F_L0(JSAPILightWeightMapTest,Iterator)301 HWTEST_F_L0(JSAPILightWeightMapTest, Iterator)
302 {
303 constexpr uint32_t NODE_NUMBERS = 8;
304 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
305 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
306
307 JSMutableHandle<JSTaggedValue> key(thread, JSTaggedValue::Undefined());
308 JSMutableHandle<JSTaggedValue> value(thread, JSTaggedValue::Undefined());
309 for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
310 key.Update(JSTaggedValue(i));
311 value.Update(JSTaggedValue(i + 1));
312 JSAPILightWeightMap::Set(thread, lwm, key, value);
313 }
314
315 // test key or value
316 JSHandle<JSTaggedValue> keyIter(factory->NewJSAPILightWeightMapIterator(lwm, IterationKind::KEY));
317 JSHandle<JSTaggedValue> valueIter(factory->NewJSAPILightWeightMapIterator(lwm, IterationKind::VALUE));
318 JSMutableHandle<JSTaggedValue> keyIterResult(thread, JSTaggedValue::Undefined());
319 JSMutableHandle<JSTaggedValue> valueIterResult(thread, JSTaggedValue::Undefined());
320 JSMutableHandle<JSTaggedValue> keyHandle(thread, JSTaggedValue::Undefined());
321 for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
322 keyIterResult.Update(JSIterator::IteratorStep(thread, keyIter).GetTaggedValue());
323 valueIterResult.Update(JSIterator::IteratorStep(thread, valueIter).GetTaggedValue());
324 JSTaggedValue k = JSIterator::IteratorValue(thread, keyIterResult).GetTaggedValue();
325 keyHandle.Update(k);
326 JSTaggedValue v = JSIterator::IteratorValue(thread, valueIterResult).GetTaggedValue();
327 EXPECT_EQ(JSAPILightWeightMap::HasKey(thread, lwm, keyHandle), JSTaggedValue::True());
328 EXPECT_EQ(JSAPILightWeightMap::Get(thread, lwm, keyHandle), v);
329 }
330
331 // test key and value
332 for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
333 JSTaggedValue k = JSTaggedValue(i);
334 JSTaggedValue v = JSTaggedValue(i + 1);
335 keyHandle.Update(k);
336 EXPECT_EQ(JSAPILightWeightMap::HasKey(thread, lwm, keyHandle), JSTaggedValue::True());
337 EXPECT_EQ(JSAPILightWeightMap::Get(thread, lwm, keyHandle), v);
338 }
339 }
340
HWTEST_F_L0(JSAPILightWeightMapTest,IsEmptyHasValueHasAll)341 HWTEST_F_L0(JSAPILightWeightMapTest, IsEmptyHasValueHasAll)
342 {
343 constexpr uint32_t NODE_NUMBERS = 8;
344 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
345 JSHandle<JSAPILightWeightMap> lwp(thread, CreateLightWeightMap());
346 JSHandle<JSAPILightWeightMap> hasAllLwp(thread, CreateLightWeightMap());
347 JSMutableHandle<JSTaggedValue> key1(thread, JSTaggedValue::Undefined());
348 JSMutableHandle<JSTaggedValue> value1(thread, JSTaggedValue::Undefined());
349 JSMutableHandle<JSTaggedValue> value2(thread, JSTaggedValue::Undefined());
350 JSMutableHandle<JSTaggedValue> value3(thread, JSTaggedValue::Undefined());
351
352 std::string tValue;
353 // test IsEmpty
354 EXPECT_EQ(lwp->IsEmpty(), JSTaggedValue::True());
355 // test Set
356 std::string myKey1("mykey");
357 std::string myValue1("myvalue");
358 for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
359 std::string iKey1 = myKey1 + std::to_string(i);
360 std::string iValue1 = myValue1 + std::to_string(i + 1);
361 key1.Update(factory->NewFromStdString(iKey1).GetTaggedValue());
362 value1.Update(factory->NewFromStdString(iValue1).GetTaggedValue());
363 JSAPILightWeightMap::Set(thread, lwp, key1, value1);
364 }
365 EXPECT_EQ(lwp->GetLength(), NODE_NUMBERS);
366
367 // test HasValue
368 for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
369 tValue = myValue1 + std::to_string(i + 1);
370 value1.Update(factory->NewFromStdString(tValue).GetTaggedValue());
371 EXPECT_EQ(JSAPILightWeightMap::HasValue(thread, lwp, value1), JSTaggedValue::True());
372 }
373 tValue = myValue1 + std::to_string(NODE_NUMBERS + 1);
374 value1.Update(factory->NewFromStdString(tValue).GetTaggedValue());
375 EXPECT_EQ(JSAPILightWeightMap::HasValue(thread, lwp, value1), JSTaggedValue::False());
376
377 // test HasAll
378 for (uint32_t i = 0; i < NODE_NUMBERS - 5; i++) {
379 if (i == 1) {
380 std::string mykey2("destKey");
381 std::string myValue2("destValue");
382 std::string iKey2 = mykey2 + std::to_string(i);
383 std::string iValue2 = myValue2 + std::to_string(i);
384 key1.Update(factory->NewFromStdString(iKey2).GetTaggedValue());
385 value1.Update(factory->NewFromStdString(iValue2).GetTaggedValue());
386 JSAPILightWeightMap::Set(thread, hasAllLwp, key1, value1);
387 } else {
388 std::string iKey = myKey1 + std::to_string(i);
389 std::string iValue = myValue1 + std::to_string(i + 1);
390 key1.Update(factory->NewFromStdString(iValue).GetTaggedValue());
391 value1.Update(factory->NewFromStdString(iValue).GetTaggedValue());
392 JSAPILightWeightMap::Set(thread, hasAllLwp, key1, value2);
393 }
394 }
395 EXPECT_EQ(hasAllLwp->GetLength(), NODE_NUMBERS - 5);
396 EXPECT_EQ(JSAPILightWeightMap::HasAll(thread, lwp, hasAllLwp), JSTaggedValue::False());
397 EXPECT_EQ(JSAPILightWeightMap::HasAll(thread, hasAllLwp, lwp), JSTaggedValue::False());
398 }
399
400 /**
401 * @tc.name: GetIteratorObj
402 * @tc.desc:
403 * @tc.type: FUNC
404 * @tc.require:
405 */
HWTEST_F_L0(JSAPILightWeightMapTest,GetIteratorObj)406 HWTEST_F_L0(JSAPILightWeightMapTest, GetIteratorObj)
407 {
408 JSHandle<JSAPILightWeightMap> lwp(thread, CreateLightWeightMap());
409 JSHandle<JSTaggedValue> iteratorObj(thread, JSAPILightWeightMap::GetIteratorObj(
410 thread, lwp, IterationKind::KEY_AND_VALUE));
411 EXPECT_TRUE(iteratorObj->IsJSAPILightWeightMapIterator());
412 }
413 } // namespace panda::test
414