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