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/*
17 * @tc.name:container
18 * @tc.desc:test container
19 * @tc.type: FUNC
20 * @tc.require: issueI5NO8G
21 */
22import {testdProxyArray1}  from "./utility";
23
24var arrayList = undefined;
25if (globalThis["ArkPrivate"] != undefined) {
26    arrayList = ArkPrivate.Load(ArkPrivate.ArrayList);
27    let arr = new arrayList();
28    arr.add(1);
29    arr.add(2);
30
31    let map = new Map();
32    let flag1 = false;
33    try {
34        arr["aa"] = 3;
35    } catch (e) {
36        flag1 = true;
37    }
38    map.set("flag1", flag1);
39
40    let flag2 = true;
41    for (let i = 0; i < arr.length; i++) {
42        if (arr[i] != (i + 1)) {
43            flag2 = false;
44            break;
45        }
46    }
47    map.set("flag2", flag2);
48
49    let arr1 = new arrayList();
50    let proxy = new Proxy(arr1, {});
51    let testArray = []
52    let res = true
53    for(let i = 0; i < 10; i++) {
54        proxy.add(i)
55        testArray.push(i)
56    }
57
58    for(let i = 0; i < testArray.length; i++) {
59        if (proxy[i] !== testArray[i]) {
60            res = false
61        }
62    }
63    map.set("test arraylist add:", res)
64
65    map.set("test arraylist has:", proxy.has(2))
66    map.set("test arraylist getCapacity:", proxy.getCapacity() === 15)
67    map.set("test arraylist getLastIndexOf:", proxy.getLastIndexOf(1) === 1)
68    map.set("test arraylist getIndexOf:", proxy.getIndexOf(5) === 5)
69
70    let array = proxy.convertToArray()
71    res = true
72    for(let i = 0; i < testArray.length; i++) {
73        if (array[i] !== testArray[i]) {
74            res = false
75        }
76    }
77
78    map.set("test arraylist convertToArray:", res)
79
80    let newArrayList = proxy.clone()
81    res = true
82    for(let i = 0; i < testArray.length; i++) {
83        if (newArrayList[i] !== testArray[i]) {
84            res = false
85        }
86    }
87    map.set("test arraylist clone:", res)
88
89    proxy.insert(999, 3)
90    testArray.splice(3, 0, 999)
91    res = true
92    for(let i = 0; i < testArray.length; i++) {
93        if (proxy[i] !== testArray[i]) {
94            res = false
95        }
96    }
97    map.set("test arraylist insert:", res)
98
99    proxy.removeByIndex(9)
100    testArray.splice(9, 1)
101    res = true
102    for(let i = 0; i < testArray.length; i++) {
103        if (proxy[i] !== testArray[i]) {
104            res = false
105        }
106    }
107    map.set("test arraylist removeByIndex:", res)
108
109    const removeRes = proxy.remove(7)
110    testArray.splice(8, 1)
111    res = true
112    for(let i = 0; i < testArray.length; i++) {
113        if (proxy[i] !== testArray[i]) {
114            res = false
115        }
116    }
117    map.set("test arraylist remove:", res)
118    map.set("test arraylist removeRes:", removeRes)
119
120    proxy.removeByRange(1, 3)
121    testArray.splice(1, 2)
122    res = true
123    for(let i = 0; i < testArray.length; i++) {
124        if (proxy[i] !== testArray[i]) {
125            res = false
126        }
127    }
128    map.set("test arraylist removeByRange:", res)
129
130    res = true
131    proxy.forEach((value, index) => {
132        if (value !== testArray[index]) {
133            res = false
134        }
135    })
136
137    map.set("test arraylist forEach:", res);
138
139    res = true
140    let subArrayList = proxy.subArrayList(1, 3)
141    const newtestArray = testArray.slice(1, 3)
142    for(let i = 0; i < subArrayList.length; i++) {
143        if (newtestArray[i] !== subArrayList[i]) {
144            res =  false
145        }
146    }
147    map.set("test arraylist subArrayList:", res)
148
149    res = true
150    let j = 0
151    for (const data of proxy) {
152      if (data !== testArray[j]) {
153        res = false
154      }
155      j++;
156    }
157    map.set("test arraylist for of:", res);
158
159    testdProxyArray1(proxy, res, testArray);
160
161    map.set("test arraylist Symbol.iterator:", res)
162
163    proxy.replaceAllElements((item, index) => {
164        return item * 2
165    })
166    res = true
167    for(let i = 0; i < testArray.length; i++) {
168        if (proxy[i] !== testArray[i] * 2) {
169            res = false
170        }
171    }
172    map.set("test arraylist replaceAllElements:", res)
173
174    let arr2 = new arrayList();
175    let proxy1 = new Proxy(arr2, {});
176    proxy1.add(4);
177    proxy1.add(3);
178    proxy1.add(1);
179    proxy1.add(2);
180    proxy1.add(0);
181    proxy1.sort((a,b) => a-b);
182    res = true
183    for (let i = 0; i < 5; i++) {
184        if (proxy1[i] !== i) {
185            res = false
186        }
187    }
188    map.set("test arraylist sort:", res)
189
190    proxy1.clear()
191    map.set("test arraylist clear:", proxy1.length === 0)
192    map.set("test arraylist isEmpty:", proxy1.isEmpty())
193    proxy1.add(4);
194    proxy1.add(3);
195    proxy1.add(1);
196    proxy1.add(2);
197    proxy1.add(0);
198    proxy1.sort((a,b) => a-b);
199    res = true
200    for (let i = 0; i < 5; i++) {
201        if (proxy1[i] !== i) {
202            res = false
203        }
204    }
205    map.set("test arraylist clear and add:", res)
206
207    proxy1.insert(50, 0);
208    map.set("test arraylist insert index === 0:", proxy1[0] === 50)
209    proxy1.increaseCapacityTo(20)
210    map.set("test arraylist increaseCapacityTo:", proxy1.getCapacity() === 20)
211
212    proxy1.trimToCurrentLength()
213    map.set("test arraylist trimToCurrentLength:", proxy1.getCapacity() === 6)
214
215    let testlist = new arrayList();
216    try {
217        testlist.removeByIndex(0);
218    } catch(err) {
219        res = (err =="BusinessError: Container is empty")
220        map.set("test RemoveByIndex exception when arraylist is empty:", res)
221    }
222    try {
223        testlist.removeByRange(0, 1);
224    } catch(err) {
225        res = (err =="BusinessError: Container is empty")
226        map.set("test RemoveByRange exception when arraylist is empty:", res)
227    }
228    try {
229        testlist.subArrayList(0, 1);
230    } catch(err) {
231        res = (err =="BusinessError: Container is empty")
232        map.set("test SubArrayList exception when arraylist is empty:", res)
233    }
234    testlist.add(7);
235    testlist.add(9);
236    map.set("test arraylist JSAPIArrayList::GetProperty:", testlist[Math.floor(1)] === 9);
237
238    try {
239        let myArrayList = new arrayList();
240        myArrayList.add(1);
241        myArrayList[2147483648];
242    } catch(err) {
243        let overFlowTest = (err == "BusinessError: The type of \"index\" must be small integer.");
244        map.set("test ArrayList[i] overFlowTest:", overFlowTest);
245    }
246
247    let flag = undefined;
248    function elements(value, key, map) {
249        if (!value) {
250            if (!flag) {
251                flag = [];
252            }
253            flag.push(key);
254        }
255    }
256    map.forEach(elements);
257    let de = new arrayList();
258    try {
259        de.forEach(123);
260    } catch(err) {
261        if (err.name != "BusinessError") {
262            print("ArrayList forEach throw error fail");
263        }
264    }
265    let test1 = new arrayList();
266    for (let k = 0; k < 10; k++) {
267        test1.add(k);
268    }
269    var keyName = "";
270    for (const key in test1) {
271        keyName += key;
272    }
273    if (keyName != "0123456789") {
274        print("ArrayList for in fail")
275    }
276
277    // Math.foor as index input should not have exception.
278    let myAl = new arrayList();
279    myAl.add(1);
280    myAl.add(2);
281    myAl.add(3);
282    myAl.insert(30, Math.floor(1.3));
283    myAl.removeByIndex(Math.floor(1.3));
284
285    const v1 = new arrayList()
286    v1.add(1)
287    v1.add(2)
288    v1.add(3)
289    let oldLen = v1.length
290    v1.replaceAllElements((val,index,temp)=>{
291        temp.add(val)
292    })
293    print(oldLen * 2 === v1.length)
294    const v3 = new arrayList();
295    const v4 = [arrayList,arrayList];
296    class C4{
297    ["100"] = v4
298    }
299    const v5 = new C4();
300    try {
301        Object.assign(v3,v5)
302    } catch (error) {
303        print(error)
304    }
305
306    const v11 = new arrayList()
307    function f2(a3, a4) {
308        const o5 = {}
309        return o5;
310    }
311    const o6 = {
312        "set" : f2
313    }
314    try {
315        const v8Proxy = new Proxy(v11,o6)
316        v8Proxy[4] = "no"
317    } catch (error) {
318        print(error)
319    }
320
321    if (!flag) {
322        print("Test ArrayList success!!!");
323    } else {
324        print("Test ArrayList fail: " + flag);
325    }
326}
327export let arraylistRes = "Test ArrayList";
328