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