1/*
2 * Copyright (C) 2021 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 */
15import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
16import dataRdb from '@ohos.data.rdb'
17
18const TAG = "[RDB_JSKITS_TEST]"
19const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (" + "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
20    "data1 text," + "data2 long, " + "data3 double," + "data4 blob)";
21
22const STORE_CONFIG = {
23    name: "Resultset.db",
24}
25var rdbStore = undefined;
26
27describe('rdbResultSetTest', function () {
28    beforeAll(async function () {
29        console.info(TAG + 'beforeAll')
30        rdbStore = await dataRdb.getRdbStore(STORE_CONFIG, 1);
31        await rdbStore.executeSql(CREATE_TABLE_TEST, null);
32        await createTest();
33    })
34
35    beforeEach(async function () {
36        console.info(TAG + 'beforeEach')
37    })
38
39    afterEach(function () {
40        console.info(TAG + 'afterEach')
41    })
42
43    afterAll(async function () {
44        console.info(TAG + 'afterAll')
45        rdbStore = null
46        await dataRdb.deleteRdbStore("Resultset.db");
47    })
48    // insert data
49    async function createTest() {
50        console.log(TAG + "createTest data start");
51        {
52            var u8 = new Uint8Array([1, 2, 3])
53            const valueBucket = {
54                "data1": "hello",
55                "data2": 10,
56                "data3": 1.0,
57                "data4": u8,
58            }
59            await rdbStore.insert("test", valueBucket)
60        }
61        {
62            var u8 = new Uint8Array([3, 4, 5])
63            const valueBucket = {
64                "data1": "2",
65                "data2": -5,
66                "data3": 2.5,
67                "data4": u8,
68            }
69            await rdbStore.insert("test", valueBucket)
70        }
71        {
72            var u8 = new Uint8Array(0)
73            const valueBucket = {
74                "data1": "hello world",
75                "data2": 3,
76                "data3": 1.8,
77                "data4": u8,
78            }
79            await rdbStore.insert("test", valueBucket)
80        }
81        console.log(TAG + "createTest data end");
82    }
83
84    function createUint8Array(length) {
85        let i = 0
86        let index = 0
87        let temp = null
88        let u8 = new Uint8Array(length)
89        length = typeof (length) === 'undefined' ? 9 : length
90        for (i = 1; i <= length; i++) {
91            u8[i - 1] = i
92        }
93        for (i = 1; i <= length; i++) {
94            index = parseInt(Math.random() * (length - i)) + i
95            if (index != i) {
96                temp = u8[i - 1]
97                u8[i - 1] = u8[index - 1]
98                u8[index - 1] = temp
99            }
100        }
101        return u8;
102    }
103
104    async function createBigData(size) {
105        await rdbStore.executeSql("DELETE FROM test");
106        let u8 = createUint8Array(32768);
107        let valueBucketArray = new Array();
108        for (let i = 0; i < size; i++) {
109            valueBucketArray.push({
110                "data1": "test" + i,
111                "data2": 18,
112                "data3": 100.5,
113                "data4": u8,
114            });
115        }
116        if (valueBucketArray.length != 0) {
117            await rdbStore.batchInsert("test", valueBucketArray);
118        }
119    }
120
121    /**
122     * @tc.name resultSet getBlob normal test
123     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0010
124     * @tc.desc resultSet getBlob normal test
125     */
126    it('testGetBlob0001', 0, async function (done) {
127        console.log(TAG + "************* testGetBlob0001 start *************");
128        let predicates = await new dataRdb.RdbPredicates("test")
129        let resultSet = await rdbStore.query(predicates)
130        try {
131            expect(true).assertEqual(resultSet.goToFirstRow())
132            const id = resultSet.getLong(resultSet.getColumnIndex("id"))
133            const data4 = resultSet.getBlob(resultSet.getColumnIndex("data4"))
134            console.log(TAG + "id=" + id + ", data4=" + data4);
135            expect(1).assertEqual(data4[0]);
136            expect(2).assertEqual(data4[1]);
137            expect(3).assertEqual(data4[2]);
138
139            resultSet.close();
140            expect(true).assertEqual(resultSet.isClosed)
141        } catch (e) {
142            expect(null).assertFail();
143        }
144        resultSet = null
145        done();
146        console.log(TAG + "************* testGetBlob0001 end *************");
147    })
148
149    /**
150     * @tc.name resultSet getBlob normal test
151     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0011
152     * @tc.desc resultSet getBlob normal test
153     */
154    it('testGetBlob0002', 0, async function (done) {
155        console.log(TAG + "************* testGetBlob0002 start *************");
156        let predicates = await new dataRdb.RdbPredicates("test")
157        let resultSet = await rdbStore.query(predicates)
158        try {
159            expect(true).assertEqual(resultSet.goToFirstRow())
160            expect(true).assertEqual(resultSet.goToNextRow())
161            const id = resultSet.getLong(resultSet.getColumnIndex("id"))
162            const data4 = resultSet.getBlob(resultSet.getColumnIndex("data4"))
163            console.log(TAG + "id=" + id + ", data4=" + data4);
164            expect(3).assertEqual(data4[0]);
165            expect(4).assertEqual(data4[1]);
166
167            resultSet.close();
168            expect(true).assertEqual(resultSet.isClosed)
169        } catch (e) {
170            expect(null).assertFail();
171        }
172        resultSet = null
173        done();
174        console.log(TAG + "************* testGetBlob0002 end *************");
175    })
176
177    /**
178     * @tc.name resultSet getBlob normal test
179     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0012
180     * @tc.desc resultSet getBlob normal test
181     */
182    it('testGetBlob0003', 0, async function (done) {
183        console.log(TAG + "************* testGetBlob0003 start *************");
184        let predicates = await new dataRdb.RdbPredicates("test")
185        let resultSet = await rdbStore.query(predicates)
186        try {
187            expect(true).assertEqual(resultSet.goToFirstRow())
188            expect(true).assertEqual(resultSet.goToNextRow())
189            expect(true).assertEqual(resultSet.goToNextRow())
190            const id = resultSet.getLong(resultSet.getColumnIndex("id"))
191            const data4 = resultSet.getBlob(resultSet.getColumnIndex("data4"))
192            console.log(TAG + "id=" + id + ", data4=" + data4);
193
194            resultSet.close();
195            expect(true).assertEqual(resultSet.isClosed)
196        } catch (e) {
197            expect(null).assertFail();
198        }
199        resultSet = null
200        done();
201        console.log(TAG + "************* testGetBlob0003 end *************");
202    })
203
204    /**
205     * @tc.name resultSet isStarted normal test
206     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0020
207     * @tc.desc resultSet isStarted normal test
208     */
209    it('testIsStarted0001', 0, async function (done) {
210        console.log(TAG + "************* testIsStarted0001 start *************");
211        let predicates = await new dataRdb.RdbPredicates("test")
212        let resultSet = await rdbStore.query(predicates)
213        try {
214            expect(false).assertEqual(resultSet.isStarted)
215        } catch (e) {
216            expect(null).assertFail();
217        }
218        resultSet.close();
219        resultSet = null
220        done();
221        console.log(TAG + "************* testIsStarted0001 end *************");
222    })
223
224    /**
225     * @tc.name resultSet isStarted normal test
226     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0021
227     * @tc.desc resultSet isStarted normal test
228     */
229    it('testIsStarted0002', 0, async function (done) {
230        console.log(TAG + "************* testIsStarted0002 start *************");
231        let predicates = await new dataRdb.RdbPredicates("test")
232        let resultSet = await rdbStore.query(predicates)
233        try {
234            resultSet.goTo(1)
235            expect(true).assertEqual(resultSet.isStarted)
236        } catch (e) {
237            expect(null).assertFail();
238        }
239        resultSet.close();
240        resultSet = null
241        done();
242        console.log(TAG + "************* testIsStarted0002 end *************");
243    })
244
245    /**
246     * @tc.name resultSet isStarted normal test
247     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0022
248     * @tc.desc resultSet isStarted normal test
249     */
250    it('testIsStarted0003', 0, async function (done) {
251        console.log(TAG + "************* testIsStarted0003 start *************");
252        let predicates = await new dataRdb.RdbPredicates("test")
253        let resultSet = await rdbStore.query(predicates)
254        try {
255            expect(true).assertEqual(resultSet.goToNextRow())
256            expect(true).assertEqual(resultSet.isStarted)
257            expect(false).assertEqual(resultSet.goToPreviousRow())
258            expect(true).assertEqual(resultSet.isStarted)
259        } catch (e) {
260            expect(null).assertFail();
261        }
262        resultSet.close();
263        resultSet = null
264        done();
265        console.log(TAG + "************* testIsStarted0003 end *************");
266    })
267
268    /**
269     * @tc.name resultSet isStarted with no result test
270     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0023
271     * @tc.desc resultSet isStarted with no result test
272     */
273    it('testIsStarted0004', 0, async function (done) {
274        console.log(TAG + "************* testIsStarted0004 start *************");
275        let predicates = await new dataRdb.RdbPredicates("test")
276        let resultSet = await rdbStore.query(predicates)
277        try {
278            expect(true).assertEqual(resultSet.goToNextRow())
279            expect(true).assertEqual(resultSet.isStarted)
280            expect(true).assertEqual(resultSet.isStarted)
281        } catch (e) {
282            expect(null).assertFail();
283        }
284        resultSet.close();
285        resultSet = null
286        done();
287        console.log(TAG + "************* testIsStarted0004 end *************");
288    })
289
290
291    /**
292     * @tc.name resultSet isEnded normal test
293     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0030
294     * @tc.desc resultSet isEnded normal test
295     */
296    it('testIsEnded0001', 0, async function (done) {
297        console.log(TAG + "************* testIsEnded0001 start *************");
298        let predicates = await new dataRdb.RdbPredicates("test")
299        let resultSet = await rdbStore.query(predicates)
300        try {
301            expect(true).assertEqual(resultSet.goToFirstRow())
302            expect(false).assertEqual(resultSet.isEnded)
303        } catch (e) {
304            expect(null).assertFail();
305        }
306        resultSet.close();
307        resultSet = null
308        done();
309        console.log(TAG + "************* testIsEnded0001 end *************");
310    })
311
312    /**
313     * @tc.name resultSet isEnded normal test
314     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0031
315     * @tc.desc resultSet isEnded normal test
316     */
317    it('testIsEnded0002', 0, async function (done) {
318        console.log(TAG + "************* testIsEnded0002 start *************");
319        let predicates = await new dataRdb.RdbPredicates("test")
320        let resultSet = await rdbStore.query(predicates)
321        try {
322            expect(true).assertEqual(resultSet.goToLastRow())
323            expect(false).assertEqual(resultSet.isEnded)
324        } catch (e) {
325            expect(null).assertFail();
326        }
327        resultSet.close();
328        resultSet = null
329        done();
330        console.log(TAG + "************* testIsEnded0002 end *************");
331    })
332
333    /**
334     * @tc.name resultSet isEnded normal test
335     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0032
336     * @tc.desc resultSet isEnded normal test
337     */
338    it('testIsEnded0003', 0, async function (done) {
339        console.log(TAG + "************* testIsEnded0003 start *************");
340        let predicates = await new dataRdb.RdbPredicates("test")
341        let resultSet = await rdbStore.query(predicates)
342        try {
343            resultSet.goToRow(3)
344            expect(true).assertEqual(resultSet.isEnded)
345        } catch (e) {
346            expect(null).assertFail();
347        }
348        resultSet.close();
349        resultSet = null
350        done();
351        console.log(TAG + "************* testIsEnded0003 end *************");
352    })
353
354    /**
355     * @tc.name resultSet isEnded normal test
356     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0033
357     * @tc.desc resultSet isEnded normal test
358     */
359    it('testIsEnded0004', 0, async function (done) {
360        console.log(TAG + "************* testIsEnded0004 start *************");
361        let predicates = await new dataRdb.RdbPredicates("test")
362        let resultSet = await rdbStore.query(predicates)
363        try {
364            resultSet.goToRow(3)
365            expect(true).assertEqual(resultSet.isEnded)
366            expect(true).assertEqual(resultSet.isEnded)
367        } catch (e) {
368            expect(null).assertFail();
369        }
370        resultSet.close();
371        resultSet = null
372        done();
373        console.log(TAG + "************* testIsEnded0004 end *************");
374    })
375
376    /**
377     * @tc.name resultSet rowCount normal test
378     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0040
379     * @tc.desc resultSet rowCount normal test
380     */
381    it('testRowCount0001', 0, async function (done) {
382        console.log(TAG + "************* testRowCount0001 start *************");
383        let predicates = await new dataRdb.RdbPredicates("test")
384        let resultSet = await rdbStore.query(predicates)
385        try {
386            expect(3).assertEqual(resultSet.rowCount)
387        } catch (e) {
388            expect(null).assertFail();
389        }
390        resultSet.close();
391        resultSet = null
392        done();
393        console.log(TAG + "************* testRowCount0001 end *************");
394    })
395
396    /**
397     * @tc.name resultSet rowCount with no result test
398     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0041
399     * @tc.desc resultSet rowCount with no result test
400     */
401    it('testRowCount0002', 0, async function (done) {
402        console.log(TAG + "************* testRowCount0002 start *************");
403        let predicates = await new dataRdb.RdbPredicates("test")
404        predicates.equalTo("name", "wangwu");
405        let resultSet = await rdbStore.query(predicates)
406        try {
407            expect(-1).assertEqual(resultSet.rowCount)
408        } catch (e) {
409            expect(null).assertFail();
410        }
411        resultSet.close();
412        resultSet = null
413        done();
414        console.log(TAG + "************* testRowCount0002 end *************");
415    })
416
417    /**
418     * @tc.name resultSet rowCount test
419     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0042
420     * @tc.desc resultSet rowCount test
421     */
422    it('testRowCount0003', 0, async function (done) {
423        console.log(TAG + "************* testRowCount0003 start *************");
424        let predicates = await new dataRdb.RdbPredicates("test")
425        predicates.equalTo("data1", "hello");
426        let resultSet = await rdbStore.query(predicates)
427        try {
428            expect(1).assertEqual(resultSet.rowCount)
429        } catch (e) {
430            expect(null).assertFail();
431        }
432        resultSet.close();
433        resultSet = null
434        done();
435        console.log(TAG + "************* testRowCount0003 end *************");
436    })
437
438    /**
439     * @tc.name resultSet rowCount test
440     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0043
441     * @tc.desc resultSet rowCount test
442     */
443    it('testRowCount0004', 0, async function (done) {
444        console.log(TAG + "************* testRowCount0004 start *************");
445        let predicates = await new dataRdb.RdbPredicates("test")
446        predicates.equalTo("data1", "hello");
447        predicates.equalTo("data2", 3);
448        let resultSet = await rdbStore.query(predicates)
449        try {
450            expect(0).assertEqual(resultSet.rowCount)
451        } catch (e) {
452            expect(null).assertFail();
453        }
454        resultSet.close();
455        resultSet = null
456        done();
457        console.log(TAG + "************* testRowCount0003 end *************");
458    })
459
460    /**
461     * @tc.name resultSet getLong test
462     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0050
463     * @tc.desc resultSet getLong test
464     */
465    it('testGetLong0001', 0, async function (done) {
466        console.log(TAG + "************* testGetLong0001 start *************");
467        let predicates = await new dataRdb.RdbPredicates("test")
468        let resultSet = await rdbStore.query(predicates)
469        try {
470            expect(true).assertEqual(resultSet.goToFirstRow())
471            const id = resultSet.getLong(resultSet.getColumnIndex("id"))
472            const data2 = resultSet.getLong(resultSet.getColumnIndex("data2"))
473            console.log(TAG + "id=" + id + ", data2=" + data2);
474            expect(10).assertEqual(data2);
475
476            resultSet.close();
477            expect(true).assertEqual(resultSet.isClosed)
478        } catch (e) {
479            expect(null).assertFail();
480        }
481        resultSet = null
482        done();
483        console.log(TAG + "************* testGetLong0001 end *************");
484    })
485
486    /**
487     * @tc.name resultSet getLong test
488     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0051
489     * @tc.desc resultSet getLong test
490     */
491    it('testGetLong0002', 0, async function (done) {
492        console.log(TAG + "************* testGetLong0002 start *************");
493        let predicates = await new dataRdb.RdbPredicates("test")
494        let resultSet = await rdbStore.query(predicates)
495        try {
496            expect(true).assertEqual(resultSet.goToFirstRow())
497            expect(true).assertEqual(resultSet.goToNextRow())
498            const data1 = resultSet.getLong(resultSet.getColumnIndex("data1"))
499            expect(2).assertEqual(data1);
500
501            resultSet.close();
502            expect(true).assertEqual(resultSet.isClosed)
503        } catch (e) {
504            expect(null).assertFail();
505        }
506        resultSet = null
507        done();
508        console.log(TAG + "************* testGetLong0002 end *************");
509    })
510
511    /**
512     * @tc.name resultSet getLong test
513     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0052
514     * @tc.desc resultSet getLong test
515     */
516    it('testGetLong0003', 0, async function (done) {
517        console.log(TAG + "************* testGetLong0003 start *************");
518        let predicates = await new dataRdb.RdbPredicates("test")
519        let resultSet = await rdbStore.query(predicates)
520        try {
521            expect(true).assertEqual(resultSet.goToFirstRow())
522            expect(true).assertEqual(resultSet.goToNextRow())
523            const data2 = resultSet.getLong(resultSet.getColumnIndex("data2"))
524            expect(-5).assertEqual(data2);
525
526            resultSet.close();
527            expect(true).assertEqual(resultSet.isClosed)
528        } catch (e) {
529            expect(null).assertFail();
530        }
531        resultSet = null
532        done();
533        console.log(TAG + "************* testGetLong0003 end *************");
534    })
535
536    /**
537     * @tc.name resultSet getString test
538     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0060
539     * @tc.desc resultSet getString test
540     */
541    it('testGetString0001', 0, async function (done) {
542        console.log(TAG + "************* testGetString0001 start *************");
543        let predicates = await new dataRdb.RdbPredicates("test")
544        let resultSet = await rdbStore.query(predicates)
545        expect(true).assertEqual(resultSet.goToFirstRow())
546        const data1 = resultSet.getString(resultSet.getColumnIndex("data1"))
547        expect("hello").assertEqual(data1);
548
549        resultSet.close();
550        resultSet = null
551        done();
552        console.log(TAG + "************* testGetString0001 end *************");
553    })
554
555    /**
556     * @tc.name resultSet getString test
557     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0061
558     * @tc.desc resultSet getString test
559     */
560    it('testGetString0002', 0, async function (done) {
561        console.log(TAG + "************* testGetString0002 start *************");
562        let predicates = await new dataRdb.RdbPredicates("test")
563        let resultSet = await rdbStore.query(predicates)
564        expect(true).assertEqual(resultSet.goToFirstRow())
565        const data2 = resultSet.getString(resultSet.getColumnIndex("data2"))
566        expect("10").assertEqual(data2);
567
568        resultSet.close();
569        resultSet = null
570        done();
571        console.log(TAG + "************* testGetString0002 end *************");
572    })
573
574    /**
575     * @tc.name resultSet getString test
576     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0062
577     * @tc.desc resultSet getString test
578     */
579    it('testGetString0003', 0, async function (done) {
580        console.log(TAG + "************* testGetString0003 start *************");
581        let predicates = await new dataRdb.RdbPredicates("test")
582        let resultSet = await rdbStore.query(predicates)
583        expect(true).assertEqual(resultSet.goToFirstRow())
584        expect(true).assertEqual(resultSet.goToNextRow())
585        const data3 = resultSet.getString(resultSet.getColumnIndex("data3"))
586        expect("2.5").assertEqual(data3);
587
588        resultSet.close();
589        resultSet = null
590        done();
591        console.log(TAG + "************* testGetString0003 end *************");
592    })
593
594    /**
595     * @tc.name resultSet getString test
596     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0063
597     * @tc.desc resultSet getString test
598     */
599    it('testGetString0004', 0, async function (done) {
600        console.log(TAG + "************* testGetString0004 start *************");
601        let predicates = await new dataRdb.RdbPredicates("test")
602        let resultSet = await rdbStore.query(predicates)
603        expect(true).assertEqual(resultSet.goToFirstRow())
604        expect(true).assertEqual(resultSet.goToNextRow())
605        expect(true).assertEqual(resultSet.goToNextRow())
606        const data1 = resultSet.getString(resultSet.getColumnIndex("data1"))
607        const data2 = resultSet.getString(resultSet.getColumnIndex("data2"))
608        const data3 = resultSet.getString(resultSet.getColumnIndex("data3"))
609        expect("hello world").assertEqual(data1);
610        expect("3").assertEqual(data2);
611        expect("1.8").assertEqual(data3);
612
613        resultSet.close();
614        resultSet = null
615        done();
616        console.log(TAG + "************* testGetString0004 end *************");
617    })
618
619    /**
620     * @tc.name resultSet isClosed test
621     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0070
622     * @tc.desc resultSet isClosed test
623     */
624    it('testIsClosed0001', 0, async function (done) {
625        console.log(TAG + "************* testIsClosed0001 start *************");
626        let predicates = await new dataRdb.RdbPredicates("test")
627        let resultSet = await rdbStore.query(predicates)
628
629        expect(3).assertEqual(resultSet.rowCount)
630        resultSet.close();
631        expect(true).assertEqual(resultSet.isClosed)
632
633        resultSet.close();
634        resultSet = null
635        done();
636        console.log(TAG + "************* testIsClosed0001 end *************");
637    })
638
639    /**
640     * @tc.name resultSet isClosed with not close test
641     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0071
642     * @tc.desc resultSet isClosed with not close test
643     */
644    it('testIsClosed0002', 0, async function (done) {
645        console.log(TAG + "************* testIsClosed0002 start *************");
646        let predicates = await new dataRdb.RdbPredicates("test")
647        let resultSet = await rdbStore.query(predicates)
648        expect(false).assertEqual(resultSet.isClosed)
649
650        resultSet.close();
651        resultSet = null
652        done();
653        console.log(TAG + "************* testIsClosed0002 end *************");
654    })
655
656    /**
657     * @tc.name resultSet isClosed with not close test
658     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0072
659     * @tc.desc resultSet isClosed with not close test
660     */
661    it('testIsClosed0003', 0, async function (done) {
662        console.log(TAG + "************* testIsClosed0003 start *************");
663        let predicates = await new dataRdb.RdbPredicates("test")
664        predicates.equalTo("name", "wangwu");
665        let resultSet = await rdbStore.query(predicates)
666        expect(false).assertEqual(resultSet.isClosed)
667
668        resultSet.close();
669        resultSet = null
670        done();
671        console.log(TAG + "************* testIsClosed0003 end *************");
672    })
673
674    /**
675     * @tc.name resultSet columnCount test
676     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0080
677     * @tc.desc resultSet columnCount test
678     */
679    it('testColumnCount0001', 0, async function (done) {
680        console.log(TAG + "************* testColumnCount0001 start *************");
681        let predicates = await new dataRdb.RdbPredicates("test")
682        let resultSet = await rdbStore.query(predicates)
683        expect(5).assertEqual(resultSet.columnCount);
684        resultSet.close();
685        resultSet = null;
686        done();
687        console.log(TAG + "************* testColumnCount0001 end *************");
688    })
689
690    /**
691     * @tc.name resultSet columnCount test
692     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0081
693     * @tc.desc resultSet columnCount test
694     */
695    it('testColumnCount0002', 0, async function (done) {
696        console.log(TAG + "************* testColumnCount0002 start *************");
697        let predicates = await new dataRdb.RdbPredicates("test")
698        predicates.equalTo("name", "wangwu");
699        let resultSet = await rdbStore.query(predicates)
700        expect(0).assertEqual(resultSet.columnCount);
701        resultSet.close();
702        resultSet = null;
703        done();
704        console.log(TAG + "************* testColumnCount0002 end *************");
705    })
706
707    /**
708     * @tc.name resultSet rowIndex test
709     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0090
710     * @tc.desc resultSet rowIndex test
711     */
712    it('testRowIndex0001', 0, async function (done) {
713        console.log(TAG + "************* testRowIndex0001 *************");
714        let predicates = await new dataRdb.RdbPredicates("test")
715        let resultSet = await rdbStore.query(predicates)
716        expect(true).assertEqual(resultSet.goToFirstRow())
717        expect(0).assertEqual(resultSet.rowIndex)
718
719        resultSet.close();
720        resultSet = null;
721        done();
722        console.log(TAG + "************* testRowIndex0001 end *************");
723    })
724
725    /**
726     * @tc.name resultSet rowIndex at last row test
727     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0091
728     * @tc.desc resultSet rowIndex at last row test
729     */
730    it('testRowIndex0002', 0, async function (done) {
731        console.log(TAG + "************* testRowIndex0002 *************");
732        let predicates = await new dataRdb.RdbPredicates("test")
733        let resultSet = await rdbStore.query(predicates)
734        expect(true).assertEqual(resultSet.goToLastRow())
735        expect(2).assertEqual(resultSet.rowIndex)
736
737        resultSet.close();
738        resultSet = null;
739        done();
740        console.log(TAG + "************* testRowIndex0002 end *************");
741    })
742
743    /**
744     * @tc.name resultSet goToFirstRow normal test
745     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0100
746     * @tc.desc resultSet goToFirstRow normal test
747     */
748    it('testGoToFirstRow0001', 0, async function (done) {
749        console.log(TAG + "************* testGoToFirstRow0001 start *************");
750
751        let predicates = await new dataRdb.RdbPredicates("test")
752        let resultSet = await rdbStore.query(predicates)
753        try {
754            expect(true).assertEqual(resultSet.goToFirstRow())
755        } catch (e) {
756            expect(null).assertFail();
757        }
758        resultSet.close();
759        resultSet = null
760        done();
761        console.log(TAG + "************* testGoToFirstRow0001 end *************");
762    })
763
764    /**
765     * @tc.name resultSet goToFirstRow with no result test
766     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0101
767     * @tc.desc resultSet goToFirstRow with no result test
768     */
769    it('testGoToFirstRow0002', 0, async function (done) {
770        console.log(TAG + "************* testGoToFirstRow0002 start *************");
771
772        let predicates = await new dataRdb.RdbPredicates("test")
773        predicates.equalTo("name", "wangwu");
774        let resultSet = await rdbStore.query(predicates)
775        try {
776            expect(false).assertEqual(resultSet.goToFirstRow())
777        } catch (e) {
778            expect(null).assertFail();
779        }
780        resultSet.close()
781        resultSet = null
782        done();
783        console.log(TAG + "************* testGoToFirstRow0002 end *************");
784    })
785
786    /**
787     * @tc.name resultSet goToFirstRow test
788     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0102
789     * @tc.desc resultSet goToFirstRow test
790     */
791    it('testGoToFirstRow0003', 0, async function (done) {
792        console.log(TAG + "************* testGoToFirstRow0003 start *************");
793
794        let predicates = await new dataRdb.RdbPredicates("test")
795        let resultSet = await rdbStore.query(predicates)
796        try {
797            expect(true).assertEqual(resultSet.goToFirstRow())
798            expect(true).assertEqual(resultSet.goToNextRow())
799            expect(true).assertEqual(resultSet.goToFirstRow())
800        } catch (e) {
801            expect(null).assertFail();
802        }
803        resultSet.close()
804        resultSet = null
805        done();
806        console.log(TAG + "************* testGoToFirstRow0003 end *************");
807    })
808
809    /**
810     * @tc.name resultSet goToLastRow test
811     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0110
812     * @tc.desc resultSet goToFirstRow test
813     */
814    it('testGoToLastRow0001', 0, async function (done) {
815        console.log(TAG + "************* testGoToLastRow0001 start *************");
816        let predicates = await new dataRdb.RdbPredicates("test")
817        let resultSet = await rdbStore.query(predicates)
818        {
819            expect(true).assertEqual(resultSet.goToLastRow())
820        }
821        resultSet.close()
822        resultSet = null;
823        done();
824        console.log(TAG + "************* testGoToLastRow0001 end *************");
825    })
826
827    /**
828     * @tc.name resultSet goToLastRow with no result test
829     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0111
830     * @tc.desc resultSet goToLastRow with no result test
831     */
832    it('testGoToLastRow0002', 0, async function (done) {
833        console.log(TAG + "************* testGoToLastRow0002 start *************");
834        let predicates = await new dataRdb.RdbPredicates("test")
835        predicates.equalTo("name", "wangwu");
836        let resultSet = await rdbStore.query(predicates)
837        expect(false).assertEqual(resultSet.goToLastRow())
838        resultSet.close()
839        resultSet = null;
840        done();
841        console.log(TAG + "************* testGoToLastRow0002 end *************");
842    })
843
844    /**
845     * @tc.name resultSet goToLastRow test
846     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0112
847     * @tc.desc resultSet goToLastRow test
848     */
849    it('testGoToLastRow0003', 0, async function (done) {
850        console.log(TAG + "************* testGoToLastRow0003 start *************");
851
852        let predicates = await new dataRdb.RdbPredicates("test")
853        let resultSet = await rdbStore.query(predicates)
854
855        expect(true).assertEqual(resultSet.goToLastRow())
856        expect(true).assertEqual(resultSet.goToPreviousRow())
857        expect(true).assertEqual(resultSet.goToLastRow())
858
859        resultSet.close()
860        resultSet = null;
861        done();
862        console.log(TAG + "************* testGoToLastRow0003 end *************");
863
864    })
865
866    /**
867     * @tc.name resultSet goToNextRow test
868     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0120
869     * @tc.desc resultSet goToNextRow test
870     */
871    it('testGoToNextRow0001', 0, async function (done) {
872        console.log(TAG + "************* testGoToNextRow0001 start *************");
873
874        let predicates = await new dataRdb.RdbPredicates("test")
875        let resultSet = await rdbStore.query(predicates)
876
877        expect(true).assertEqual(resultSet.goToNextRow())
878
879        resultSet.close()
880        resultSet = null;
881        done();
882        console.log(TAG + "************* testGoToNextRow0001 end *************");
883
884    })
885
886    /**
887     * @tc.name resultSet goToNextRow with no result test
888     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0121
889     * @tc.desc resultSet goToNextRow with no result test
890     */
891    it('testGoToNextRow0002', 0, async function (done) {
892        console.log(TAG + "************* testGoToNextRow0002 start *************");
893
894        let predicates = await new dataRdb.RdbPredicates("test")
895        predicates.equalTo("name", "wangwu");
896        let resultSet = await rdbStore.query(predicates)
897
898        expect(false).assertEqual(resultSet.goToNextRow())
899
900        resultSet.close()
901        resultSet = null;
902        done();
903        console.log(TAG + "************* testGoToNextRow0002 end *************");
904
905    })
906
907    /**
908     * @tc.name resultSet goToNextRow test
909     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0122
910     * @tc.desc resultSet goToNextRow test
911     */
912    it('testGoToNextRow0003', 0, async function (done) {
913        console.log(TAG + "************* testGoToNextRow0003 start *************");
914
915        let predicates = await new dataRdb.RdbPredicates("test")
916        let resultSet = await rdbStore.query(predicates)
917
918        expect(true).assertEqual(resultSet.goToFirstRow())
919        expect(true).assertEqual(resultSet.goToNextRow())
920        expect(true).assertEqual(resultSet.goToPreviousRow())
921        expect(true).assertEqual(resultSet.goToNextRow())
922
923        resultSet.close()
924        resultSet = null;
925        done();
926        console.log(TAG + "************* testGoToNextRow0003 end *************");
927
928    })
929
930    /**
931     * @tc.name resultSet goToNextRow after last row test
932     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0123
933     * @tc.desc resultSet goToNextRow after last row test
934     */
935    it('testGoToNextRow0004', 0, async function (done) {
936        console.log(TAG + "************* testGoToNextRow0004 start *************");
937
938        let predicates = await new dataRdb.RdbPredicates("test")
939        let resultSet = await rdbStore.query(predicates)
940
941        expect(true).assertEqual(resultSet.goToLastRow())
942        expect(false).assertEqual(resultSet.goToNextRow())
943
944        resultSet.close()
945        resultSet = null;
946        done();
947        console.log(TAG + "************* testGoToNextRow0004 end *************");
948
949    })
950
951    /**
952     * @tc.name resultSet goToPreviousRow test
953     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0130
954     * @tc.desc resultSet goToPreviousRow test
955     */
956    it('testGoToPreviousRow0001', 0, async function (done) {
957        console.log(TAG + "************* testGoToPreviousRow0001 start *************");
958
959        let predicates = await new dataRdb.RdbPredicates("test")
960        let resultSet = await rdbStore.query(predicates)
961
962        expect(false).assertEqual(resultSet.goToPreviousRow())
963
964        resultSet.close()
965        resultSet = null;
966        done();
967        console.log(TAG + "************* testGoToPreviousRow0001 end *************");
968
969    })
970
971    /**
972     * @tc.name resultSet goToPreviousRow with no result test
973     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0131
974     * @tc.desc resultSet goToPreviousRow with no result test
975     */
976    it('testGoToPreviousRow0002', 0, async function (done) {
977        console.log(TAG + "************* testGoToPreviousRow0002 start *************");
978
979        let predicates = await new dataRdb.RdbPredicates("test")
980        predicates.equalTo("name", "wangwu");
981        let resultSet = await rdbStore.query(predicates)
982
983        expect(false).assertEqual(resultSet.goToPreviousRow())
984
985        resultSet.close()
986        resultSet = null;
987        done();
988        console.log(TAG + "************* testGoToPreviousRow0002 end *************");
989
990    })
991
992    /**
993     * @tc.name resultSet goToPreviousRow test
994     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0132
995     * @tc.desc resultSet goToPreviousRow test
996     */
997    it('testGoToPreviousRow0003', 0, async function (done) {
998        console.log(TAG + "************* testGoToPreviousRow0003 start *************");
999
1000        let predicates = await new dataRdb.RdbPredicates("test")
1001        let resultSet = await rdbStore.query(predicates)
1002
1003        expect(true).assertEqual(resultSet.goToFirstRow())
1004        expect(true).assertEqual(resultSet.goToNextRow())
1005        expect(true).assertEqual(resultSet.goToPreviousRow())
1006
1007        resultSet.close()
1008        resultSet = null;
1009        done();
1010        console.log(TAG + "************* testGoToPreviousRow0003 end *************");
1011
1012    })
1013
1014    /**
1015     * @tc.name resultSet goToPreviousRow after last row test
1016     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0133
1017     * @tc.desc resultSet goToPreviousRow after last row test
1018     */
1019    it('testGoToPreviousRow0004', 0, async function (done) {
1020        console.log(TAG + "************* testGoToPreviousRow0004 start *************");
1021
1022        let predicates = await new dataRdb.RdbPredicates("test")
1023        let resultSet = await rdbStore.query(predicates)
1024
1025        expect(true).assertEqual(resultSet.goToLastRow())
1026        expect(true).assertEqual(resultSet.goToPreviousRow())
1027
1028        resultSet.close()
1029        resultSet = null;
1030        done();
1031        console.log(TAG + "************* testGoToPreviousRow0004 end *************");
1032
1033    })
1034
1035    /**
1036     * @tc.name resultSet goTo test
1037     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0140
1038     * @tc.desc resultSet goTo test
1039     */
1040    it('testGoTo0001', 0, async function (done) {
1041        console.log(TAG + "************* testGoTo0001 start *************");
1042
1043        let predicates = await new dataRdb.RdbPredicates("test")
1044        let resultSet = await rdbStore.query(predicates)
1045
1046        expect(true).assertEqual(resultSet.goToFirstRow())
1047        resultSet.goTo(1)
1048        expect(1).assertEqual(resultSet.rowIndex)
1049
1050        resultSet.close()
1051        resultSet = null;
1052        done();
1053        console.log(TAG + "************* testGoTo0001 end *************");
1054
1055    })
1056
1057    /**
1058     * @tc.name resultSet goTo with no result test
1059     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0141
1060     * @tc.desc resultSet goTo with no result test
1061     */
1062    it('testGoTo0002', 0, async function (done) {
1063        console.log(TAG + "************* testGoTo0002 start *************");
1064
1065        let predicates = await new dataRdb.RdbPredicates("test")
1066        predicates.equalTo("name", "wangwu");
1067        let resultSet = await rdbStore.query(predicates)
1068
1069        resultSet.goTo(1)
1070        expect(-1).assertEqual(resultSet.rowIndex)
1071
1072        resultSet.close()
1073        resultSet = null;
1074        done();
1075        console.log(TAG + "************* testGoTo0002 end *************");
1076
1077    })
1078
1079    /**
1080     * @tc.name resultSet goTo test
1081     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0142
1082     * @tc.desc resultSet goTo test
1083     */
1084    it('testGoTo0003', 0, async function (done) {
1085        console.log(TAG + "************* testGoTo0003 start *************");
1086
1087        let predicates = await new dataRdb.RdbPredicates("test")
1088        let resultSet = await rdbStore.query(predicates)
1089
1090        expect(true).assertEqual(resultSet.goToFirstRow())
1091        expect(true).assertEqual(resultSet.goToNextRow())
1092        resultSet.goTo(1)
1093        expect(2).assertEqual(resultSet.rowIndex)
1094
1095        resultSet.close()
1096        resultSet = null;
1097        done();
1098        console.log(TAG + "************* testGoTo0003 end *************");
1099
1100    })
1101
1102    /**
1103     * @tc.name resultSet goTo after last row test
1104     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0143
1105     * @tc.desc resultSet goTo after last row test
1106     */
1107    it('testGoTo0004', 0, async function (done) {
1108        console.log(TAG + "************* testGoTo0004 start *************");
1109
1110        let predicates = await new dataRdb.RdbPredicates("test")
1111        let resultSet = await rdbStore.query(predicates)
1112
1113        expect(true).assertEqual(resultSet.goToLastRow())
1114        resultSet.goTo(5)
1115        expect(3).assertEqual(resultSet.rowIndex)
1116
1117        resultSet.close()
1118        resultSet = null;
1119        done();
1120        console.log(TAG + "************* testGoTo0004 end *************");
1121
1122    })
1123
1124    /**
1125     * @tc.name resultSet goToRow test
1126     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0150
1127     * @tc.desc resultSet goToRow test
1128     */
1129    it('testGoToRow0001', 0, async function (done) {
1130        console.log(TAG + "************* testGoToRow0001 start *************");
1131
1132        let predicates = await new dataRdb.RdbPredicates("test")
1133        let resultSet = await rdbStore.query(predicates)
1134
1135        expect(true).assertEqual(resultSet.goToFirstRow())
1136        resultSet.goToRow(1)
1137        expect(1).assertEqual(resultSet.rowIndex)
1138
1139        resultSet.close()
1140        resultSet = null;
1141        done();
1142        console.log(TAG + "************* testGoToRow0001 end *************");
1143
1144    })
1145
1146    /**
1147     * @tc.name resultSet goToRow with no result test
1148     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0151
1149     * @tc.desc resultSet goToRow with no result test
1150     */
1151    it('testGoToRow0002', 0, async function (done) {
1152        console.log(TAG + "************* testGoToRow0002 start *************");
1153
1154        let predicates = await new dataRdb.RdbPredicates("test")
1155        predicates.equalTo("name", "wangwu");
1156        let resultSet = await rdbStore.query(predicates)
1157
1158        resultSet.goToRow(1)
1159        expect(-1).assertEqual(resultSet.rowIndex)
1160
1161        resultSet.close()
1162        resultSet = null;
1163        done();
1164        console.log(TAG + "************* testGoToRow0002 end *************");
1165
1166    })
1167
1168    /**
1169     * @tc.name resultSet goToRow test
1170     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0152
1171     * @tc.desc resultSet goToRow test
1172     */
1173    it('testGoToRow0003', 0, async function (done) {
1174        console.log(TAG + "************* testGoToRow0003 start *************");
1175
1176        let predicates = await new dataRdb.RdbPredicates("test")
1177        let resultSet = await rdbStore.query(predicates)
1178
1179        expect(true).assertEqual(resultSet.goToFirstRow())
1180        expect(true).assertEqual(resultSet.goToNextRow())
1181        expect(true).assertEqual(resultSet.goToNextRow())
1182        resultSet.goToRow(1)
1183        expect(1).assertEqual(resultSet.rowIndex)
1184
1185        resultSet.close()
1186        resultSet = null;
1187        done();
1188        console.log(TAG + "************* testGoToRow0003 end *************");
1189
1190    })
1191
1192    /**
1193     * @tc.name resultSet goToRow after last row test
1194     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0153
1195     * @tc.desc resultSet goToRow after last row test
1196     */
1197    it('testGoToRow0004', 0, async function (done) {
1198        console.log(TAG + "************* testGoToRow0004 start *************");
1199
1200        let predicates = await new dataRdb.RdbPredicates("test")
1201        let resultSet = await rdbStore.query(predicates)
1202
1203        expect(true).assertEqual(resultSet.goToLastRow())
1204        resultSet.goToRow(5)
1205        expect(3).assertEqual(resultSet.rowIndex)
1206
1207        resultSet.close()
1208        resultSet = null;
1209        done();
1210        console.log(TAG + "************* testGoToRow0004 end *************");
1211
1212    })
1213
1214    /**
1215     * @tc.name resultSet isAtFirstRow test
1216     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0160
1217     * @tc.desc resultSet isAtFirstRow test
1218     */
1219    it('testIsAtFirstRow0001', 0, async function (done) {
1220        console.log(TAG + "************* testIsAtFirstRow0001 start *************");
1221
1222        let predicates = await new dataRdb.RdbPredicates("test")
1223        let resultSet = await rdbStore.query(predicates)
1224
1225        expect(true).assertEqual(resultSet.goToFirstRow())
1226        expect(true).assertEqual(resultSet.isAtFirstRow)
1227
1228        resultSet.close()
1229        resultSet = null;
1230        done();
1231        console.log(TAG + "************* testIsAtFirstRow0001 end *************");
1232
1233    })
1234
1235    /**
1236     * @tc.name resultSet isAtFirstRow with no result test
1237     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0161
1238     * @tc.desc resultSet isAtFirstRow with no result test
1239     */
1240    it('testIsAtFirstRow0002', 0, async function (done) {
1241        console.log(TAG + "************* testIsAtFirstRow0002 start *************");
1242
1243        let predicates = await new dataRdb.RdbPredicates("test")
1244        predicates.equalTo("name", "wangwu");
1245        let resultSet = await rdbStore.query(predicates)
1246
1247        expect(false).assertEqual(resultSet.isAtFirstRow)
1248
1249        resultSet.close()
1250        resultSet = null;
1251        done();
1252        console.log(TAG + "************* testIsAtFirstRow0002 end *************");
1253
1254    })
1255
1256    /**
1257     * @tc.name resultSet isAtFirstRow test
1258     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0162
1259     * @tc.desc resultSet isAtFirstRow test
1260     */
1261    it('testIsAtFirstRow0003', 0, async function (done) {
1262        console.log(TAG + "************* testIsAtFirstRow0003 start *************");
1263
1264        let predicates = await new dataRdb.RdbPredicates("test")
1265        let resultSet = await rdbStore.query(predicates)
1266
1267        expect(true).assertEqual(resultSet.goToFirstRow())
1268        expect(true).assertEqual(resultSet.goToNextRow())
1269        expect(false).assertEqual(resultSet.isAtFirstRow)
1270
1271        resultSet.close()
1272        resultSet = null;
1273        done();
1274        console.log(TAG + "************* testIsAtFirstRow0003 end *************");
1275
1276    })
1277
1278    /**
1279     * @tc.name resultSet isAtFirstRow after last row test
1280     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0163
1281     * @tc.desc resultSet isAtFirstRow after last row test
1282     */
1283    it('testIsAtFirstRow0004', 0, async function (done) {
1284        console.log(TAG + "************* testIsAtFirstRow0004 start *************");
1285
1286        let predicates = await new dataRdb.RdbPredicates("test")
1287        let resultSet = await rdbStore.query(predicates)
1288
1289        expect(true).assertEqual(resultSet.goToLastRow())
1290        expect(false).assertEqual(resultSet.isAtFirstRow)
1291
1292        resultSet.close()
1293        resultSet = null;
1294        done();
1295        console.log(TAG + "************* testIsAtFirstRow0004 end *************");
1296
1297    })
1298
1299    /**
1300     * @tc.name resultSet isAtFirstRow test
1301     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0165
1302     * @tc.descresultSet isAtFirstRow test
1303     */
1304    it('testIsAtFirstRow0005', 0, async function (done) {
1305        console.log(TAG + "************* testIsAtFirstRow0005 start *************");
1306
1307        let predicates = await new dataRdb.RdbPredicates("test")
1308        let resultSet = await rdbStore.query(predicates)
1309
1310        resultSet.goTo(1)
1311        resultSet.goTo(0)
1312        expect(true).assertEqual(resultSet.isAtFirstRow)
1313
1314        resultSet.close()
1315        resultSet = null;
1316        done();
1317        console.log(TAG + "************* testIsAtFirstRow0005 end *************");
1318
1319    })
1320
1321    /**
1322     * @tc.name resultSet isAtFirstRow test
1323     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0166
1324     * @tc.descresultSet isAtFirstRow test
1325     */
1326    it('testIsAtFirstRow0006', 0, async function (done) {
1327        console.log(TAG + "************* testIsAtFirstRow0006 start *************");
1328
1329        let predicates = await new dataRdb.RdbPredicates("test")
1330        let resultSet = await rdbStore.query(predicates)
1331
1332        resultSet.goTo(1)
1333        expect(true).assertEqual(resultSet.isAtFirstRow)
1334        expect(true).assertEqual(resultSet.isAtFirstRow)
1335
1336        resultSet.close()
1337        resultSet = null;
1338        done();
1339        console.log(TAG + "************* testIsAtFirstRow0006 end *************");
1340
1341    })
1342
1343    /**
1344     * @tc.name resultSet isAtLastRow test
1345     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0170
1346     * @tc.desc resultSet isAtLastRow test
1347     */
1348    it('testIsAtLastRow0001', 0, async function (done) {
1349        console.log(TAG + "************* testIsAtLastRow0001 start *************");
1350
1351        let predicates = await new dataRdb.RdbPredicates("test")
1352        let resultSet = await rdbStore.query(predicates)
1353
1354        expect(true).assertEqual(resultSet.goToFirstRow())
1355        expect(false).assertEqual(resultSet.isAtLastRow)
1356
1357        resultSet.close()
1358        resultSet = null;
1359        done();
1360        console.log(TAG + "************* testIsAtLastRow0001 end *************");
1361
1362    })
1363
1364    /**
1365     * @tc.name resultSet isAtLastRow with no result test
1366     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0171
1367     * @tc.desc resultSet isAtLastRow with no result test
1368     */
1369    it('testIsAtLastRow0002', 0, async function (done) {
1370        console.log(TAG + "************* testIsAtLastRow0002 start *************");
1371
1372        let predicates = await new dataRdb.RdbPredicates("test")
1373        predicates.equalTo("name", "wangwu");
1374        let resultSet = await rdbStore.query(predicates)
1375
1376        expect(false).assertEqual(resultSet.isAtLastRow)
1377
1378        resultSet.close()
1379        resultSet = null;
1380        done();
1381        console.log(TAG + "************* testIsAtLastRow0002 end *************");
1382
1383    })
1384
1385    /**
1386     * @tc.name resultSet isAtLastRow test
1387     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0172
1388     * @tc.desc resultSet isAtLastRow test
1389     */
1390    it('testIsAtLastRow0003', 0, async function (done) {
1391        console.log(TAG + "************* testIsAtLastRow0003 start *************");
1392
1393        let predicates = await new dataRdb.RdbPredicates("test")
1394        let resultSet = await rdbStore.query(predicates)
1395
1396        expect(true).assertEqual(resultSet.goToFirstRow())
1397        expect(true).assertEqual(resultSet.goToNextRow())
1398        expect(false).assertEqual(resultSet.isAtLastRow)
1399
1400        resultSet.close()
1401        resultSet = null;
1402        done();
1403        console.log(TAG + "************* testIsAtLastRow0003 end *************");
1404
1405    })
1406
1407    /**
1408     * @tc.name resultSet isAtLastRow after last row test
1409     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0173
1410     * @tc.desc resultSet isAtLastRow after last row test
1411     */
1412    it('testIsAtLastRow0004', 0, async function (done) {
1413        console.log(TAG + "************* testIsAtLastRow0004 start *************");
1414
1415        let predicates = await new dataRdb.RdbPredicates("test")
1416        let resultSet = await rdbStore.query(predicates)
1417
1418        expect(true).assertEqual(resultSet.goToLastRow())
1419        expect(true).assertEqual(resultSet.isAtLastRow)
1420
1421        resultSet.close()
1422        resultSet = null;
1423        done();
1424        console.log(TAG + "************* testIsAtLastRow0004 end *************");
1425
1426    })
1427
1428    /**
1429     * @tc.name resultSet isAtLastRow test
1430     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0174
1431     * @tc.desc resultSet isAtLastRow test
1432     */
1433    it('testIsAtLastRow0005', 0, async function (done) {
1434        console.log(TAG + "************* testIsAtLastRow0005 start *************");
1435
1436        let predicates = await new dataRdb.RdbPredicates("test")
1437        let resultSet = await rdbStore.query(predicates)
1438
1439        resultSet.goToRow(2)
1440        expect(true).assertEqual(resultSet.isAtLastRow)
1441        expect(true).assertEqual(resultSet.isAtLastRow)
1442
1443        resultSet.close()
1444        resultSet = null;
1445        done();
1446        console.log(TAG + "************* testIsAtLastRow0005 end *************");
1447
1448    })
1449
1450    /**
1451     * @tc.name resultSet getDouble test
1452     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0180
1453     * @tc.desc resultSet getDouble test
1454     */
1455    it('testGetDouble0001', 0, async function (done) {
1456        console.log(TAG + "************* testGetDouble0001 start *************");
1457
1458        let predicates = await new dataRdb.RdbPredicates("test")
1459        let resultSet = await rdbStore.query(predicates)
1460
1461        resultSet.goTo(1)
1462        const data3 = resultSet.getDouble(resultSet.getColumnIndex("data3"))
1463        expect(1.0).assertEqual(data3)
1464
1465        resultSet.close()
1466        resultSet = null;
1467        done();
1468        console.log(TAG + "************* testGetDouble0001 end *************");
1469
1470    })
1471
1472    /**
1473     * @tc.name resultSet getDouble test
1474     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0181
1475     * @tc.desc resultSet getDouble test
1476     */
1477    it('testGetDouble0002', 0, async function (done) {
1478        console.log(TAG + "************* testGetDouble0002 start *************");
1479
1480        let predicates = await new dataRdb.RdbPredicates("test")
1481        let resultSet = await rdbStore.query(predicates)
1482
1483        resultSet.goTo(2)
1484        const data3 = resultSet.getDouble(resultSet.getColumnIndex("data3"))
1485        expect(2.5).assertEqual(data3)
1486
1487        resultSet.close()
1488        resultSet = null;
1489        done();
1490        console.log(TAG + "************* testGetDouble0002 end *************");
1491
1492    })
1493
1494    /**
1495     * @tc.name resultSet getDouble test
1496     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0182
1497     * @tc.desc resultSet getDouble test
1498     */
1499    it('testGetDouble0003', 0, async function (done) {
1500        console.log(TAG + "************* testGetDouble0003 start *************");
1501
1502        let predicates = await new dataRdb.RdbPredicates("test")
1503        let resultSet = await rdbStore.query(predicates)
1504
1505        resultSet.goTo(3)
1506        const data3 = resultSet.getDouble(resultSet.getColumnIndex("data3"))
1507        expect(1.8).assertEqual(data3)
1508
1509        resultSet.close()
1510        resultSet = null;
1511        done();
1512        console.log(TAG + "************* testGetDouble0003 end *************");
1513
1514    })
1515
1516    /**
1517     * @tc.name resultSet getDouble test
1518     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0183
1519     * @tc.desc resultSet getDouble test
1520     */
1521    it('testGetDouble0004', 0, async function (done) {
1522        console.log(TAG + "************* testGetDouble0004 start *************");
1523
1524        let predicates = await new dataRdb.RdbPredicates("test")
1525        let resultSet = await rdbStore.query(predicates)
1526
1527        resultSet.goTo(1)
1528        const data2 = resultSet.getDouble(resultSet.getColumnIndex("data2"))
1529        expect(10).assertEqual(data2)
1530
1531        resultSet.close()
1532        resultSet = null;
1533        done();
1534        console.log(TAG + "************* testGetDouble0004 end *************");
1535
1536    })
1537
1538    /**
1539     * @tc.name resultSet isColumnNull test
1540     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0190
1541     * @tc.desc resultSet isColumnNull test
1542     */
1543    it('testIsColumnNull0001', 0, async function (done) {
1544        console.log(TAG + "************* testIsColumnNull0001 start *************");
1545
1546        let predicates = await new dataRdb.RdbPredicates("test")
1547        let resultSet = await rdbStore.query(predicates)
1548
1549        expect(true).assertEqual(resultSet.goToFirstRow())
1550        expect(true).assertEqual(resultSet.goToNextRow())
1551        expect(true).assertEqual(resultSet.goToNextRow())
1552        const isColumnNull1 = resultSet.isColumnNull(resultSet.getColumnIndex("data1"))
1553        expect(false).assertEqual(isColumnNull1)
1554
1555        resultSet.close()
1556        resultSet = null;
1557        done();
1558        console.log(TAG + "************* testIsColumnNull0001 end *************");
1559
1560    })
1561
1562    /**
1563     * @tc.name resultSet isColumnNull test
1564     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0191
1565     * @tc.desc resultSet isColumnNull test
1566     */
1567    it('testIsColumnNull0002', 0, async function (done) {
1568        console.log(TAG + "************* testIsColumnNull0002 start *************");
1569
1570        let predicates = await new dataRdb.RdbPredicates("test")
1571        let resultSet = await rdbStore.query(predicates)
1572
1573        expect(true).assertEqual(resultSet.goToFirstRow())
1574        expect(true).assertEqual(resultSet.goToNextRow())
1575        expect(true).assertEqual(resultSet.goToNextRow())
1576        const isColumnNull4 = resultSet.isColumnNull(resultSet.getColumnIndex("data4"))
1577        expect(true).assertEqual(isColumnNull4)
1578
1579        resultSet.close()
1580        resultSet = null;
1581        done();
1582        console.log(TAG + "************* testIsColumnNull0002 end *************");
1583
1584    })
1585
1586    /**
1587     * @tc.name resultSet isColumnNull test
1588     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0192
1589     * @tc.desc resultSet isColumnNull test
1590     */
1591    it('testIsColumnNull0003', 0, async function (done) {
1592        console.log(TAG + "************* testIsColumnNull0003 start *************");
1593
1594        let predicates = await new dataRdb.RdbPredicates("test")
1595        let resultSet = await rdbStore.query(predicates)
1596        resultSet.goToRow(5)
1597        try {
1598            expect(false).assertEqual(resultSet.isColumnNull(1));
1599        } catch (e) {
1600            expect(e.code).assertEqual("14800012");
1601        }
1602        resultSet.close()
1603        resultSet = null;
1604        done();
1605        console.log(TAG + "************* testIsColumnNull0003 end *************");
1606
1607    })
1608    /**
1609     * @tc.name resultSet isColumnNull test
1610     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0193
1611     * @tc.desc resultSet isColumnNull test
1612     */
1613    it('testIsColumnNull0004', 0, async function (done) {
1614        console.log(TAG + "************* testIsColumnNull0004 start *************");
1615
1616        let predicates = await new dataRdb.RdbPredicates("test")
1617        let resultSet = await rdbStore.query(predicates)
1618        {
1619            resultSet.goToRow(2)
1620            expect(false).assertEqual(resultSet.isColumnNull(1))
1621            expect(true).assertEqual(resultSet.isColumnNull(4))
1622        }
1623        resultSet.close()
1624        resultSet = null;
1625        done();
1626        console.log(TAG + "************* testIsColumnNull0004 end *************");
1627
1628    })
1629
1630    /**
1631     * @tc.name resultSet getColumnIndex test
1632     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0200
1633     * @tc.desc resultSet getColumnIndex test
1634     */
1635    it('testGetColumnIndex0001', 0, async function (done) {
1636        console.log(TAG + "************* testGetColumnIndex0001 start *************");
1637
1638        let predicates = await new dataRdb.RdbPredicates("test")
1639        let resultSet = await rdbStore.query(predicates)
1640        expect(true).assertEqual(resultSet.goToFirstRow())
1641        expect(1).assertEqual(resultSet.getColumnIndex("data1"))
1642
1643        resultSet.close()
1644        resultSet = null;
1645        done();
1646        console.log(TAG + "************* testGetColumnIndex0001 end *************");
1647
1648    })
1649
1650    /**
1651     * @tc.name resultSet getColumnIndex test
1652     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0201
1653     * @tc.desc resultSet getColumnIndex test
1654     */
1655    it('testGetColumnIndex0002', 0, async function (done) {
1656        console.log(TAG + "************* testGetColumnIndex0002 start *************");
1657
1658        let predicates = await new dataRdb.RdbPredicates("test")
1659        predicates.equalTo("name", "wangwu");
1660        let resultSet = await rdbStore.query(predicates)
1661        expect(-1).assertEqual(resultSet.getColumnIndex("data1"))
1662
1663        resultSet.close()
1664        resultSet = null;
1665        done();
1666        console.log(TAG + "************* testGetColumnIndex0002 end *************");
1667
1668    })
1669
1670    /**
1671     * @tc.name resultSet getColumnIndex test
1672     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0202
1673     * @tc.desc resultSet getColumnIndex test
1674     */
1675    it('testGetColumnIndex0003', 0, async function (done) {
1676        console.log(TAG + "************* testGetColumnIndex0003 start *************");
1677
1678        let predicates = await new dataRdb.RdbPredicates("test")
1679        let resultSet = await rdbStore.query(predicates)
1680        expect(-1).assertEqual(resultSet.getColumnIndex("dataX"))
1681
1682        resultSet.close()
1683        resultSet = null;
1684        done();
1685        console.log(TAG + "************* testGetColumnIndex0003 end *************");
1686
1687    })
1688
1689    /**
1690     * @tc.name resultSet getColumnIndex test
1691     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0203
1692     * @tc.desc resultSet getColumnIndex test
1693     */
1694    it('testGetColumnIndex0004', 0, async function (done) {
1695        console.log(TAG + "************* testGetColumnIndex0004 start *************");
1696
1697        let predicates = await new dataRdb.RdbPredicates("test")
1698        let resultSet = await rdbStore.query(predicates)
1699        try {
1700            expect(-1).assertEqual(resultSet.getColumnIndex(""))
1701        } catch (err) {
1702            expect("401").assertEqual(err.code)
1703        }
1704        resultSet.close()
1705        resultSet = null
1706        done()
1707        console.log(TAG + "************* testGetColumnIndex0004 end *************");
1708
1709    })
1710
1711    /**
1712     * @tc.name resultSet getColumnName test
1713     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0210
1714     * @tc.desc resultSet getColumnName test
1715     */
1716    it('testGetColumnName0001', 0, async function (done) {
1717        console.log(TAG + "************* testGetColumnIndex0001 start *************");
1718
1719        let predicates = await new dataRdb.RdbPredicates("test")
1720        let resultSet = await rdbStore.query(predicates)
1721
1722        expect("data1").assertEqual(resultSet.getColumnName(1))
1723        expect("data4").assertEqual(resultSet.getColumnName(4))
1724
1725        resultSet.close()
1726        resultSet = null;
1727        done();
1728        console.log(TAG + "************* testGetColumnName0001 end *************");
1729
1730    })
1731
1732    /**
1733     * @tc.name resultSet getColumnName test
1734     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0211
1735     * @tc.desc resultSet getColumnName test
1736     */
1737    it('testGetColumnName0002', 0, async function (done) {
1738        console.log(TAG + "************* testGetColumnName0002 start *************");
1739
1740        let predicates = await new dataRdb.RdbPredicates("test")
1741        predicates.equalTo("name", "wangwu");
1742        let resultSet = await rdbStore.query(predicates)
1743
1744        expect("").assertEqual(resultSet.getColumnName(1))
1745        expect("").assertEqual(resultSet.getColumnName(4))
1746
1747        resultSet.close()
1748        resultSet = null;
1749        done();
1750        console.log(TAG + "************* testGetColumnName0002 end *************");
1751
1752    })
1753
1754    /**
1755     * @tc.name resultSet getColumnName test
1756     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0212
1757     * @tc.desc resultSet getColumnName test
1758     */
1759    it('testGetColumnName0003', 0, async function (done) {
1760        console.log(TAG + "************* testGetColumnName0003 start *************");
1761
1762        let predicates = await new dataRdb.RdbPredicates("test")
1763        let resultSet = await rdbStore.query(predicates)
1764
1765        expect("").assertEqual(resultSet.getColumnName(10))
1766
1767        resultSet.close()
1768        resultSet = null;
1769        done();
1770        console.log(TAG + "************* testGetColumnName0003 end *************");
1771
1772    })
1773
1774    /**
1775     * @tc.name resultSet getColumnName test
1776     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0213
1777     * @tc.desc resultSet getColumnName test
1778     */
1779    it('testGetColumnName0004', 0, async function (done) {
1780        console.log(TAG + "************* testGetColumnName0004 start *************");
1781
1782        let predicates = await new dataRdb.RdbPredicates("test")
1783        predicates.equalTo("name", "wangwu");
1784        let resultSet = await rdbStore.query(predicates)
1785
1786        expect("").assertEqual(resultSet.getColumnName(10))
1787
1788        resultSet.close()
1789        resultSet = null;
1790        done();
1791        console.log(TAG + "************* testGetColumnName0004 end *************");
1792
1793    })
1794
1795    /**
1796     * @tc.name resultSet close test
1797     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0220
1798     * @tc.desc resultSet close test
1799     */
1800    it('testClose0001', 0, async function (done) {
1801        console.log(TAG + "************* testClose0001 start *************");
1802
1803        let predicates = await new dataRdb.RdbPredicates("test")
1804        let resultSet = await rdbStore.query(predicates)
1805        resultSet.goToRow(1)
1806        resultSet.close()
1807        expect(true).assertEqual(resultSet.isClosed)
1808
1809        resultSet.close()
1810        resultSet = null;
1811        done();
1812        console.log(TAG + "************* testClose0001 end *************");
1813
1814    })
1815
1816    /**
1817     * @tc.name resultSet close test
1818     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0221
1819     * @tc.desc resultSet close test
1820     */
1821    it('testClose0002', 0, async function (done) {
1822        console.log(TAG + "************* testClose0002 start *************");
1823
1824        let predicates = await new dataRdb.RdbPredicates("test")
1825        predicates.equalTo("name", "wangwu");
1826        let resultSet = await rdbStore.query(predicates)
1827        resultSet.close()
1828        expect(true).assertEqual(resultSet.isClosed)
1829
1830        resultSet.close()
1831        resultSet = null;
1832        done();
1833        console.log(TAG + "************* testClose0002 end *************");
1834
1835    })
1836
1837    /**
1838     * @tc.name big resultSet data test
1839     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0222
1840     * @tc.desc big resultSet data test
1841     */
1842    it('testBigData0001', 0, async function (done) {
1843        console.log(TAG + "************* testBigData0001 start *************");
1844
1845        await createBigData(500);
1846        let resultSet = await rdbStore.querySql("SELECT * FROM test");
1847        let count = resultSet.rowCount;
1848        expect(500).assertEqual(count);
1849
1850        resultSet.goToFirstRow();
1851        let i = 0;
1852        while (resultSet.isEnded == false) {
1853            expect("test" + i++).assertEqual(resultSet.getString(1))
1854            resultSet.goToNextRow();
1855        }
1856
1857        resultSet.close()
1858        expect(true).assertEqual(resultSet.isClosed)
1859        resultSet = null;
1860        done();
1861        console.log(TAG + "************* testBigData0001 end *************");
1862
1863    })
1864
1865    /**
1866     * @tc.name big resultSet data test
1867     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0223
1868     * @tc.desc big resultSet data test
1869     */
1870    it('testBigData0002', 0, async function (done) {
1871        console.log(TAG + "************* testBigData0002 start *************");
1872
1873        await createBigData(500);
1874        let resultSet = await rdbStore.querySql("SELECT * FROM test");
1875        let count = resultSet.rowCount;
1876        expect(500).assertEqual(count);
1877
1878        resultSet.goToLastRow();
1879        let i = resultSet.rowCount;
1880        while (i >= 1) {
1881            expect("test" + --i).assertEqual(resultSet.getString(1))
1882            resultSet.goToPreviousRow();
1883        }
1884
1885        resultSet.close()
1886        expect(true).assertEqual(resultSet.isClosed)
1887        resultSet = null;
1888        done();
1889        console.log(TAG + "************* testBigData0002 end *************");
1890
1891    })
1892
1893    /**
1894     * @tc.name big resultSet data test
1895     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0224
1896     * @tc.desc big resultSet data test
1897     */
1898    it('testBigData0003', 0, async function (done) {
1899        console.log(TAG + "************* testBigData0003 start *************");
1900
1901        await createBigData(500);
1902        let resultSet = await rdbStore.querySql("SELECT * FROM test");
1903        let count = resultSet.rowCount;
1904        expect(500).assertEqual(count);
1905
1906        let rows = [62, 80, 59, 121, 45, 99, 42, 104, 41, 105, 499, 248];
1907        for (const i of rows) {
1908            resultSet.goToRow(i);
1909            expect("test" + i).assertEqual(resultSet.getString(1))
1910        }
1911
1912        resultSet.close()
1913        expect(true).assertEqual(resultSet.isClosed)
1914        resultSet = null;
1915        done();
1916        console.log(TAG + "************* testBigData0003 end *************");
1917
1918    })
1919
1920    /**
1921     * @tc.name big resultSet data test
1922     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0225
1923     * @tc.desc big resultSet data test
1924     */
1925    it('testBigData0004', 0, async function (done) {
1926        console.log(TAG + "************* testBigData0004 start *************");
1927
1928        await createBigData(0);
1929        let resultSet = await rdbStore.querySql("SELECT * FROM test");
1930        let count = resultSet.rowCount;
1931        expect(0).assertEqual(count);
1932
1933        resultSet.goToFirstRow();
1934        expect(false).assertEqual(resultSet.isStarted);
1935
1936        let rows = [1, 2, 0, -1, -2];
1937        for (const i of rows) {
1938            resultSet.goToRow(i);
1939            expect(false).assertEqual(resultSet.isStarted);
1940        }
1941
1942        resultSet.close()
1943        expect(true).assertEqual(resultSet.isClosed)
1944        resultSet = null;
1945        done();
1946        console.log(TAG + "************* testBigData0004 end *************");
1947
1948    })
1949
1950    /**
1951     * @tc.name big resultSet data test
1952     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0226
1953     * @tc.desc big resultSet data test
1954     */
1955    it('testBigData0005', 0, async function (done) {
1956        console.log(TAG + "************* testBigData0005 start *************");
1957
1958        await createBigData(1);
1959        let resultSet = await rdbStore.querySql("SELECT * FROM test");
1960        let count = resultSet.rowCount;
1961        expect(1).assertEqual(count);
1962
1963        resultSet.goToFirstRow();
1964        expect(true).assertEqual(resultSet.isStarted);
1965        expect("test0").assertEqual(resultSet.getString(1))
1966        try {
1967            let rows = [1, 2, -1, -2];
1968            for (const i of rows) {
1969                resultSet.goToRow(i)
1970                expect(true).assertEqual(resultSet.isStarted)
1971                expect("").assertEqual(resultSet.getString(1))
1972            }
1973        } catch (e) {
1974            expect(e.code).assertEqual("14800012");
1975        }
1976        resultSet.close()
1977        expect(true).assertEqual(resultSet.isClosed)
1978        resultSet = null;
1979        done();
1980        console.log(TAG + "************* testBigData0005 end *************");
1981
1982    })
1983
1984    /**
1985     * @tc.name big resultSet data test
1986     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0227
1987     * @tc.desc big resultSet data test
1988     */
1989    it('testBigData0006', 0, async function (done) {
1990        console.log(TAG + "************* testBigData0006 start *************");
1991
1992        await createBigData(2);
1993        let resultSet = await rdbStore.querySql("SELECT * FROM test");
1994        let count = resultSet.rowCount;
1995        expect(2).assertEqual(count);
1996
1997        resultSet.goToFirstRow();
1998        expect(true).assertEqual(resultSet.isStarted);
1999
2000        let rows = [0, 1];
2001        for (const i of rows) {
2002            resultSet.goToRow(i);
2003            expect(true).assertEqual(resultSet.isStarted);
2004            expect("test" + i).assertEqual(resultSet.getString(1))
2005        }
2006
2007        try {
2008            rows = [2, 3, 4, -1, -2];
2009            for (const i of rows) {
2010                resultSet.goToRow(i);
2011                expect(true).assertEqual(resultSet.isStarted);
2012                expect("").assertEqual(resultSet.getString(1))
2013            }
2014        } catch (e) {
2015            expect(e.code).assertEqual("14800012");
2016        }
2017
2018        resultSet.close()
2019        expect(true).assertEqual(resultSet.isClosed)
2020        resultSet = null;
2021        done();
2022        console.log(TAG + "************* testBigData0006 end *************");
2023
2024    })
2025
2026    /**
2027     * @tc.name big resultSet data test
2028     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0228
2029     * @tc.desc big resultSet data test
2030     */
2031    it('testBigData0007', 0, async function (done) {
2032        console.log(TAG + "************* testBigData0007 start *************");
2033
2034        await createBigData(500);
2035        let resultSet = await rdbStore.querySql("SELECT * FROM test");
2036        let count = resultSet.rowCount;
2037        expect(500).assertEqual(count);
2038
2039        let rows = [62, 80, 59, 121, 45, -1, 99, 42, 104, 41, 105, 499, 248];
2040        for (const i of rows) {
2041            resultSet.goToRow(i);
2042            if (i > 0) {
2043                expect("test" + i).assertEqual(resultSet.getString(1))
2044            } else {
2045                expect("test45").assertEqual(resultSet.getString(1))
2046            }
2047        }
2048
2049        resultSet.close()
2050        expect(true).assertEqual(resultSet.isClosed)
2051        resultSet = null;
2052        done();
2053        console.log(TAG + "************* testBigData0007 end *************");
2054
2055    })
2056
2057    /**
2058     * @tc.name big resultSet data test
2059     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0229
2060     * @tc.desc big resultSet data test
2061     */
2062    it('testBigData0008', 0, async function (done) {
2063        console.log(TAG + "************* testBigData0008 start *************");
2064
2065        await createBigData(200);
2066        let resultSet = await rdbStore.querySql("SELECT * FROM test");
2067        let count = resultSet.rowCount;
2068        expect(200).assertEqual(count);
2069
2070        let i = 0;
2071        while (resultSet.goToNextRow() == 0) {
2072            expect("test" + i++).assertEqual(resultSet.getString(1))
2073        }
2074
2075        resultSet.close()
2076        expect(true).assertEqual(resultSet.isClosed)
2077        resultSet = null;
2078        done();
2079        console.log(TAG + "************* testBigData0008 end *************");
2080
2081    })
2082
2083    /**
2084     * @tc.name big resultSet data test
2085     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0230
2086     * @tc.desc big resultSet data test
2087     */
2088    it('testBigData0009', 0, async function (done) {
2089        console.log(TAG + "************* testBigData0009 start *************");
2090
2091        await createBigData(200);
2092        let resultSet = await rdbStore.querySql("SELECT * FROM test");
2093        let count = resultSet.rowCount;
2094        expect(200).assertEqual(count);
2095
2096        let i = 0;
2097        while (i < 200) {
2098            resultSet.goToRow(i);
2099            expect("test" + i).assertEqual(resultSet.getString(1))
2100            i++;
2101        }
2102
2103        resultSet.close()
2104        expect(true).assertEqual(resultSet.isClosed)
2105        resultSet = null;
2106        done();
2107        console.log(TAG + "************* testBigData0009 end *************");
2108
2109    })
2110
2111    /**
2112     * @tc.name big resultSet data test
2113     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0231
2114     * @tc.desc big resultSet data test
2115     */
2116    it('testBigData0010', 0, async function (done) {
2117        console.log(TAG + "************* testBigData0010 start *************");
2118
2119        await createBigData(200);
2120        let resultSet = await rdbStore.querySql("SELECT * FROM test");
2121        let count = resultSet.rowCount;
2122        expect(200).assertEqual(count);
2123
2124        resultSet.goToFirstRow();
2125        let i = 0;
2126        while (resultSet.isEnded == false) {
2127            expect("test" + i++).assertEqual(resultSet.getString(1))
2128            resultSet.goToNextRow();
2129        }
2130
2131        i = 0;
2132        while (i < 200) {
2133            resultSet.goToRow(i);
2134            expect("test" + i).assertEqual(resultSet.getString(1))
2135            i++;
2136        }
2137
2138        resultSet.close()
2139        expect(true).assertEqual(resultSet.isClosed)
2140        resultSet = null;
2141        done();
2142        console.log(TAG + "************* testBigData0010 end *************");
2143
2144    })
2145
2146    /**
2147     * @tc.name big resultSet data test
2148     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0232
2149     * @tc.desc big resultSet data test
2150     */
2151    it('testBigData0011', 0, async function (done) {
2152        console.log(TAG + "************* testBigData0011 start *************");
2153
2154        await createBigData(200);
2155        let resultSet = await rdbStore.querySql("SELECT * FROM test");
2156        let count = resultSet.rowCount;
2157        expect(200).assertEqual(count);
2158
2159        let i = 0;
2160        while (i < 200) {
2161            resultSet.goToRow(i);
2162            expect("test" + i).assertEqual(resultSet.getString(1))
2163            i++;
2164        }
2165
2166        resultSet.goToFirstRow();
2167        i = 0;
2168        while (resultSet.isEnded == false) {
2169            expect("test" + i++).assertEqual(resultSet.getString(1))
2170            resultSet.goToNextRow();
2171        }
2172
2173        resultSet.close()
2174        expect(true).assertEqual(resultSet.isClosed)
2175        resultSet = null;
2176        done();
2177        console.log(TAG + "************* testBigData0011 end *************");
2178
2179    })
2180
2181    /**
2182     * @tc.name big resultSet data test
2183     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0232
2184     * @tc.desc big resultSet data test
2185     */
2186    it('testBigData0012', 0, async function (done) {
2187        console.log(TAG + "************* testBigData0012 start *************");
2188
2189        await createBigData(1);
2190        let resultSet = await rdbStore.querySql("SELECT * FROM test");
2191        let count = resultSet.rowCount;
2192        expect(1).assertEqual(count);
2193
2194        let i = 0;
2195        resultSet.goToNextRow();
2196        expect("test0").assertEqual(resultSet.getString(1))
2197
2198        resultSet.close()
2199        expect(true).assertEqual(resultSet.isClosed)
2200        resultSet = null;
2201        done();
2202        console.log(TAG + "************* testBigData0012 end *************");
2203
2204    })
2205
2206    /**
2207     * @tc.name big resultSet data test
2208     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0232
2209     * @tc.desc big resultSet data test
2210     */
2211    it('testBigData0013', 0, async function (done) {
2212        console.log(TAG + "************* testBigData0013 start *************");
2213
2214        await createBigData(200);
2215        let resultSet = await rdbStore.querySql("SELECT * FROM test");
2216        let count = resultSet.rowCount;
2217        expect(200).assertEqual(count);
2218
2219        resultSet.goToFirstRow();
2220        let i = 0;
2221        while (resultSet.isEnded == false) {
2222            expect("test" + i++).assertEqual(resultSet.getString(1))
2223            resultSet.goToNextRow();
2224        }
2225
2226        resultSet.goToRow(1);
2227        expect("test1").assertEqual(resultSet.getString(1))
2228
2229        resultSet.goToRow(5);
2230        expect("test5").assertEqual(resultSet.getString(1))
2231
2232        resultSet.close()
2233        expect(true).assertEqual(resultSet.isClosed)
2234        resultSet = null;
2235        done();
2236        console.log(TAG + "************* testBigData0013 end *************");
2237
2238    })
2239
2240    /**
2241     * @tc.name big resultSet data test
2242     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0233
2243     * @tc.desc big resultSet data test
2244     */
2245    it('testBigData0014', 0, async function (done) {
2246        console.log(TAG + "************* testBigData0014 start *************");
2247
2248        await createBigData(5);
2249        let resultSet = await rdbStore.querySql("SELECT * FROM test");
2250        let count = resultSet.rowCount;
2251        expect(5).assertEqual(count);
2252
2253        resultSet.goToFirstRow();
2254        let i = 0;
2255        while (resultSet.isEnded == false) {
2256            expect("test" + i++).assertEqual(resultSet.getString(1))
2257            resultSet.goToNextRow();
2258        }
2259
2260        i = 0;
2261        while (i < 5) {
2262            resultSet.goToRow(i);
2263            expect("test" + i).assertEqual(resultSet.getString(1))
2264            i++;
2265        }
2266
2267        resultSet.close()
2268        expect(true).assertEqual(resultSet.isClosed)
2269        resultSet = null;
2270        done();
2271        console.log(TAG + "************* testBigData0014 end *************");
2272
2273    })
2274    console.log(TAG + "*************Unit Test End*************");
2275})