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/test_helper.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 testing::Test {
39 public:
40 const static int DEFAULT_SIZE = 8;
SetUpTestCase()41 static void SetUpTestCase()
42 {
43 GTEST_LOG_(INFO) << "SetUpTestCase";
44 }
45
TearDownTestCase()46 static void TearDownTestCase()
47 {
48 GTEST_LOG_(INFO) << "TearDownCase";
49 }
50
SetUp()51 void SetUp() override
52 {
53 TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
54 }
55
TearDown()56 void TearDown() override
57 {
58 TestHelper::DestroyEcmaVMWithScope(instance, scope);
59 }
60
61 EcmaVM *instance {nullptr};
62 ecmascript::EcmaHandleScope *scope {nullptr};
63 JSThread *thread {nullptr};
64
65 protected:
CreateLightWeightMap()66 JSAPILightWeightMap *CreateLightWeightMap()
67 {
68 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
69 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
70
71 JSHandle<JSTaggedValue> globalObject = env->GetJSGlobalObject();
72 JSHandle<JSTaggedValue> key(factory->NewFromASCII("ArkPrivate"));
73 JSHandle<JSTaggedValue> value = JSObject::GetProperty(thread,
74 JSHandle<JSTaggedValue>(globalObject), key).GetValue();
75
76 auto objCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
77 objCallInfo->SetFunction(JSTaggedValue::Undefined());
78 objCallInfo->SetThis(value.GetTaggedValue());
79 objCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int>(containers::ContainerTag::LightWeightMap)));
80
81 auto prev = TestHelper::SetupFrame(thread, objCallInfo);
82 JSHandle<JSTaggedValue> constructor =
83 JSHandle<JSTaggedValue>(thread, containers::ContainersPrivate::Load(objCallInfo));
84 TestHelper::TearDownFrame(thread, prev);
85 JSHandle<JSAPILightWeightMap> lightWeightMap = JSHandle<JSAPILightWeightMap>::
86 Cast(factory->NewJSObjectByConstructor(JSHandle<JSFunction>(constructor), constructor));
87 JSHandle<JSTaggedValue> hashArray = JSHandle<JSTaggedValue>(factory->NewTaggedArray(DEFAULT_SIZE));
88 JSHandle<JSTaggedValue> keyArray = JSHandle<JSTaggedValue>(factory->NewTaggedArray(DEFAULT_SIZE));
89 JSHandle<JSTaggedValue> valueArray = JSHandle<JSTaggedValue>(factory->NewTaggedArray(DEFAULT_SIZE));
90 lightWeightMap->SetHashes(thread, hashArray);
91 lightWeightMap->SetKeys(thread, keyArray);
92 lightWeightMap->SetValues(thread, valueArray);
93 lightWeightMap->SetLength(0);
94 return *lightWeightMap;
95 }
96 };
97
HWTEST_F_L0(JSAPILightWeightMapTest,LightWeightMapCreate)98 HWTEST_F_L0(JSAPILightWeightMapTest, LightWeightMapCreate)
99 {
100 JSAPILightWeightMap *lightWeightMap = CreateLightWeightMap();
101 EXPECT_TRUE(lightWeightMap != nullptr);
102 }
103
HWTEST_F_L0(JSAPILightWeightMapTest,SetHasKeyGetHasValue)104 HWTEST_F_L0(JSAPILightWeightMapTest, SetHasKeyGetHasValue)
105 {
106 JSAPILightWeightMap *lightWeightMap = CreateLightWeightMap();
107
108 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(1));
109 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(2));
110 JSHandle<JSAPILightWeightMap> lwm(thread, lightWeightMap);
111 JSAPILightWeightMap::Set(thread, lwm, key, value);
112 EXPECT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread,
113 JSAPILightWeightMap::Get(thread, lwm, key)), value));
114
115 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(2));
116 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(3));
117 JSAPILightWeightMap::Set(thread, lwm, key1, value1);
118
119 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(3));
120 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(4));
121 JSAPILightWeightMap::Set(thread, lwm, key2, value2);
122
123 // test species
124 JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
125 JSHandle<JSTaggedValue> key3 = env->GetSpeciesSymbol();
126 JSHandle<JSTaggedValue> value3(thread, JSTaggedValue(5));
127 JSAPILightWeightMap::Set(thread, lwm, key3, value3);
128
129 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(10));
130 JSHandle<JSTaggedValue> value4(thread, JSTaggedValue(10));
131 JSAPILightWeightMap::Set(thread, lwm, key4, value4);
132 EXPECT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread,
133 JSAPILightWeightMap::Get(thread, lwm, key4)), value4));
134
135 // change value on Existed key
136 JSHandle<JSTaggedValue> value5(thread, JSTaggedValue(100));
137 JSAPILightWeightMap::Set(thread, lwm, key4, value5);
138 EXPECT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread,
139 JSAPILightWeightMap::Get(thread, lwm, key4)), value5));
140
141 EXPECT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread,
142 JSAPILightWeightMap::Get(thread, lwm, key)), value));
143
144 EXPECT_EQ(JSAPILightWeightMap::HasKey(thread, lwm, key1), JSTaggedValue::True());
145 EXPECT_EQ(JSAPILightWeightMap::HasKey(thread, lwm, key), JSTaggedValue::True());
146 EXPECT_EQ(JSAPILightWeightMap::HasKey(thread, lwm, key3), JSTaggedValue::True());
147 EXPECT_EQ(JSAPILightWeightMap::HasKey(thread, lwm, value), JSTaggedValue::True());
148 }
149
HWTEST_F_L0(JSAPILightWeightMapTest,GetIndexOfKeyAndGetIndexOfValue)150 HWTEST_F_L0(JSAPILightWeightMapTest, GetIndexOfKeyAndGetIndexOfValue)
151 {
152 constexpr uint32_t NODE_NUMBERS = 8;
153 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
154 JSMutableHandle<JSTaggedValue> key(thread, JSTaggedValue::Undefined());
155 JSMutableHandle<JSTaggedValue> value(thread, JSTaggedValue::Undefined());
156 std::string myKey("mykey");
157 std::string myValue("myvalue");
158 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
159 for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
160 std::string ikey = myKey + std::to_string(i);
161 std::string ivalue = myValue + std::to_string(i);
162 key.Update(factory->NewFromStdString(ikey).GetTaggedValue());
163 value.Update(factory->NewFromStdString(ivalue).GetTaggedValue());
164 JSAPILightWeightMap::Set(thread, lwm, key, value);
165 EXPECT_TRUE(JSAPILightWeightMap::GetIndexOfKey(thread, lwm, key) != -1);
166 EXPECT_TRUE(JSAPILightWeightMap::GetIndexOfValue(thread, lwm, value) != -1);
167 uint32_t length = lwm->GetLength();
168 EXPECT_EQ(length, i + 1);
169 }
170 std::string ivalue = myValue + std::to_string(NODE_NUMBERS);
171 value.Update(factory->NewFromStdString(ivalue).GetTaggedValue());
172 EXPECT_TRUE(JSAPILightWeightMap::GetIndexOfValue(thread, lwm, value) == -1);
173 }
174
HWTEST_F_L0(JSAPILightWeightMapTest,IsEmptyGetKeyAtGetValue)175 HWTEST_F_L0(JSAPILightWeightMapTest, IsEmptyGetKeyAtGetValue)
176 {
177 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
178
179 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(1));
180 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(2));
181 JSAPILightWeightMap::Set(thread, lwm, key, value);
182
183 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(2));
184 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(3));
185 JSAPILightWeightMap::Set(thread, lwm, key1, value1);
186
187 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(3));
188 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(4));
189 JSAPILightWeightMap::Set(thread, lwm, key2, value2);
190
191 JSHandle<JSTaggedValue> result =
192 JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::GetValueAt(thread, lwm, 0));
193 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, value));
194 result = JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::GetValueAt(thread, lwm, 1));
195 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, value1));
196 result = JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::GetValueAt(thread, lwm, 2));
197 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, value2));
198
199 result = JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::GetKeyAt(thread, lwm, 0));
200 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, key));
201 result = JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::GetKeyAt(thread, lwm, 1));
202 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, key1));
203 result = JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::GetKeyAt(thread, lwm, 2));
204 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, key2));
205
206 EXPECT_EQ(lwm->IsEmpty(), JSTaggedValue::False());
207 JSAPILightWeightMap::Clear(thread, lwm);
208 EXPECT_EQ(lwm->IsEmpty(), JSTaggedValue::True());
209 }
210
HWTEST_F_L0(JSAPILightWeightMapTest,Remove)211 HWTEST_F_L0(JSAPILightWeightMapTest, Remove)
212 {
213 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
214 JSHandle<TaggedArray> valueArray(thread,
215 JSTaggedValue(TaggedArray::Cast(lwm->GetValues().GetTaggedObject())));
216
217 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(1));
218 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(2));
219 JSAPILightWeightMap::Set(thread, lwm, key, value);
220
221 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(2));
222 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(3));
223 JSAPILightWeightMap::Set(thread, lwm, key1, value1);
224
225 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(3));
226 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(4));
227 JSAPILightWeightMap::Set(thread, lwm, key2, value2);
228
229 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(4));
230
231 JSHandle<JSTaggedValue> result =
232 JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::Remove(thread, lwm, key2));
233 JSHandle<JSTaggedValue> resultNoExist =
234 JSHandle<JSTaggedValue>(thread, JSAPILightWeightMap::Remove(thread, lwm, key3));
235 EXPECT_TRUE(JSTaggedValue::Equal(thread, result, value2));
236 bool isKeyExist = true;
237 if (resultNoExist->IsUndefined()) {
238 isKeyExist = false;
239 }
240 EXPECT_FALSE(isKeyExist);
241 }
242
HWTEST_F_L0(JSAPILightWeightMapTest,RemoveAt)243 HWTEST_F_L0(JSAPILightWeightMapTest, RemoveAt)
244 {
245 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
246 JSHandle<TaggedArray> valueArray(thread,
247 JSTaggedValue(TaggedArray::Cast(lwm->GetValues().GetTaggedObject())));
248
249 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(1));
250 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(2));
251 JSAPILightWeightMap::Set(thread, lwm, key, value);
252
253 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(2));
254 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(3));
255 JSAPILightWeightMap::Set(thread, lwm, key1, value1);
256
257 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(3));
258 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(4));
259 JSAPILightWeightMap::Set(thread, lwm, key2, value2);
260
261 int32_t removeIndex = JSAPILightWeightMap::GetIndexOfKey(thread, lwm, key1);
262 EXPECT_EQ(JSAPILightWeightMap::RemoveAt(thread, lwm, removeIndex), JSTaggedValue::True());
263 JSHandle<JSTaggedValue> result(thread, JSAPILightWeightMap::Get(thread, lwm, key1));
264 bool isSuccessRemove = false;
265 if (result->IsUndefined()) {
266 isSuccessRemove = true;
267 }
268 EXPECT_TRUE(isSuccessRemove);
269 EXPECT_EQ(JSAPILightWeightMap::HasValue(thread, lwm, value1), JSTaggedValue::False());
270 EXPECT_TRUE(lwm->GetLength() == 2);
271
272 EXPECT_EQ(JSAPILightWeightMap::RemoveAt(thread, lwm, -1), JSTaggedValue::False());
273 EXPECT_EQ(JSAPILightWeightMap::RemoveAt(thread, lwm, 10), JSTaggedValue::False());
274 }
275
HWTEST_F_L0(JSAPILightWeightMapTest,SetValueAt)276 HWTEST_F_L0(JSAPILightWeightMapTest, SetValueAt)
277 {
278 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
279
280 JSHandle<JSTaggedValue> key(thread, JSTaggedValue(1));
281 JSHandle<JSTaggedValue> value(thread, JSTaggedValue(2));
282 JSAPILightWeightMap::Set(thread, lwm, key, value);
283 EXPECT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread,
284 JSAPILightWeightMap::Get(thread, lwm, key)), value));
285
286 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(2));
287 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(3));
288 JSAPILightWeightMap::Set(thread, lwm, key1, value1);
289
290 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(3));
291 JSHandle<JSTaggedValue> value2(thread, JSTaggedValue(4));
292 JSAPILightWeightMap::Set(thread, lwm, key2, value2);
293
294 JSHandle<JSTaggedValue> value3(thread, JSTaggedValue(5));
295
296 int32_t index = JSAPILightWeightMap::GetIndexOfKey(thread, lwm, key);
297 JSAPILightWeightMap::SetValueAt(thread, lwm, index, value3);
298 EXPECT_TRUE(JSTaggedValue::Equal(thread, JSHandle<JSTaggedValue>(thread,
299 JSAPILightWeightMap::Get(thread, lwm, key)), value3));
300 }
301
HWTEST_F_L0(JSAPILightWeightMapTest,GetStateOfKey)302 HWTEST_F_L0(JSAPILightWeightMapTest, GetStateOfKey)
303 {
304 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
305
306 JSHandle<JSTaggedValue> key1(thread, JSTaggedValue(1));
307 JSHandle<JSTaggedValue> value1(thread, JSTaggedValue(1));
308 JSAPILightWeightMap::Set(thread, lwm, key1, value1);
309 KeyState keyState1 = JSAPILightWeightMap::GetStateOfKey(thread, lwm, key1);
310 EXPECT_TRUE(keyState1.existed);
311
312 JSHandle<JSTaggedValue> key2(thread, JSTaggedValue(2));
313 KeyState keyState2 = JSAPILightWeightMap::GetStateOfKey(thread, lwm, key2);
314 EXPECT_FALSE(keyState2.existed);
315
316 // hash Collision
317 std::vector<double> setVector = {0.0, 1224.0, 1285.0, 1463.0, 4307.0, 5135.0,
318 5903.0, 6603.0, 6780.0, 8416.0, 9401.0, 9740.0};
319 for (uint32_t i = 0; i < setVector.size() - 1; i++) {
320 JSHandle<JSTaggedValue> key3(thread, JSTaggedValue(setVector[i]));
321 JSHandle<JSTaggedValue> value3(thread, JSTaggedValue(setVector[i]));
322 JSAPILightWeightMap::Set(thread, lwm, key3, value3);
323 }
324
325 // check
326 for (uint32_t i = 0; i < setVector.size() - 1; i++) {
327 JSHandle<JSTaggedValue> key4(thread, JSTaggedValue(setVector[i]));
328 KeyState keyState4 = JSAPILightWeightMap::GetStateOfKey(thread, lwm, key4);
329 EXPECT_TRUE(keyState4.existed);
330 }
331 JSHandle<JSTaggedValue> key5(thread, JSTaggedValue(setVector[setVector.size() - 1]));
332 KeyState keyState5 = JSAPILightWeightMap::GetStateOfKey(thread, lwm, key5);
333 EXPECT_FALSE(keyState5.existed);
334
335 JSHandle<JSTaggedValue> key6(thread, JSTaggedValue(0));
336 KeyState keyState6 = JSAPILightWeightMap::GetStateOfKey(thread, lwm, key6);
337 EXPECT_TRUE(keyState6.existed);
338 }
339
HWTEST_F_L0(JSAPILightWeightMapTest,IncreaseCapacityTo)340 HWTEST_F_L0(JSAPILightWeightMapTest, IncreaseCapacityTo)
341 {
342 constexpr uint32_t NODE_NUMBERS = 10;
343 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
344 JSMutableHandle<JSTaggedValue> key(thread, JSTaggedValue::Undefined());
345 JSMutableHandle<JSTaggedValue> value(thread, JSTaggedValue::Undefined());
346 std::string myKey("mykey");
347 std::string myValue("myvalue");
348 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
349 for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
350 std::string ikey = myKey + std::to_string(i);
351 std::string ivalue = myValue + std::to_string(i);
352 key.Update(factory->NewFromStdString(ikey).GetTaggedValue());
353 value.Update(factory->NewFromStdString(ivalue).GetTaggedValue());
354 JSAPILightWeightMap::Set(thread, lwm, key, value);
355 EXPECT_TRUE(JSAPILightWeightMap::GetIndexOfKey(thread, lwm, key) != -1);
356 EXPECT_TRUE(JSAPILightWeightMap::GetIndexOfValue(thread, lwm, value) != -1);
357 uint32_t length = lwm->GetLength();
358 EXPECT_EQ(length, i + 1);
359 }
360 EXPECT_EQ(JSAPILightWeightMap::IncreaseCapacityTo(thread, lwm, 15), JSTaggedValue::True());
361 EXPECT_EQ(JSAPILightWeightMap::IncreaseCapacityTo(thread, lwm, 9), JSTaggedValue::False());
362 }
363
HWTEST_F_L0(JSAPILightWeightMapTest,Iterator)364 HWTEST_F_L0(JSAPILightWeightMapTest, Iterator)
365 {
366 constexpr uint32_t NODE_NUMBERS = 8;
367 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
368 JSHandle<JSAPILightWeightMap> lwm(thread, CreateLightWeightMap());
369
370 JSMutableHandle<JSTaggedValue> key(thread, JSTaggedValue::Undefined());
371 JSMutableHandle<JSTaggedValue> value(thread, JSTaggedValue::Undefined());
372 for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
373 key.Update(JSTaggedValue(i));
374 value.Update(JSTaggedValue(i + 1));
375 JSAPILightWeightMap::Set(thread, lwm, key, value);
376 }
377
378 // test key or value
379 JSHandle<JSTaggedValue> keyIter(factory->NewJSAPILightWeightMapIterator(lwm, IterationKind::KEY));
380 JSHandle<JSTaggedValue> valueIter(factory->NewJSAPILightWeightMapIterator(lwm, IterationKind::VALUE));
381 JSMutableHandle<JSTaggedValue> keyIterResult(thread, JSTaggedValue::Undefined());
382 JSMutableHandle<JSTaggedValue> valueIterResult(thread, JSTaggedValue::Undefined());
383 JSMutableHandle<JSTaggedValue> keyHandle(thread, JSTaggedValue::Undefined());
384 for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
385 keyIterResult.Update(JSIterator::IteratorStep(thread, keyIter).GetTaggedValue());
386 valueIterResult.Update(JSIterator::IteratorStep(thread, valueIter).GetTaggedValue());
387 JSTaggedValue k = JSIterator::IteratorValue(thread, keyIterResult).GetTaggedValue();
388 keyHandle.Update(k);
389 JSTaggedValue v = JSIterator::IteratorValue(thread, valueIterResult).GetTaggedValue();
390 EXPECT_EQ(JSAPILightWeightMap::HasKey(thread, lwm, keyHandle), JSTaggedValue::True());
391 EXPECT_EQ(JSAPILightWeightMap::Get(thread, lwm, keyHandle), v);
392 }
393
394 // test key and value
395 for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
396 JSTaggedValue k = JSTaggedValue(i);
397 JSTaggedValue v = JSTaggedValue(i + 1);
398 keyHandle.Update(k);
399 EXPECT_EQ(JSAPILightWeightMap::HasKey(thread, lwm, keyHandle), JSTaggedValue::True());
400 EXPECT_EQ(JSAPILightWeightMap::Get(thread, lwm, keyHandle), v);
401 }
402 }
403
HWTEST_F_L0(JSAPILightWeightMapTest,IsEmptyHasValueHasAll)404 HWTEST_F_L0(JSAPILightWeightMapTest, IsEmptyHasValueHasAll)
405 {
406 constexpr uint32_t NODE_NUMBERS = 8;
407 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
408 JSHandle<JSAPILightWeightMap> lwp(thread, CreateLightWeightMap());
409 JSHandle<JSAPILightWeightMap> hasAllLwp(thread, CreateLightWeightMap());
410 JSMutableHandle<JSTaggedValue> key1(thread, JSTaggedValue::Undefined());
411 JSMutableHandle<JSTaggedValue> value1(thread, JSTaggedValue::Undefined());
412 JSMutableHandle<JSTaggedValue> value2(thread, JSTaggedValue::Undefined());
413 JSMutableHandle<JSTaggedValue> value3(thread, JSTaggedValue::Undefined());
414
415 std::string tValue;
416 // test IsEmpty
417 EXPECT_EQ(lwp->IsEmpty(), JSTaggedValue::True());
418 // test Set
419 std::string myKey1("mykey");
420 std::string myValue1("myvalue");
421 for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
422 std::string iKey1 = myKey1 + std::to_string(i);
423 std::string iValue1 = myValue1 + std::to_string(i + 1);
424 key1.Update(factory->NewFromStdString(iKey1).GetTaggedValue());
425 value1.Update(factory->NewFromStdString(iValue1).GetTaggedValue());
426 JSAPILightWeightMap::Set(thread, lwp, key1, value1);
427 }
428 EXPECT_EQ(lwp->GetLength(), NODE_NUMBERS);
429
430 // test HasValue
431 for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
432 tValue = myValue1 + std::to_string(i + 1);
433 value1.Update(factory->NewFromStdString(tValue).GetTaggedValue());
434 EXPECT_EQ(JSAPILightWeightMap::HasValue(thread, lwp, value1), JSTaggedValue::True());
435 }
436 tValue = myValue1 + std::to_string(NODE_NUMBERS + 1);
437 value1.Update(factory->NewFromStdString(tValue).GetTaggedValue());
438 EXPECT_EQ(JSAPILightWeightMap::HasValue(thread, lwp, value1), JSTaggedValue::False());
439
440 // test HasAll
441 for (uint32_t i = 0; i < NODE_NUMBERS - 5; i++) {
442 if (i == 1) {
443 std::string mykey2("destKey");
444 std::string myValue2("destValue");
445 std::string iKey2 = mykey2 + std::to_string(i);
446 std::string iValue2 = myValue2 + std::to_string(i);
447 key1.Update(factory->NewFromStdString(iKey2).GetTaggedValue());
448 value1.Update(factory->NewFromStdString(iValue2).GetTaggedValue());
449 JSAPILightWeightMap::Set(thread, hasAllLwp, key1, value1);
450 } else {
451 std::string iKey = myKey1 + std::to_string(i);
452 std::string iValue = myValue1 + std::to_string(i + 1);
453 key1.Update(factory->NewFromStdString(iValue).GetTaggedValue());
454 value1.Update(factory->NewFromStdString(iValue).GetTaggedValue());
455 JSAPILightWeightMap::Set(thread, hasAllLwp, key1, value2);
456 }
457 }
458 EXPECT_EQ(hasAllLwp->GetLength(), NODE_NUMBERS - 5);
459 EXPECT_EQ(JSAPILightWeightMap::HasAll(thread, lwp, hasAllLwp), JSTaggedValue::False());
460 EXPECT_EQ(JSAPILightWeightMap::HasAll(thread, hasAllLwp, lwp), JSTaggedValue::False());
461 }
462
463 /**
464 * @tc.name: GetIteratorObj
465 * @tc.desc:
466 * @tc.type: FUNC
467 * @tc.require:
468 */
HWTEST_F_L0(JSAPILightWeightMapTest,GetIteratorObj)469 HWTEST_F_L0(JSAPILightWeightMapTest, GetIteratorObj)
470 {
471 JSHandle<JSAPILightWeightMap> lwp(thread, CreateLightWeightMap());
472 JSHandle<JSTaggedValue> iteratorObj(thread, JSAPILightWeightMap::GetIteratorObj(
473 thread, lwp, IterationKind::KEY_AND_VALUE));
474 EXPECT_TRUE(iteratorObj->IsJSAPILightWeightMapIterator());
475 }
476 } // namespace panda::test
477