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
31using namespace panda;
32
33using namespace panda::ecmascript;
34
35using namespace panda::ecmascript::containers;
36
37namespace panda::test {
38class JSAPILightWeightMapTest : public BaseTestWithScope<false> {
39public:
40    const static int DEFAULT_SIZE = 8;
41
42protected:
43    JSAPILightWeightMap *CreateLightWeightMap()
44    {
45        return EcmaContainerCommon::CreateLightWeightMap(thread);
46    }
47
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
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
86HWTEST_F_L0(JSAPILightWeightMapTest, LightWeightMapCreate)
87{
88    JSAPILightWeightMap *lightWeightMap = CreateLightWeightMap();
89    EXPECT_TRUE(lightWeightMap != nullptr);
90}
91
92HWTEST_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
138HWTEST_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
150HWTEST_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
186HWTEST_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
206HWTEST_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
226HWTEST_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
252HWTEST_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
290HWTEST_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
300HWTEST_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
340HWTEST_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 */
405HWTEST_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