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