1/*
2 * Copyright (c) 2022-2024 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/containers/containers_private.h"
17#include "ecmascript/containers/containers_vector.h"
18#include "ecmascript/ecma_runtime_call_info.h"
19#include "ecmascript/global_env.h"
20#include "ecmascript/js_api/js_api_vector.h"
21#include "ecmascript/js_api/js_api_vector_iterator.h"
22#include "ecmascript/js_array.h"
23#include "ecmascript/js_handle.h"
24#include "ecmascript/js_object-inl.h"
25#include "ecmascript/js_tagged_value-inl.h"
26#include "ecmascript/js_thread.h"
27#include "ecmascript/object_factory.h"
28#include "ecmascript/tests/test_helper.h"
29#include "ecmascript/containers/tests/containers_test_helper.h"
30
31using namespace panda::ecmascript;
32using namespace panda::ecmascript::containers;
33
34namespace panda::test {
35class ContainersVectorTest : public testing::Test {
36public:
37    static void SetUpTestCase()
38    {
39        GTEST_LOG_(INFO) << "SetUpTestCase";
40    }
41
42    static void TearDownTestCase()
43    {
44        GTEST_LOG_(INFO) << "TearDownCase";
45    }
46
47    void SetUp() override
48    {
49        TestHelper::CreateEcmaVMWithScope(instance, thread, scope);
50    }
51
52    void TearDown() override
53    {
54        TestHelper::DestroyEcmaVMWithScope(instance, scope);
55    }
56
57    EcmaVM *instance {nullptr};
58    EcmaHandleScope *scope {nullptr};
59    JSThread *thread {nullptr};
60
61    class TestClass : public base::BuiltinsBase {
62    public:
63        static JSTaggedValue TestForEachFunc(EcmaRuntimeCallInfo *argv)
64        {
65            JSHandle<JSTaggedValue> value = GetCallArg(argv, 0);
66            JSHandle<JSTaggedValue> key = GetCallArg(argv, 1);
67            JSHandle<JSTaggedValue> vector = GetCallArg(argv, 2); // 2 means the secode arg
68            if (!vector->IsUndefined()) {
69                if (value->IsNumber()) {
70                    TaggedArray *elements = TaggedArray::Cast(JSAPIVector::Cast(vector.GetTaggedValue().
71                                            GetTaggedObject())->GetElements().GetTaggedObject());
72                    JSTaggedValue result = elements->Get(key->GetInt());
73                    EXPECT_EQ(result, value.GetTaggedValue());
74                }
75            }
76            return JSTaggedValue::Undefined();
77        }
78
79        static JSTaggedValue TestReplaceAllElementsFunc(EcmaRuntimeCallInfo *argv)
80        {
81            JSThread *thread = argv->GetThread();
82            JSHandle<JSTaggedValue> value = GetCallArg(argv, 0);
83            JSHandle<JSTaggedValue> index = GetCallArg(argv, 1);
84            JSHandle<JSTaggedValue> vector = GetCallArg(argv, 2); // 2 means the secode arg
85            if (!vector->IsUndefined()) {
86                if (value->IsNumber()) {
87                    JSHandle<JSTaggedValue> newValue(thread, JSTaggedValue(value->GetInt() * 2)); // 2 means mul by 2
88                    JSHandle<JSAPIVector>::Cast(vector)->Set(thread, index->GetNumber(), newValue.GetTaggedValue());
89                    return newValue.GetTaggedValue();
90                }
91            }
92            return JSTaggedValue::Undefined();
93        }
94    };
95protected:
96    JSTaggedValue InitializeVectorConstructor()
97    {
98        ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
99        JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
100
101        JSHandle<JSTaggedValue> globalObject = env->GetJSGlobalObject();
102        JSHandle<JSTaggedValue> key(factory->NewFromASCII("ArkPrivate"));
103        JSHandle<JSTaggedValue> value =
104            JSObject::GetProperty(thread, JSHandle<JSTaggedValue>(globalObject), key).GetValue();
105
106        auto objCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
107        objCallInfo->SetFunction(JSTaggedValue::Undefined());
108        objCallInfo->SetThis(value.GetTaggedValue());
109        objCallInfo->SetCallArg(0, JSTaggedValue(static_cast<int>(ContainerTag::Vector)));
110        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, objCallInfo);
111        JSTaggedValue result = ContainersPrivate::Load(objCallInfo);
112        TestHelper::TearDownFrame(thread, prev);
113
114        return result;
115    }
116
117    JSHandle<JSAPIVector> CreateJSAPIVector(JSTaggedValue compare = JSTaggedValue::Undefined())
118    {
119        JSHandle<JSTaggedValue> compareHandle(thread, compare);
120        JSHandle<JSFunction> newTarget(thread, InitializeVectorConstructor());
121        auto objCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
122        objCallInfo->SetFunction(newTarget.GetTaggedValue());
123        objCallInfo->SetNewTarget(newTarget.GetTaggedValue());
124        objCallInfo->SetThis(JSTaggedValue::Undefined());
125        objCallInfo->SetCallArg(0, compareHandle.GetTaggedValue());
126
127        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, objCallInfo);
128        JSTaggedValue result = ContainersVector::VectorConstructor(objCallInfo);
129        TestHelper::TearDownFrame(thread, prev);
130        JSHandle<JSAPIVector> vector(thread, result);
131        return vector;
132    }
133};
134
135// new vector
136HWTEST_F_L0(ContainersVectorTest, VectorConstructor)
137{
138    // Initialize twice and return directly the second time
139    InitializeVectorConstructor();
140    JSHandle<JSFunction> newTarget(thread, InitializeVectorConstructor());
141
142    auto objCallInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
143    objCallInfo->SetFunction(newTarget.GetTaggedValue());
144    objCallInfo->SetNewTarget(newTarget.GetTaggedValue());
145    objCallInfo->SetThis(JSTaggedValue::Undefined());
146
147    [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, objCallInfo);
148    JSTaggedValue result = ContainersVector::VectorConstructor(objCallInfo);
149    TestHelper::TearDownFrame(thread, prev);
150    ASSERT_TRUE(result.IsJSAPIVector());
151
152    JSHandle<JSAPIVector> setHandle(thread, result);
153    JSTaggedValue resultProto = JSTaggedValue::GetPrototype(thread, JSHandle<JSTaggedValue>(setHandle));
154    JSTaggedValue funcProto = newTarget->GetFunctionPrototype();
155    ASSERT_EQ(resultProto, funcProto);
156    int size = setHandle->GetSize();
157    ASSERT_EQ(size, 0);
158
159    // test VectorConstructor exception
160    objCallInfo->SetNewTarget(JSTaggedValue::Undefined());
161    CONTAINERS_API_EXCEPTION_TEST(ContainersVector, VectorConstructor, objCallInfo);
162}
163
164// add  has
165HWTEST_F_L0(ContainersVectorTest, AddAndHas)
166{
167    constexpr int32_t ELEMENT_NUMS = 8;
168    JSHandle<JSAPIVector> vector = CreateJSAPIVector();
169    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
170        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
171        callInfo->SetFunction(JSTaggedValue::Undefined());
172        callInfo->SetThis(vector.GetTaggedValue());
173        callInfo->SetCallArg(0, JSTaggedValue(i));
174
175        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
176        JSTaggedValue result = ContainersVector::Add(callInfo);
177        TestHelper::TearDownFrame(thread, prev);
178        EXPECT_TRUE(result.IsTrue());
179        EXPECT_EQ(vector->GetSize(), i + 1);
180    }
181    EXPECT_EQ(vector->GetSize(), ELEMENT_NUMS);
182
183    // test add insert string
184    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
185    JSMutableHandle<JSTaggedValue> key(thread, JSTaggedValue::Undefined());
186    std::string myKey("mykey");
187    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
188        std::string ikey = myKey + std::to_string(i);
189        key.Update(factory->NewFromStdString(ikey).GetTaggedValue());
190
191        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
192        callInfo->SetFunction(JSTaggedValue::Undefined());
193        callInfo->SetThis(vector.GetTaggedValue());
194        callInfo->SetCallArg(0, key.GetTaggedValue());
195
196        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
197        JSTaggedValue result = ContainersVector::Add(callInfo);
198        TestHelper::TearDownFrame(thread, prev);
199        EXPECT_TRUE(result.IsTrue());
200        EXPECT_EQ(vector->GetSize(), ELEMENT_NUMS + i + 1);
201    }
202    EXPECT_EQ(vector->GetSize(), ELEMENT_NUMS * 2);
203
204    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
205        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
206        callInfo->SetFunction(JSTaggedValue::Undefined());
207        callInfo->SetThis(vector.GetTaggedValue());
208        callInfo->SetCallArg(0, JSTaggedValue(i));
209        callInfo->SetCallArg(1, JSTaggedValue(i));
210
211        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
212        ContainersVector::Insert(callInfo);
213        TestHelper::TearDownFrame(thread, prev);
214        EXPECT_EQ(vector->GetSize(), ELEMENT_NUMS * 2 + i + 1);
215    }
216    EXPECT_EQ(vector->GetSize(), ELEMENT_NUMS * 3);
217
218    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
219        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
220        callInfo->SetFunction(JSTaggedValue::Undefined());
221        callInfo->SetThis(vector.GetTaggedValue());
222        callInfo->SetCallArg(0, JSTaggedValue(i));
223
224        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
225        JSTaggedValue result = ContainersVector::Has(callInfo);
226        TestHelper::TearDownFrame(thread, prev);
227        EXPECT_TRUE(result.IsTrue());
228    }
229    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
230        std::string ikey = myKey + std::to_string(i);
231        key.Update(factory->NewFromStdString(ikey).GetTaggedValue());
232
233        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
234        callInfo->SetFunction(JSTaggedValue::Undefined());
235        callInfo->SetThis(vector.GetTaggedValue());
236        callInfo->SetCallArg(0, key.GetTaggedValue());
237
238        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
239        JSTaggedValue result = ContainersVector::Has(callInfo);
240        TestHelper::TearDownFrame(thread, prev);
241        EXPECT_TRUE(result.IsTrue());
242    }
243}
244
245// getIndexOf  getLastIndexOf
246HWTEST_F_L0(ContainersVectorTest, GetFirstValueAndGetLastValue)
247{
248    constexpr int32_t ELEMENT_NUMS = 8;
249    JSHandle<JSAPIVector> vector = CreateJSAPIVector();
250    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
251        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
252        callInfo->SetFunction(JSTaggedValue::Undefined());
253        callInfo->SetThis(vector.GetTaggedValue());
254        callInfo->SetCallArg(0, JSTaggedValue(i));
255
256        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
257        JSTaggedValue result = ContainersVector::Add(callInfo);
258        TestHelper::TearDownFrame(thread, prev);
259        EXPECT_TRUE(result.IsTrue());
260        // double
261        result = ContainersVector::Add(callInfo);
262        TestHelper::TearDownFrame(thread, prev);
263        EXPECT_TRUE(result.IsTrue());
264        EXPECT_EQ(vector->GetSize(), 2 * (i + 1));
265    }
266    EXPECT_EQ(vector->GetSize(), ELEMENT_NUMS * 2);
267
268    // getIndexOf
269    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
270        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
271        callInfo->SetFunction(JSTaggedValue::Undefined());
272        callInfo->SetThis(vector.GetTaggedValue());
273        callInfo->SetCallArg(0, JSTaggedValue(i));
274
275        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
276        JSTaggedValue result = ContainersVector::GetIndexOf(callInfo);
277        TestHelper::TearDownFrame(thread, prev);
278        EXPECT_EQ(result, JSTaggedValue(2 * i));
279    }
280    // getLastIndexOf
281    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
282        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
283        callInfo->SetFunction(JSTaggedValue::Undefined());
284        callInfo->SetThis(vector.GetTaggedValue());
285        callInfo->SetCallArg(0, JSTaggedValue(i));
286
287        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
288        JSTaggedValue result = ContainersVector::GetLastIndexOf(callInfo);
289        TestHelper::TearDownFrame(thread, prev);
290        EXPECT_EQ(result, JSTaggedValue(2 * i + 1));
291    }
292    // getFirstElement
293    {
294        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
295        callInfo->SetFunction(JSTaggedValue::Undefined());
296        callInfo->SetThis(vector.GetTaggedValue());
297
298        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
299        JSTaggedValue result = ContainersVector::GetFirstElement(callInfo);
300        TestHelper::TearDownFrame(thread, prev);
301        EXPECT_EQ(result, JSTaggedValue(0));
302    }
303    // getLastElement
304    {
305        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
306        callInfo->SetFunction(JSTaggedValue::Undefined());
307        callInfo->SetThis(vector.GetTaggedValue());
308
309        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
310        JSTaggedValue result = ContainersVector::GetLastElement(callInfo);
311        TestHelper::TearDownFrame(thread, prev);
312        EXPECT_EQ(result, JSTaggedValue(7));
313    }
314}
315
316// removeByIndex  remove  removeByRange  clear  isEmpty
317HWTEST_F_L0(ContainersVectorTest, RemoveByIndexAndRemoveAndRemoveRangeAndClear)
318{
319    // add
320    constexpr int32_t ELEMENT_NUMS = 8;
321    JSHandle<JSAPIVector> vector = CreateJSAPIVector();
322    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
323        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
324        callInfo->SetFunction(JSTaggedValue::Undefined());
325        callInfo->SetThis(vector.GetTaggedValue());
326        callInfo->SetCallArg(0, JSTaggedValue(i));
327
328        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
329        JSTaggedValue result = ContainersVector::Add(callInfo);
330        TestHelper::TearDownFrame(thread, prev);
331        EXPECT_TRUE(result.IsTrue());
332        EXPECT_EQ(vector->GetSize(), i + 1);
333    }
334
335    // removeByIndex
336    {
337        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
338        callInfo->SetFunction(JSTaggedValue::Undefined());
339        callInfo->SetThis(vector.GetTaggedValue());
340        callInfo->SetCallArg(0, JSTaggedValue(0));
341
342        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
343        JSTaggedValue result = ContainersVector::RemoveByIndex(callInfo);
344        TestHelper::TearDownFrame(thread, prev);
345        EXPECT_EQ(result, JSTaggedValue(0));
346        EXPECT_EQ(vector->GetSize(), 7);
347    }
348    // remove fail
349    {
350        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
351        callInfo->SetFunction(JSTaggedValue::Undefined());
352        callInfo->SetThis(vector.GetTaggedValue());
353        callInfo->SetCallArg(0, JSTaggedValue(0));
354
355        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
356        JSTaggedValue result = ContainersVector::Remove(callInfo);
357        TestHelper::TearDownFrame(thread, prev);
358        EXPECT_TRUE(result.IsFalse());
359        EXPECT_EQ(vector->GetSize(), 7);
360    }
361    // remove success
362    {
363        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
364        callInfo->SetFunction(JSTaggedValue::Undefined());
365        callInfo->SetThis(vector.GetTaggedValue());
366        callInfo->SetCallArg(0, JSTaggedValue(1));
367
368        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
369        JSTaggedValue result = ContainersVector::Remove(callInfo);
370        TestHelper::TearDownFrame(thread, prev);
371        EXPECT_TRUE(result.IsTrue());
372        EXPECT_EQ(vector->GetSize(), 6);
373    }
374    // removeByRange
375    {
376        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
377        callInfo->SetFunction(JSTaggedValue::Undefined());
378        callInfo->SetThis(vector.GetTaggedValue());
379        callInfo->SetCallArg(0, JSTaggedValue(4));
380        callInfo->SetCallArg(1, JSTaggedValue(2));
381
382        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
383        ContainersVector::RemoveByRange(callInfo);
384        TestHelper::TearDownFrame(thread, prev);
385        EXPECT_EQ(vector->GetSize(), 6);
386    }
387    // isEmpty
388    {
389        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
390        callInfo->SetFunction(JSTaggedValue::Undefined());
391        callInfo->SetThis(vector.GetTaggedValue());
392
393        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
394        JSTaggedValue result = ContainersVector::IsEmpty(callInfo);
395        TestHelper::TearDownFrame(thread, prev);
396        EXPECT_TRUE(result.IsFalse());
397    }
398    // clear
399    {
400        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
401        callInfo->SetFunction(JSTaggedValue::Undefined());
402        callInfo->SetThis(vector.GetTaggedValue());
403
404        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
405        ContainersVector::Clear(callInfo);
406        TestHelper::TearDownFrame(thread, prev);
407        EXPECT_EQ(vector->GetSize(), 0);
408    }
409    // isEmpty
410    {
411        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
412        callInfo->SetFunction(JSTaggedValue::Undefined());
413        callInfo->SetThis(vector.GetTaggedValue());
414
415        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
416        JSTaggedValue result = ContainersVector::IsEmpty(callInfo);
417        TestHelper::TearDownFrame(thread, prev);
418        EXPECT_TRUE(result.IsTrue());
419    }
420}
421
422// replaceAllElements  forEach
423HWTEST_F_L0(ContainersVectorTest, ReplaceAllElementsAndForEach)
424{
425    constexpr int32_t ELEMENT_NUMS = 8;
426    JSHandle<JSAPIVector> vector = CreateJSAPIVector();
427    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
428        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
429        callInfo->SetFunction(JSTaggedValue::Undefined());
430        callInfo->SetThis(vector.GetTaggedValue());
431        callInfo->SetCallArg(0, JSTaggedValue(i));
432
433        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
434        JSTaggedValue result = ContainersVector::Add(callInfo);
435        TestHelper::TearDownFrame(thread, prev);
436        EXPECT_TRUE(result.IsTrue());
437        EXPECT_EQ(vector->GetSize(), i + 1);
438    }
439    EXPECT_EQ(vector->GetSize(), ELEMENT_NUMS);
440
441    // forEach
442    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
443    JSHandle<JSAPIVector> vec = CreateJSAPIVector();
444    {
445        JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
446        JSHandle<JSFunction> func = factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestForEachFunc));
447        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
448        callInfo->SetFunction(JSTaggedValue::Undefined());
449        callInfo->SetThis(vector.GetTaggedValue());
450        callInfo->SetCallArg(0, func.GetTaggedValue());
451        callInfo->SetCallArg(1, vec.GetTaggedValue());
452
453        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
454        ContainersVector::ForEach(callInfo);
455        TestHelper::TearDownFrame(thread, prev);
456        for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
457            auto callInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
458            callInfo1->SetFunction(JSTaggedValue::Undefined());
459            callInfo1->SetThis(vector.GetTaggedValue());
460            callInfo1->SetCallArg(0, JSTaggedValue(i));
461
462            [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, callInfo1);
463            JSTaggedValue result = ContainersVector::Get(callInfo1);
464            TestHelper::TearDownFrame(thread, prev1);
465            EXPECT_EQ(result, JSTaggedValue(i));
466        }
467    }
468
469    // replaceAllElements
470    {
471        JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
472        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
473        JSHandle<JSFunction> func =
474            factory->NewJSFunction(env, reinterpret_cast<void *>(TestClass::TestReplaceAllElementsFunc));
475        callInfo->SetFunction(JSTaggedValue::Undefined());
476        callInfo->SetThis(vector.GetTaggedValue());
477        callInfo->SetCallArg(0, func.GetTaggedValue());
478
479        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
480        ContainersVector::ReplaceAllElements(callInfo);
481        TestHelper::TearDownFrame(thread, prev);
482        for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
483            auto callInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
484            callInfo1->SetFunction(JSTaggedValue::Undefined());
485            callInfo1->SetThis(vector.GetTaggedValue());
486            callInfo1->SetCallArg(0, JSTaggedValue(i));
487
488            [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, callInfo1);
489            JSTaggedValue result = ContainersVector::Get(callInfo1);
490            TestHelper::TearDownFrame(thread, prev1);
491            EXPECT_EQ(result, JSTaggedValue(i * 2));
492        }
493    }
494}
495
496// sort
497HWTEST_F_L0(ContainersVectorTest, Sort)
498{
499    constexpr int32_t ELEMENT_NUMS = 8;
500    JSHandle<JSAPIVector> vector = CreateJSAPIVector();
501    for (int32_t i = ELEMENT_NUMS - 1; i >= 0; i--) {
502        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
503        callInfo->SetFunction(JSTaggedValue::Undefined());
504        callInfo->SetThis(vector.GetTaggedValue());
505        callInfo->SetCallArg(0, JSTaggedValue(i));
506
507        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
508        JSTaggedValue result = ContainersVector::Add(callInfo);
509        TestHelper::TearDownFrame(thread, prev);
510        EXPECT_TRUE(result.IsTrue());
511    }
512    EXPECT_EQ(vector->GetSize(), ELEMENT_NUMS);
513
514    // sort
515    {
516        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
517        callInfo->SetFunction(JSTaggedValue::Undefined());
518        callInfo->SetThis(vector.GetTaggedValue());
519        callInfo->SetCallArg(0, JSTaggedValue::Undefined());
520
521        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
522        ContainersVector::Sort(callInfo);
523        TestHelper::TearDownFrame(thread, prev);
524
525        for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
526            auto callInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
527            callInfo1->SetFunction(JSTaggedValue::Undefined());
528            callInfo1->SetThis(vector.GetTaggedValue());
529            callInfo1->SetCallArg(0, JSTaggedValue(i));
530
531            [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, callInfo1);
532            JSTaggedValue result = ContainersVector::Get(callInfo1);
533            TestHelper::TearDownFrame(thread, prev1);
534            EXPECT_EQ(result, JSTaggedValue(i));
535        }
536    }
537}
538
539// clone  convertToArray  copyToArray
540HWTEST_F_L0(ContainersVectorTest, CloneAndConvertToArrayAndCopyToArray)
541{
542    constexpr int32_t ELEMENT_NUMS = 8;
543    JSHandle<JSAPIVector> vector = CreateJSAPIVector();
544    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
545        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
546        callInfo->SetFunction(JSTaggedValue::Undefined());
547        callInfo->SetThis(vector.GetTaggedValue());
548        callInfo->SetCallArg(0, JSTaggedValue(i));
549
550        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
551        JSTaggedValue result = ContainersVector::Add(callInfo);
552        TestHelper::TearDownFrame(thread, prev);
553        EXPECT_TRUE(result.IsTrue());
554        EXPECT_EQ(vector->GetSize(), i + 1);
555    }
556    EXPECT_EQ(vector->GetSize(), ELEMENT_NUMS);
557    // clone
558    {
559        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
560        callInfo->SetFunction(JSTaggedValue::Undefined());
561        callInfo->SetThis(vector.GetTaggedValue());
562
563        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
564        JSTaggedValue vec = ContainersVector::Clone(callInfo);
565        TestHelper::TearDownFrame(thread, prev);
566        JSHandle<JSAPIVector> handleVec(thread, vec);
567        EXPECT_EQ(handleVec->GetSize(), vector->GetSize());
568
569        for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
570            auto callInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
571            callInfo1->SetFunction(JSTaggedValue::Undefined());
572            callInfo1->SetThis(vec);
573            callInfo1->SetCallArg(0, JSTaggedValue(i));
574
575            [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, callInfo1);
576            JSTaggedValue result = ContainersVector::Get(callInfo1);
577            TestHelper::TearDownFrame(thread, prev1);
578            EXPECT_EQ(result, JSTaggedValue(i));
579        }
580    }
581    // convertToArray
582    {
583        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
584        callInfo->SetFunction(JSTaggedValue::Undefined());
585        callInfo->SetThis(vector.GetTaggedValue());
586
587        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
588        JSTaggedValue arr = ContainersVector::ConvertToArray(callInfo);
589        TestHelper::TearDownFrame(thread, prev);
590        EXPECT_TRUE(arr.IsJSArray());
591        JSHandle<JSTaggedValue> handleArr(thread, arr);
592        JSHandle<TaggedArray> taggedArr = JSArray::ToTaggedArray(thread, handleArr);
593        for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
594            JSTaggedValue result = taggedArr->Get(i);
595            EXPECT_EQ(result, JSTaggedValue(i));
596        }
597    }
598    // copyToArray
599    {
600        ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
601        JSHandle<JSArray> array = factory->NewJSArray();
602        JSHandle<TaggedArray> arrayElement = factory->NewTaggedArray(ELEMENT_NUMS, JSTaggedValue::Hole());
603        array->SetElements(thread, arrayElement);
604        array->SetArrayLength(thread, static_cast<uint32_t>(ELEMENT_NUMS));
605        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
606        callInfo->SetFunction(JSTaggedValue::Undefined());
607        callInfo->SetThis(vector.GetTaggedValue());
608        callInfo->SetCallArg(0, array.GetTaggedValue());
609
610        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
611        ContainersVector::CopyToArray(callInfo);
612        TestHelper::TearDownFrame(thread, prev);
613        EXPECT_TRUE(array->IsJSArray());
614        for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
615            auto callInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
616            callInfo1->SetFunction(JSTaggedValue::Undefined());
617            callInfo1->SetThis(array.GetTaggedValue());
618            callInfo1->SetCallArg(0, JSTaggedValue(i));
619
620            [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, callInfo1);
621            int result = JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(array), i).GetValue()->GetInt();
622            TestHelper::TearDownFrame(thread, prev1);
623            EXPECT_EQ(result, i);
624        }
625
626        JSHandle<JSArray> longArray = factory->NewJSArray();
627        JSHandle<TaggedArray> longArrayElement = factory->NewTaggedArray(ELEMENT_NUMS * 2, JSTaggedValue::Hole());
628        longArray->SetElements(thread, longArrayElement);
629        longArray->SetArrayLength(thread, static_cast<uint32_t>(ELEMENT_NUMS * 2));
630        auto callInfo2 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
631        callInfo2->SetFunction(JSTaggedValue::Undefined());
632        callInfo2->SetThis(vector.GetTaggedValue());
633        callInfo2->SetCallArg(0, longArray.GetTaggedValue());
634
635        [[maybe_unused]] auto prev2 = TestHelper::SetupFrame(thread, callInfo2);
636        ContainersVector::CopyToArray(callInfo2);
637        TestHelper::TearDownFrame(thread, prev2);
638        EXPECT_TRUE(longArray->IsJSArray());
639        for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
640            auto callInfo3 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
641            callInfo3->SetFunction(JSTaggedValue::Undefined());
642            callInfo3->SetThis(longArray.GetTaggedValue());
643            callInfo3->SetCallArg(0, JSTaggedValue(i));
644
645            [[maybe_unused]] auto prev4 = TestHelper::SetupFrame(thread, callInfo3);
646            int result1 = JSArray::GetProperty(thread, JSHandle<JSTaggedValue>(longArray), i).GetValue()->GetInt();
647            TestHelper::TearDownFrame(thread, prev4);
648            EXPECT_EQ(result1, i);
649        }
650        for (int32_t i = ELEMENT_NUMS; i < ELEMENT_NUMS * 2; i++) {
651            auto callInfo4 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
652            callInfo4->SetFunction(JSTaggedValue::Undefined());
653            callInfo4->SetThis(longArray.GetTaggedValue());
654            callInfo4->SetCallArg(0, JSTaggedValue(i));
655
656            [[maybe_unused]] auto prev5 = TestHelper::SetupFrame(thread, callInfo4);
657            JSHandle<JSTaggedValue> result2 = JSArray::GetProperty(thread,
658                JSHandle<JSTaggedValue>(longArray), i).GetValue();
659            TestHelper::TearDownFrame(thread, prev5);
660            EXPECT_EQ(result2.GetTaggedValue(), JSTaggedValue::Undefined());
661        }
662    }
663}
664
665// subVector  getCapacity  trimToCurrentLength  increaseCapacityTo
666HWTEST_F_L0(ContainersVectorTest, SubVectorAndGetCapacityAndTrimToCurrentLengthAndIncreaseCapacityTo)
667{
668    constexpr int32_t ELEMENT_NUMS = 8;
669    JSHandle<JSAPIVector> vector = CreateJSAPIVector();
670    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
671        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
672        callInfo->SetFunction(JSTaggedValue::Undefined());
673        callInfo->SetThis(vector.GetTaggedValue());
674        callInfo->SetCallArg(0, JSTaggedValue(i));
675
676        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
677        JSTaggedValue result = ContainersVector::Add(callInfo);
678        TestHelper::TearDownFrame(thread, prev);
679        EXPECT_TRUE(result.IsTrue());
680        EXPECT_EQ(vector->GetSize(), i + 1);
681    }
682    EXPECT_EQ(vector->GetSize(), ELEMENT_NUMS);
683
684    // getCapacity
685    {
686        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
687        callInfo->SetFunction(JSTaggedValue::Undefined());
688        callInfo->SetThis(vector.GetTaggedValue());
689
690        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
691        int32_t capacity = ContainersVector::GetCapacity(callInfo).GetInt();
692        TestHelper::TearDownFrame(thread, prev);
693        EXPECT_EQ(capacity, 10);
694    }
695    // increaseCapacityTo
696    {
697        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
698        callInfo->SetFunction(JSTaggedValue::Undefined());
699        callInfo->SetThis(vector.GetTaggedValue());
700        callInfo->SetCallArg(0, JSTaggedValue(20));
701
702        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
703        ContainersVector::IncreaseCapacityTo(callInfo);
704        TestHelper::TearDownFrame(thread, prev);
705    }
706    // getCapacity
707    {
708        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
709        callInfo->SetFunction(JSTaggedValue::Undefined());
710        callInfo->SetThis(vector.GetTaggedValue());
711
712        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
713        int32_t newCapacity1 = ContainersVector::GetCapacity(callInfo).GetInt();
714        TestHelper::TearDownFrame(thread, prev);
715        EXPECT_EQ(newCapacity1, 20);
716    }
717    // trimToCurrentLength
718    {
719        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
720        callInfo->SetFunction(JSTaggedValue::Undefined());
721        callInfo->SetThis(vector.GetTaggedValue());
722
723        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
724        ContainersVector::TrimToCurrentLength(callInfo);
725        TestHelper::TearDownFrame(thread, prev);
726    }
727    // getCapacity
728    {
729        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
730        callInfo->SetFunction(JSTaggedValue::Undefined());
731        callInfo->SetThis(vector.GetTaggedValue());
732
733        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
734        int32_t newCapacity2 = ContainersVector::GetCapacity(callInfo).GetInt();
735        TestHelper::TearDownFrame(thread, prev);
736        EXPECT_EQ(newCapacity2, 8);
737    }
738    // subVector
739    {
740        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
741        callInfo->SetFunction(JSTaggedValue::Undefined());
742        callInfo->SetThis(vector.GetTaggedValue());
743        callInfo->SetCallArg(0, JSTaggedValue(0));
744        callInfo->SetCallArg(1, JSTaggedValue(2));
745
746        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
747        JSTaggedValue vec = ContainersVector::SubVector(callInfo);
748        for (int32_t i = 0; i < 2; i++) {
749            auto callInfo1 = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
750            callInfo1->SetFunction(JSTaggedValue::Undefined());
751            callInfo1->SetThis(vec);
752            callInfo1->SetCallArg(0, JSTaggedValue(i));
753
754            [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, callInfo1);
755            JSTaggedValue result = ContainersVector::Get(callInfo1);
756            TestHelper::TearDownFrame(thread, prev);
757            EXPECT_EQ(result, JSTaggedValue(i));
758        }
759    }
760}
761
762// toString  getLastIndexFrom  getIndexFrom
763HWTEST_F_L0(ContainersVectorTest, ToStringAndGetLastIndexFromAndGetIndexFrom)
764{
765    constexpr int32_t ELEMENT_NUMS = 8;
766    JSHandle<JSAPIVector> vector = CreateJSAPIVector();
767    for (int32_t i = 0; i < ELEMENT_NUMS; i++) {
768        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 6);
769        callInfo->SetFunction(JSTaggedValue::Undefined());
770        callInfo->SetThis(vector.GetTaggedValue());
771        callInfo->SetCallArg(0, JSTaggedValue(i));
772
773        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
774        JSTaggedValue result = ContainersVector::Add(callInfo);
775        TestHelper::TearDownFrame(thread, prev);
776        EXPECT_TRUE(result.IsTrue());
777        EXPECT_EQ(vector->GetSize(), i + 1);
778    }
779    EXPECT_EQ(vector->GetSize(), ELEMENT_NUMS);
780    // toString
781    {
782        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 4);
783        callInfo->SetFunction(JSTaggedValue::Undefined());
784        callInfo->SetThis(vector.GetTaggedValue());
785        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
786        JSTaggedValue result = ContainersVector::ToString(callInfo);
787
788        EXPECT_TRUE(result.IsString());
789    }
790    // getLastIndexFrom
791    {
792        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
793        callInfo->SetFunction(JSTaggedValue::Undefined());
794        callInfo->SetThis(vector.GetTaggedValue());
795        callInfo->SetCallArg(0, JSTaggedValue(1));
796        callInfo->SetCallArg(1, JSTaggedValue(3));
797
798        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
799        JSTaggedValue result = ContainersVector::GetLastIndexFrom(callInfo);
800        TestHelper::TearDownFrame(thread, prev);
801        EXPECT_TRUE(JSTaggedValue::SameValue(result, JSTaggedValue(1)));
802    }
803    // getIndexFrom
804    {
805        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
806        callInfo->SetFunction(JSTaggedValue::Undefined());
807        callInfo->SetThis(vector.GetTaggedValue());
808        callInfo->SetCallArg(0, JSTaggedValue(1));
809        callInfo->SetCallArg(1, JSTaggedValue(3));
810
811        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
812        JSTaggedValue result = ContainersVector::GetIndexFrom(callInfo);
813        TestHelper::TearDownFrame(thread, prev);
814        EXPECT_TRUE(JSTaggedValue::SameValue(result, JSTaggedValue(-1)));
815    }
816    // getIndexFrom
817    {
818        auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
819        callInfo->SetFunction(JSTaggedValue::Undefined());
820        callInfo->SetThis(vector.GetTaggedValue());
821        callInfo->SetCallArg(0, JSTaggedValue(10));
822        callInfo->SetCallArg(1, JSTaggedValue(0));
823
824        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
825        JSTaggedValue result = ContainersVector::GetIndexFrom(callInfo);
826        TestHelper::TearDownFrame(thread, prev);
827        EXPECT_TRUE(JSTaggedValue::SameValue(result, JSTaggedValue(-1)));
828    }
829}
830
831HWTEST_F_L0(ContainersVectorTest, ProxyOfGetSizeSetLength)
832{
833    constexpr uint32_t NODE_NUMBERS = 8;
834    JSHandle<JSAPIVector> vector = CreateJSAPIVector();
835    auto callInfo = TestHelper::CreateEcmaRuntimeCallInfo(thread, JSTaggedValue::Undefined(), 8);
836    callInfo->SetFunction(JSTaggedValue::Undefined());
837    JSHandle<JSProxy> proxy = CreateJSProxyHandle(thread);
838    proxy->SetTarget(thread, vector.GetTaggedValue());
839    callInfo->SetThis(proxy.GetTaggedValue());
840
841    for (uint32_t i = 0; i < NODE_NUMBERS; i++) {
842        callInfo->SetCallArg(0, JSTaggedValue(i));
843        callInfo->SetCallArg(1, JSTaggedValue(i + 1));
844        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
845        ContainersVector::Add(callInfo);
846        TestHelper::TearDownFrame(thread, prev);
847
848        [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, callInfo);
849        JSTaggedValue retult = ContainersVector::GetSize(callInfo);
850        TestHelper::TearDownFrame(thread, prev1);
851        EXPECT_EQ(retult, JSTaggedValue(i + 1));
852    }
853
854
855    // SetLength
856    {
857        callInfo->SetCallArg(0, JSTaggedValue(NODE_NUMBERS * 2));
858
859        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
860        ContainersVector::SetLength(callInfo);
861        TestHelper::TearDownFrame(thread, prev);
862
863        [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, callInfo);
864        JSTaggedValue result = ContainersVector::GetSize(callInfo);
865        TestHelper::TearDownFrame(thread, prev1);
866
867        EXPECT_TRUE(JSTaggedValue::SameValue(result, JSTaggedValue(NODE_NUMBERS * 2)));
868    }
869
870    // SetLength
871    {
872        callInfo->SetCallArg(0, JSTaggedValue(NODE_NUMBERS / 2));
873
874        [[maybe_unused]] auto prev = TestHelper::SetupFrame(thread, callInfo);
875        ContainersVector::SetLength(callInfo);
876        TestHelper::TearDownFrame(thread, prev);
877
878        [[maybe_unused]] auto prev1 = TestHelper::SetupFrame(thread, callInfo);
879        JSTaggedValue result = ContainersVector::GetSize(callInfo);
880        TestHelper::TearDownFrame(thread, prev1);
881
882        EXPECT_TRUE(JSTaggedValue::SameValue(result, JSTaggedValue(NODE_NUMBERS / 2)));
883    }
884}
885
886HWTEST_F_L0(ContainersVectorTest, ExceptionReturn1)
887{
888    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, Insert);
889    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, SetLength);
890    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, IncreaseCapacityTo);
891    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, Get);
892    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, GetIndexFrom);
893    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, Add);
894    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, GetCapacity);
895    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, GetIndexOf);
896    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, IsEmpty);
897
898    JSHandle<JSAPIVector> vector = CreateJSAPIVector();
899    {
900        auto callInfo = NewEmptyCallInfo(thread);
901        callInfo->SetThis(vector.GetTaggedValue());
902        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, Insert, callInfo);
903    }
904    {
905        auto callInfo = NewEmptyCallInfo(thread);
906        callInfo->SetThis(vector.GetTaggedValue());
907        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, SetLength, callInfo);
908    }
909    {
910        auto callInfo = NewEmptyCallInfo(thread);
911        callInfo->SetThis(vector.GetTaggedValue());
912        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, IncreaseCapacityTo, callInfo);
913    }
914    {
915        auto callInfo = NewEmptyCallInfo(thread);
916        callInfo->SetThis(vector.GetTaggedValue());
917        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, Get, callInfo);
918    }
919    {
920        auto callInfo = NewEmptyCallInfo(thread);
921        callInfo->SetThis(vector.GetTaggedValue());
922        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, GetIndexFrom, callInfo);
923    }
924    {
925        auto callInfo = NewEmptyCallInfo(thread);
926        callInfo->SetThis(vector.GetTaggedValue());
927        callInfo->SetCallArg(0, JSTaggedValue(-1));
928        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, SetLength, callInfo);
929    }
930}
931
932HWTEST_F_L0(ContainersVectorTest, ExceptionReturn2)
933{
934    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, GetLastIndexFrom);
935    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, RemoveByIndex);
936    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, RemoveByRange);
937    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, GetLastElement);
938    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, GetLastIndexOf);
939    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, Remove);
940
941    JSHandle<JSAPIVector> vector = CreateJSAPIVector();
942    {
943        auto callInfo = NewEmptyCallInfo(thread);
944        callInfo->SetThis(vector.GetTaggedValue());
945        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, GetLastIndexFrom, callInfo);
946    }
947    {
948        auto callInfo = NewEmptyCallInfo(thread);
949        callInfo->SetThis(vector.GetTaggedValue());
950        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, RemoveByIndex, callInfo);
951    }
952    {
953        auto callInfo = NewEmptyCallInfo(thread);
954        callInfo->SetThis(vector.GetTaggedValue());
955        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, RemoveByRange, callInfo);
956    }
957}
958
959HWTEST_F_L0(ContainersVectorTest, ExceptionReturn3)
960{
961    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, Set);
962    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, SubVector);
963    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, ReplaceAllElements);
964    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, ToString);
965    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, GetSize);
966    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, ForEach);
967    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, TrimToCurrentLength);
968    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, Clear);
969
970    JSHandle<JSAPIVector> vector = CreateJSAPIVector();
971    {
972        auto callInfo = NewEmptyCallInfo(thread);
973        callInfo->SetThis(vector.GetTaggedValue());
974        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, Set, callInfo);
975    }
976    {
977        auto callInfo = NewEmptyCallInfo(thread);
978        callInfo->SetThis(vector.GetTaggedValue());
979        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, SubVector, callInfo);
980    }
981    {
982        auto callInfo = NewEmptyCallInfo(thread);
983        callInfo->SetThis(vector.GetTaggedValue());
984        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, ReplaceAllElements, callInfo);
985    }
986    {
987        auto callInfo = NewEmptyCallInfo(thread);
988        callInfo->SetThis(vector.GetTaggedValue());
989        callInfo->SetCallArg(0, JSTaggedValue(-1));
990        CONTAINERS_API_EXCEPTION_TEST(ContainersVector, Set, callInfo);
991    }
992}
993
994HWTEST_F_L0(ContainersVectorTest, ExceptionReturn4)
995{
996    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, Clone);
997    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, Has);
998    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, CopyToArray);
999    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, ConvertToArray);
1000    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, GetFirstElement);
1001    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, Sort);
1002    CONTAINERS_API_TYPE_MISMATCH_EXCEPTION_TEST(ContainersVector, GetIteratorObj);
1003}
1004} // namespace panda::test