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 */
22var List = undefined;
23if (globalThis["ArkPrivate"] != undefined) {
24    List = ArkPrivate.Load(ArkPrivate.List);
25    let list = new List();
26    const testArray = [];
27    let map = new Map();
28    map.set("test list isEmpty1:", list.isEmpty() === true);
29    for(let i = 0; i < 10; i++) {
30        list.add(i);
31        testArray.push(i);
32    }
33
34    map.set("test list isEmpty2:", list.isEmpty() === false);
35    map.set("test list get 1:", list.get(1) === 1);
36    map.set("test list has:",  list.has(8));
37    map.set("test list not has:", list.has(123) === false);
38
39    let list1 = new List();
40    const testArray2 = [];
41    for(let i = 0; i < 10; i++) {
42        list1.add(i)
43        testArray2.push(i);
44    }
45
46    map.set("test list equal:", list.equal(list1));
47    list.add(10);
48    testArray.push(10);
49    map.set("test list equal:", list.equal(list1) === false);
50    map.set("test list getLastIndexOf:", list.getLastIndexOf(1) === 1);
51    map.set("test list getIndexOf:", list.getIndexOf(5) === 5);
52
53    list.removeByIndex(10);
54    testArray.splice(10, 1);
55    let res = true;
56    for(let i = 0; i < testArray.length; i++) {
57        if (list[i] !== testArray[i]) {
58            res = false;
59        }
60    }
61    map.set("test list removeByIndex:", res);
62
63    list.remove(9);
64    testArray.splice(9, 1);
65    res = true;
66    for(let i = 0; i < testArray.length; i++) {
67        if (list[i] !== testArray[i]) {
68            res = false;
69        }
70        testArray[i] = testArray[i] * 2;
71    }
72    map.set("test list remove:", res);
73
74    list.replaceAllElements((item, index) => {
75        return item * 2;
76    })
77    res = true;
78    for(let i = 0; i < testArray.length; i++) {
79        if (list[i] !== testArray[i] * 2) {
80            res = false;
81        }
82    }
83    map.set("test list replaceAllElements:", res);
84    map.set("test list getFirst:", list.getFirst() === 0);
85    map.set("test list getLast:", list.getLast() === 16);
86    list.insert(999, 3);
87    testArray.splice(3, 0, 999);
88    res = true;
89    for(let i = 0; i < testArray.length; i++) {
90        if (list[i] !== testArray[i]) {
91            res = false;
92        }
93    }
94    map.set("test list insert:", res);
95
96    list.set(5, 888);
97    testArray[5] = 888;
98    res = true;
99    for(let i = 0; i < testArray.length; i++) {
100        if (list[i] !== testArray[i]) {
101            res = false;
102        }
103    }
104    map.set("test list set:", res);
105
106    let list2 = new List();
107    list2.sort();
108    list2.add(4);
109    list2.add(3);
110    list2.add(1);
111    list2.add(2);
112    list2.add(0);
113    list2.sort((a,b) => a-b);
114    res = true;
115    for (let i = 0; i < 5; i++) {
116        if (list2[i] !== i) {
117            res = false;
118        }
119    }
120    map.set("test list sort:", res);
121
122    res = true;
123    let subList = list.getSubList(1, 3);
124    const newtestArray = testArray.slice(1, 3);
125    for(let i = 0; i < subList.length; i++) {
126        if (newtestArray[i] !== subList[i]) {
127            res = false;
128        }
129    }
130    map.set("test list getSubList:", res);
131
132    res = true;
133    let list6 = new List();
134    const testArray1 = [];
135    for(let i = 0; i < 4; i++) {
136        list6.add(i);
137        testArray1.push(i);
138    }
139    let subList11 = list6.getSubList(1, 4);
140    const newtestArraylist1 = testArray1.slice(1, 4);
141    for(let i = 0; i < subList11.length; i++) {
142        if (newtestArraylist1[i] !== subList11[i]) {
143            res =  false;
144        }
145    }
146    map.set("test list getSubList1:", res);
147
148    res = true;
149    const arr = list.convertToArray();
150    for (let i = 0; i < arr.length; i++) {
151        if (arr[i] !== testArray[i]) {
152            res = false;
153        }
154    }
155    map.set("test list convertToArray:", res);
156
157    res = true;
158    let i = 0;
159    for (const data of list) {
160        if (data !== testArray[i]) {
161            res = false;
162        }
163        i++;
164    }
165    map.set("test list itertor:", res);
166
167    res = true;
168    list1.forEach((i, d) => {
169        if (d !== testArray2[i]) {
170            res = false;
171        }
172    })
173    map.set("test list forEach:", res);
174    list2.clear();
175    map.set("test list clear:", list2.length === 0);
176    res = true;
177    const testArrayClear = [];
178    for(let i = 0; i < 10; i++) {
179        list2.add(i);
180        testArrayClear.push(i);
181    }
182    for(let i = 0; i < testArrayClear.length; i++) {
183        if (list2[i] !== testArrayClear[i]) {
184            res = false;
185        }
186    }
187    map.set("test list clear and add:", res);
188    map.set("test list get:", list1.get(200) === undefined);
189    map.set("test list getLastIndexOf:", list1.getLastIndexOf('abc') === -1);
190    let flag = false;
191    try {
192        list1.removeByIndex(99)
193    } catch (error) {
194        flag = true;
195    }
196    map.set("test list removeByIndex:", flag);
197    res = list1.remove(888);
198    map.set("test list remove:", !res);
199
200    let list3 = new List();
201    let proxy = new Proxy(list3, {});
202    map.set("test list proxy isEmpty1:", proxy.isEmpty() === true);
203    const testArray3 = [];
204    for(let i = 0; i < 10; i++) {
205        proxy.add(i);
206        testArray3.push(i);
207    }
208
209    let s = Math.trunc(1.33);
210    map.set("test list proxy isEmpty2:", proxy.isEmpty() === false);
211    map.set("test list get 1:", proxy.get(1) === 1);
212    map.set("test list get Math.trunc:", proxy.get(s) === 1);
213    map.set("test list has:",  proxy.has(8));
214    map.set("test list not has:", proxy.has(123) === false);
215
216    let list4 = new List();
217    let proxy1 = new Proxy(list4, {});
218    const testArray4 = [];
219    for(let i = 0; i < 10; i++) {
220        proxy1.add(i);
221        testArray4.push(i);
222    }
223
224    proxy.add(10);
225    testArray3.push(10);
226    map.set("test list equal:", proxy.equal(proxy1) === false);
227    map.set("test list getLastIndexOf:", proxy.getLastIndexOf(1) === 1);
228    map.set("test list getIndexOf:", proxy.getIndexOf(5) === 5);
229
230    proxy.removeByIndex(10);
231    testArray3.splice(10, 1);
232    res = true;
233    for(let i = 0; i < testArray3.length; i++) {
234        if (proxy[i] !== testArray3[i]) {
235            res = false;
236        }
237    }
238    map.set("test list removeByIndex:", res);
239
240    proxy.remove(9);
241    testArray3.splice(9, 1);
242    res = true;
243    for(let i = 0; i < testArray3.length; i++) {
244        if (proxy[i] !== testArray3[i]) {
245            res = false;
246        }
247        testArray3[i] = testArray3[i] * 2;
248    }
249    map.set("test list remove:", res);
250
251
252    function testCopyArray() {
253        let myList = new List();
254        let obj = {};
255        let result = [
256            "hello9",
257            "hello10",
258            "hello0",
259            "hello1",
260            "hello2",
261            "hello3",
262            "hello4",
263            "hello5",
264            "hello6",
265            "hello7",
266            "hello8",
267            "hello10",
268            "hello9"
269        ]
270        function prepareList() {
271            const list = new List();
272            for (let i = 0; i <= 10; i++) {
273                list.add("hello" + i);
274            }
275            obj.dataArray = list;
276        }
277
278        function checkList() {
279            for (let i = 0; i < obj.dataArray.length; i++) {
280                if (obj.dataArray.get(i) != result[i]) {
281                    return false;
282                }
283            }
284            return true;
285        }
286
287        function addData(data) {
288            const tmp = obj.dataArray;
289            tmp.add(data);
290            obj.dataArray = tmp;
291
292            const tmp2 = obj.dataArray;
293            tmp2.remove(data);
294            tmp2.insert(data, 0);
295            obj.dataArray = tmp2;
296        }
297
298        prepareList();
299        addData("hello10");
300        addData("hello9");
301        return checkList();
302    }
303
304    map.set("test list copyArray:", testCopyArray());
305
306    proxy.replaceAllElements((item, index) => {
307        return item * 2;
308    })
309    res = true;
310    for(let i = 0; i < testArray3.length; i++) {
311        if (proxy[i] !== testArray3[i]) {
312            res = false;
313        }
314    }
315    map.set("test list replaceAllElements:", res);
316    map.set("test list getFirst:", proxy.getFirst() === 0);
317    map.set("test list getLast:", proxy.getLast() === 16);
318    proxy.insert(999, 3);
319    testArray3.splice(3, 0, 999);
320    res = true;
321    for(let i = 0; i < testArray3.length; i++) {
322        if (proxy[i] !== testArray3[i]) {
323            res = false;
324        }
325    }
326    map.set("test list insert:", res);
327
328    proxy.set(5, 888);
329    testArray3[5] = 888;
330    res = true;
331    for(let i = 0; i < testArray3.length; i++) {
332        if (proxy[i] !== testArray3[i]) {
333            res = false;
334        }
335    }
336    map.set("test list set:", res);
337
338    let list5 = new List();
339    let proxy2 = new Proxy(list5, {});
340    proxy2.add(4);
341    proxy2.add(3);
342    proxy2.add(1);
343    proxy2.add(2);
344    proxy2.add(0);
345    proxy2.sort((a,b) => a-b);
346    res = true;
347    for (let i = 0; i < 5; i++) {
348        if (proxy2[i] !== i) {
349            res = false;
350        }
351    }
352    map.set("test list sort:", res);
353
354    res = true;
355    let subList1 = proxy.getSubList(1, 3);
356    const newtestArray1 = testArray3.slice(1, 3);
357    for(let i = 0; i < subList1.length; i++) {
358        if (newtestArray1[i] !== subList1[i]) {
359            res =  false;
360        }
361    }
362    map.set("test list getSubList:", res);
363
364    res = true;
365    const arr1 = proxy.convertToArray();
366    for (let i = 0; i < arr1.length; i++) {
367        if (arr1[i] !== testArray3[i]) {
368            res = false;
369        }
370    }
371    map.set("test list convertToArray:", res);
372
373    res = true;
374    let k = 0;
375    for (const data of proxy1) {
376        if (data !== testArray4[k]) {
377            res = false;
378        }
379        k++;
380    }
381    map.set("test list iterator:", res);
382
383    res = true;
384    proxy1.forEach((i, d) => {
385        if (d !== testArray4[i]) {
386            res = false;
387        }
388    })
389    map.set("test list forEach:", res);
390    proxy2.clear();
391    map.set("test list clear:", proxy2.length === 0);
392    map.set("test list get:", proxy1.get(200) === undefined);
393    map.set("test list getLastIndexOf:", proxy1.getLastIndexOf('abc') === -1);
394    flag = false;
395    try {
396        proxy1.removeByIndex(99);
397    } catch (error) {
398        flag = true;
399    }
400    map.set("test list removeByIndex:", flag)
401    res = proxy1.remove(888);
402    map.set("test list remove:", !res);
403
404    let testlist = new List();
405    testlist.add(7);
406    testlist.add(8);
407    map.set("test list JSAPIList::GetProperty:", testlist[Math.floor(1)] === 8);
408
409    let empty_l = new List();
410    try {
411        empty_l.set(0, 1);
412    } catch(err) {
413        res = (err == "BusinessError: Container is empty")
414        map.set("test Set exception when arraylist is empty:", res)
415    }
416    try {
417        empty_l.removeByIndex(0);
418    } catch(err) {
419        res = (err == "BusinessError: Container is empty")
420        map.set("test removeByIndex exception when arraylist is empty:", res)
421    }
422    try {
423        empty_l.getSubList(0, 1);
424    } catch(err) {
425        res = (err == "BusinessError: Container is empty")
426        map.set("test GetSubList exception when arraylist is empty:", res)
427    }
428
429    try {
430        let myList = new List();
431        myList.add(1);
432        myList[2147483648];
433    } catch(err) {
434        let overFlowTest = (err == "BusinessError: The type of \"index\" must be small integer.");
435        map.set("test List[i] overFlowTest:", overFlowTest);
436    }
437
438    try {
439        let myList = new List();
440        myList.add(1);
441        myList.getSubList(2147483648, 2147483649);
442    } catch(err) {
443        res = (err.name == "BusinessError")
444        map.set("test GetSubList exception when fromIndex is over int32Max:", res)
445    }
446
447    flag = undefined;
448    function elementsList(valueList, keyList, map) {
449        if (!valueList) {
450            if (!flag) {
451                flag = [];
452            }
453            flag.push(keyList);
454        }
455    }
456    map.forEach(elementsList);
457
458    let de = new List();
459    try {
460        de.forEach(123);
461    } catch(err) {
462        if (err.name != "BusinessError") {
463            print("List forEach throw error fail");
464        }
465    }
466    if (!flag) {
467        print("Test List success!!!");
468    } else {
469        print("Test List fail: " + flag);
470    }
471
472    let mList = new List();
473    for (let i = 1; i <= 10; ++i) {
474        mList.add(i);
475    }
476
477    for (let i = 1; i <= 10; ++i) {
478        mList.remove(i);
479    }
480
481    for (let i = 1; i <= 3; ++i) {
482        mList.add(i);
483    }
484
485    // Math.floor as the index input should not throw exception.
486    let myList1 = new List();
487    myList1.add(1);
488    myList1.add(2);
489    myList1.add(3);
490    myList1.insert(999, Math.floor(1.5));
491    myList1.get(Math.floor(1.5));
492    myList1.set(Math.floor(1.5), 888);
493    myList1.removeByIndex(Math.floor(1.5));
494
495    if (mList.getLast() != 3 ||
496        ("convertToArray= " + mList.convertToArray()) != "convertToArray= 1,2,3") {
497        print("Test List fail!!!");
498    }
499}
500export let listRes = "Test List done";
501