1/*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
16import factory from '@ohos.data.distributedData'
17
18const KEY_TEST_INT_ELEMENT = 'key_test_int_2';
19const KEY_TEST_FLOAT_ELEMENT = 'key_test_float_2';
20const KEY_TEST_BOOLEAN_ELEMENT = 'key_test_boolean_2';
21const KEY_TEST_STRING_ELEMENT = 'key_test_string_2';
22const KEY_TEST_SYNC_ELEMENT = 'key_test_sync';
23
24const VALUE_TEST_INT_ELEMENT = 1234;
25const VALUE_TEST_FLOAT_ELEMENT = 4321.12;
26const VALUE_TEST_BOOLEAN_ELEMENT = true;
27const VALUE_TEST_STRING_ELEMENT = 'value-string-002';
28const VALUE_TEST_SYNC_ELEMENT = 'value-string-001';
29
30const TEST_BUNDLE_NAME = 'com.example.myapplication';
31const TEST_STORE_ID = 'storeId';
32var kvManager = null;
33var kvStore = null;
34const USED_DEVICE_IDS =  ['A12C1F9261528B21F95778D2FDC0B2E33943E6251AC5487F4473D005758905DB'];
35const UNUSED_DEVICE_IDS =  [];  /* add you test device-ids here */
36var syncDeviceIds = USED_DEVICE_IDS.concat(UNUSED_DEVICE_IDS);
37
38function sleep(ms) {
39    return new Promise(resolve => setTimeout(resolve, ms));
40}
41
42function putBatchString(len, prefix) {
43    let entries = [];
44    for (var i = 0; i < len; i++) {
45        var entry = {
46            key : prefix + i,
47            value : {
48                type : factory.ValueType.STRING,
49                value : 'batch_test_string_value'
50            }
51        }
52        entries.push(entry);
53    }
54    return entries;
55}
56
57describe('singleKvStoreCallbackTest', function () {
58    const config = {
59        bundleName : TEST_BUNDLE_NAME,
60        userInfo : {
61            userId : '0',
62            userType : factory.UserType.SAME_USER_ID
63        }
64    }
65
66    const options = {
67        createIfMissing : true,
68        encrypt : false,
69        backup : false,
70        autoSync : true,
71        kvStoreType : factory.KVStoreType.SINGLE_VERSION,
72        schema : '',
73        securityLevel : factory.SecurityLevel.S2,
74    }
75
76    beforeAll(async function (done) {
77        console.info('beforeAll config:'+ JSON.stringify(config));
78        await factory.createKVManager(config, function (err, manager) {
79            kvManager = manager;
80            console.info('beforeAll createKVManager success');
81            done();
82        })
83    })
84
85    afterAll(async function (done) {
86        console.info('afterAll');
87        kvManager = null;
88        kvStore = null;
89        done();
90    })
91
92    beforeEach(async function (done) {
93        console.info('beforeEach' + JSON.stringify(options));
94        await kvManager.getKVStore(TEST_STORE_ID, options, function (err, store) {
95            kvStore = store;
96            console.info('beforeEach getKVStore success');
97            done();
98        });
99    })
100
101    afterEach(async function (done) {
102        console.info('afterEach');
103        await kvManager.closeKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, kvStore, async function (err, data) {
104            console.info('afterEach closeKVStore success');
105            await kvManager.deleteKVStore(TEST_BUNDLE_NAME, TEST_STORE_ID, function (err, data) {
106                console.info('afterEach deleteKVStore success');
107                done();
108            });
109        });
110        kvStore = null;
111    })
112
113    /**
114     * @tc.name SingleKvStorePutStringCallbackTest001
115     * @tc.desc Test Js Api SingleKvStore.Put(String) testcase 001
116     * @tc.type: FUNC
117     * @tc.require: issueNumber
118     */
119    it('SingleKvStorePutStringCallbackTest001', 0, async function (done) {
120        console.info('SingleKvStorePutStringCallbackTest001');
121        try {
122            await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, function (err,data) {
123                if (err == undefined) {
124                    console.info('SingleKvStorePutStringCallbackTest001 put success');
125                } else {
126                    console.error('SingleKvStorePutStringCallbackTest001 put fail' + `, error code is ${err.code}, message is ${err.message}`);
127                    expect(null).assertFail();
128                }
129                done();
130            });
131        }catch (e) {
132            console.error('SingleKvStorePutStringCallbackTest001 put e' + `, error code is ${e.code}, message is ${e.message}`);
133            expect(null).assertFail();
134            done();
135        }
136    })
137
138    /**
139     * @tc.name SingleKvStorePutStringCallbackTest002
140     * @tc.desc Test Js Api SingleKvStore.Put(String) testcase 002
141     * @tc.type: FUNC
142     * @tc.require: issueNumber
143     */
144    it('SingleKvStorePutStringCallbackTest002', 0, async function (done) {
145        console.info('SingleKvStorePutStringCallbackTest002');
146        try {
147            var str = '';
148            for (var i = 0 ; i < 4095; i++) {
149                str += 'x';
150            }
151            await kvStore.put(KEY_TEST_STRING_ELEMENT+'102', str, async function (err,data) {
152                console.info('SingleKvStorePutStringCallbackTest002 put success');
153                expect(err == undefined).assertTrue();
154                await kvStore.get(KEY_TEST_STRING_ELEMENT+'102', function (err,data) {
155                    console.info('SingleKvStorePutStringCallbackTest002 get success');
156                    expect(str == data).assertTrue();
157                    done();
158                });
159            });
160        }catch (e) {
161            console.error('SingleKvStorePutStringCallbackTest002 put e' + `, error code is ${e.code}, message is ${e.message}`);
162            expect(null).assertFail();
163            done();
164        }
165    })
166
167    /**
168     * @tc.name SingleKvStoreGetStringCallbackTest001
169     * @tc.desc Test Js Api SingleKvStore.GetString() testcase 001
170     * @tc.type: FUNC
171     * @tc.require: issueNumber
172     */
173    it('SingleKvStoreGetStringCallbackTest001', 0, async function (done) {
174        console.info('SingleKvStoreGetStringCallbackTest001');
175        try{
176            await kvStore.get(KEY_TEST_STRING_ELEMENT, function (err,data) {
177                if (err == undefined) {
178                    console.info('SingleKvStoreGetStringCallbackTest001 get success');
179                    expect(null).assertFail();
180                } else {
181                    console.info('SingleKvStoreGetStringCallbackTest001 get fail');
182                }
183                done();
184            });
185        }catch(e) {
186            console.error('SingleKvStoreGetStringCallbackTest001 get e' + `, error code is ${e.code}, message is ${e.message}`);
187            expect(null).assertFail();
188            done();
189        }
190    })
191
192    /**
193     * @tc.name SingleKvStoreGetStringCallbackTest002
194     * @tc.desc Test Js Api SingleKvStore.GetString() testcase 002
195     * @tc.type: FUNC
196     * @tc.require: issueNumber
197     */
198    it('SingleKvStoreGetStringCallbackTest002', 0, async function (done) {
199        console.info('SingleKvStoreGetStringCallbackTest002');
200        try{
201            await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, async function (err,data) {
202                console.info('SingleKvStoreGetStringCallbackTest002 put success');
203                expect(err == undefined).assertTrue();
204                await kvStore.get(KEY_TEST_STRING_ELEMENT, function (err,data) {
205                    console.info('SingleKvStoreGetStringCallbackTest002 get success');
206                    expect((err == undefined) && (VALUE_TEST_STRING_ELEMENT == data)).assertTrue();
207                    done();
208                });
209            })
210        }catch(e) {
211            console.error('SingleKvStoreGetStringCallbackTest002 get e' + `, error code is ${e.code}, message is ${e.message}`);
212            expect(null).assertFail();
213            done();
214        }
215    })
216
217    /**
218     * @tc.name SingleKvStorePutIntCallbackTest001
219     * @tc.desc Test Js Api SingleKvStore.Put(Int) testcase 001
220     * @tc.type: FUNC
221     * @tc.require: issueNumber
222     */
223    it('SingleKvStorePutIntCallbackTest001', 0, async function (done) {
224        console.info('SingleKvStorePutIntCallbackTest001');
225        try {
226            await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT, async function (err,data) {
227                console.info('SingleKvStorePutIntCallbackTest001 put success');
228                expect(err == undefined).assertTrue();
229                await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) {
230                    console.info('SingleKvStorePutIntCallbackTest001 get success');
231                    expect((err == undefined) && (VALUE_TEST_INT_ELEMENT == data)).assertTrue();
232                    done();
233                })
234            });
235        }catch(e) {
236            console.error('SingleKvStorePutIntCallbackTest001 put e' + `, error code is ${e.code}, message is ${e.message}`);
237            expect(null).assertFail();
238            done();
239        }
240    })
241
242    /**
243     * @tc.name SingleKvStorePutIntCallbackTest002
244     * @tc.desc Test Js Api SingleKvStore.Put(Int) testcase 002
245     * @tc.type: FUNC
246     * @tc.require: issueNumber
247     */
248    it('SingleKvStorePutIntCallbackTest002', 0, async function (done) {
249        console.info('SingleKvStorePutIntCallbackTest002');
250        try {
251            var intValue = 987654321;
252            await kvStore.put(KEY_TEST_INT_ELEMENT, intValue, async function (err,data) {
253                console.info('SingleKvStorePutIntCallbackTest002 put success');
254                expect(err == undefined).assertTrue();
255                await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) {
256                    console.info('SingleKvStorePutIntCallbackTest002 get success');
257                    expect((err == undefined) && (intValue == data)).assertTrue();
258                    done();
259                })
260            });
261        }catch(e) {
262            console.error('SingleKvStorePutIntCallbackTest002 put e' + `, error code is ${e.code}, message is ${e.message}`);
263            expect(null).assertFail();
264            done();
265        }
266    })
267
268    /**
269     * @tc.name SingleKvStorePutIntCallbackTest003
270     * @tc.desc Test Js Api SingleKvStore.Put(Int) testcase 003
271     * @tc.type: FUNC
272     * @tc.require: issueNumber
273     */
274    it('SingleKvStorePutIntCallbackTest003', 0, async function (done) {
275        console.info('SingleKvStorePutIntCallbackTest003');
276        try {
277            var intValue = Number.MIN_VALUE;
278            await kvStore.put(KEY_TEST_INT_ELEMENT, intValue, async function (err,data) {
279                console.info('SingleKvStorePutIntCallbackTest003 put success');
280                expect(err == undefined).assertTrue();
281                await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) {
282                    console.info('SingleKvStorePutIntCallbackTest003 get success');
283                    expect((err == undefined) && (intValue == data)).assertTrue();
284                    done();
285                })
286            });
287        }catch(e) {
288            console.error('SingleKvStorePutIntCallbackTest003 put e' + `, error code is ${e.code}, message is ${e.message}`);
289            expect(null).assertFail();
290            done();
291        }
292    })
293
294    /**
295     * @tc.name SingleKvStorePutIntCallbackTest004
296     * @tc.desc Test Js Api SingleKvStore.Put(Int) testcase 004
297     * @tc.type: FUNC
298     * @tc.require: issueNumber
299     */
300    it('SingleKvStorePutIntCallbackTest004', 0, async function (done) {
301        console.info('SingleKvStorePutIntCallbackTest004');
302        try {
303            var intValue = Number.MAX_VALUE;
304            await kvStore.put(KEY_TEST_INT_ELEMENT, intValue, async function (err,data) {
305                console.info('SingleKvStorePutIntCallbackTest004 put success');
306                expect(err == undefined).assertTrue();
307                await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) {
308                    console.info('SingleKvStorePutIntCallbackTest004 get success');
309                    expect((err == undefined) && (intValue == data)).assertTrue();
310                    done();
311                })
312            });
313        }catch(e) {
314            console.error('SingleKvStorePutIntCallbackTest004 put e' + `, error code is ${e.code}, message is ${e.message}`);
315            expect(null).assertFail();
316            done();
317        }
318    })
319
320    /**
321     * @tc.name SingleKvStoreGetIntCallbackTest001
322     * @tc.desc Test Js Api SingleKvStore.GetInt() testcase 001
323     * @tc.type: FUNC
324     * @tc.require: issueNumber
325     */
326    it('SingleKvStoreGetIntCallbackTest001', 0, async function (done) {
327        console.info('SingleKvStoreGetIntCallbackTest001');
328        try {
329            await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT, async function (err,data) {
330                console.info('SingleKvStoreGetIntCallbackTest001 put success');
331                expect(err == undefined).assertTrue();
332                await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) {
333                    console.info('SingleKvStoreGetIntCallbackTest001 get success');
334                    expect((err == undefined) && (VALUE_TEST_INT_ELEMENT == data)).assertTrue();
335                    done();
336                })
337            });
338        }catch(e) {
339            console.error('SingleKvStoreGetIntCallbackTest001 put e' + `, error code is ${e.code}, message is ${e.message}`);
340            expect(null).assertFail();
341            done();
342        }
343    })
344
345    /**
346     * @tc.name SingleKvStoreGetIntCallbackTest002
347     * @tc.desc Test Js Api SingleKvStore.GetInt() testcase 002
348     * @tc.type: FUNC
349     * @tc.require: issueNumber
350     */
351    it('SingleKvStoreGetIntCallbackTest002', 0, async function (done) {
352        console.info('SingleKvStoreGetIntCallbackTest002');
353        try {
354            await kvStore.get(KEY_TEST_INT_ELEMENT, function (err,data) {
355                if (err == undefined) {
356                    console.info('SingleKvStoreGetIntCallbackTest002 get success');
357                    expect(null).assertFail();
358                } else {
359                    console.info('SingleKvStoreGetIntCallbackTest002 get fail');
360                }
361                done();
362            })
363        }catch(e) {
364            console.error('SingleKvStoreGetIntCallbackTest002 put e' + `, error code is ${e.code}, message is ${e.message}`);
365            expect(null).assertFail();
366            done();
367        }
368    })
369
370    /**
371     * @tc.name SingleKvStorePutBoolCallbackTest001
372     * @tc.desc Test Js Api SingleKvStore.Put(Bool) testcase 001
373     * @tc.type: FUNC
374     * @tc.require: issueNumber
375     */
376    it('SingleKvStorePutBoolCallbackTest001', 0, async function (done) {
377        console.info('SingleKvStorePutBoolCallbackTest001');
378        try {
379            await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT, function (err,data) {
380                console.info('SingleKvStorePutBoolCallbackTest001 put success');
381                expect(err == undefined).assertTrue();
382                done();
383            });
384        }catch(e) {
385            console.error('SingleKvStorePutBoolCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
386            expect(null).assertFail();
387            done();
388        }
389    })
390
391    /**
392     * @tc.name SingleKvStoreGetBoolCallbackTest001
393     * @tc.desc Test Js Api SingleKvStore.GetBool() testcase 001
394     * @tc.type: FUNC
395     * @tc.require: issueNumber
396     */
397    it('SingleKvStoreGetBoolCallbackTest001', 0, async function (done) {
398        console.info('SingleKvStoreGetBoolCallbackTest001');
399        try {
400            await kvStore.get(KEY_TEST_BOOLEAN_ELEMENT, function (err,data) {
401                if (err == undefined) {
402                    console.info('SingleKvStoreGetBoolCallbackTest001 get success');
403                    expect(null).assertFail();
404                } else {
405                    console.error('SingleKvStoreGetBoolCallbackTest001 get fail' + `, error code is ${err.code}, message is ${err.message}`);
406                }
407                done();
408            });
409        }catch(e) {
410            console.error('SingleKvStoreGetBoolCallbackTest001 e' + `, error code is ${e.code}, message is ${e.message}`);
411            expect(null).assertFail();
412            done();
413        }
414    })
415
416    /**
417     * @tc.name SingleKvStoreGetBoolCallbackTest002
418     * @tc.desc Test Js Api SingleKvStore.GetBool() testcase 002
419     * @tc.type: FUNC
420     * @tc.require: issueNumber
421     */
422    it('SingleKvStoreGetBoolCallbackTest002', 0, async function (done) {
423        console.info('SingleKvStoreGetBoolCallbackTest002');
424        try {
425            await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT, async function (err, data) {
426                console.info('SingleKvStoreGetBoolCallbackTest002 put success');
427                expect(err == undefined).assertTrue();
428                await kvStore.get(KEY_TEST_BOOLEAN_ELEMENT, function (err,data) {
429                    console.info('SingleKvStoreGetBoolCallbackTest002 get success');
430                    expect((err == undefined) && (VALUE_TEST_BOOLEAN_ELEMENT == data)).assertTrue();
431                    done();
432                });
433            })
434        }catch(e) {
435            console.error('SingleKvStoreGetBoolCallbackTest002 e' + `, error code is ${e.code}, message is ${e.message}`);
436            expect(null).assertFail();
437            done();
438        }
439    })
440
441    /**
442     * @tc.name SingleKvStorePutFloatCallbackTest001
443     * @tc.desc Test Js Api SingleKvStore.Put(Float) testcase 001
444     * @tc.type: FUNC
445     * @tc.require: issueNumber
446     */
447    it('SingleKvStorePutFloatCallbackTest001', 0, async function (done) {
448        console.info('SingleKvStorePutFloatCallbackTest001');
449        try {
450            await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, function (err,data) {
451                console.info('SingleKvStorePutFloatCallbackTest001 put success');
452                expect(err == undefined).assertTrue();
453                done();
454            });
455        }catch(e) {
456            console.error('SingleKvStorePutFloatCallbackTest001 e' + `, error code is ${e.code}, message is ${e.message}`);
457            expect(null).assertFail();
458            done();
459        }
460    })
461
462    /**
463     * @tc.name SingleKvStorePutFloatCallbackTest002
464     * @tc.desc Test Js Api SingleKvStore.Put(Float) testcase 002
465     * @tc.type: FUNC
466     * @tc.require: issueNumber
467     */
468    it('SingleKvStorePutFloatCallbackTest002', 0, async function (done) {
469        console.info('SingleKvStorePutFloatCallbackTest002');
470        try {
471            var floatValue = 123456.654321;
472            await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue, async function (err,data) {
473                console.info('SingleKvStorePutFloatCallbackTest002 put success');
474                expect(err == undefined).assertTrue();
475                await kvStore.get(KEY_TEST_FLOAT_ELEMENT, function (err, data) {
476                    console.info('SingleKvStorePutFloatCallbackTest002 get success');
477                    expect((err == undefined) && (floatValue == data)).assertTrue();
478                    done();
479                })
480                done();
481            });
482        }catch(e) {
483            console.error('SingleKvStorePutFloatCallbackTest002 e' + `, error code is ${e.code}, message is ${e.message}`);
484            expect(null).assertFail();
485            done();
486        }
487    })
488
489    /**
490     * @tc.name SingleKvStorePutFloatCallbackTest003
491     * @tc.desc Test Js Api SingleKvStore.Put(Float) testcase 003
492     * @tc.type: FUNC
493     * @tc.require: issueNumber
494     */
495    it('SingleKvStorePutFloatCallbackTest003', 0, async function (done) {
496        console.info('SingleKvStorePutFloatCallbackTest003');
497        try {
498            var floatValue = 123456.0;
499            await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue, async function (err,data) {
500                console.info('SingleKvStorePutFloatCallbackTest003 put success');
501                expect(err == undefined).assertTrue();
502                await kvStore.get(KEY_TEST_FLOAT_ELEMENT, function (err, data) {
503                    console.info('SingleKvStorePutFloatCallbackTest003 get success');
504                    expect((err == undefined) && (floatValue == data)).assertTrue();
505                    done();
506                })
507                done();
508            });
509        }catch(e) {
510            console.error('SingleKvStorePutFloatCallbackTest003 e' + `, error code is ${e.code}, message is ${e.message}`);
511            expect(null).assertFail();
512            done();
513        }
514    })
515
516    /**
517     * @tc.name SingleKvStorePutFloatCallbackTest004
518     * @tc.desc Test Js Api SingleKvStore.Put(Float) testcase 004
519     * @tc.type: FUNC
520     * @tc.require: issueNumber
521     */
522    it('SingleKvStorePutFloatCallbackTest004', 0, async function (done) {
523        console.info('SingleKvStorePutFloatCallbackTest004');
524        try {
525            var floatValue = 123456.00;
526            await kvStore.put(KEY_TEST_FLOAT_ELEMENT, floatValue, async function (err,data) {
527                console.info('SingleKvStorePutFloatCallbackTest004 put success');
528                expect(err == undefined).assertTrue();
529                await kvStore.get(KEY_TEST_FLOAT_ELEMENT, function (err, data) {
530                    console.info('SingleKvStorePutFloatCallbackTest004 get success');
531                    expect((err == undefined) && (floatValue == data)).assertTrue();
532                    done();
533                })
534                done();
535            });
536        }catch(e) {
537            console.error('SingleKvStorePutFloatCallbackTest004 e' + `, error code is ${e.code}, message is ${e.message}`);
538            expect(null).assertFail();
539            done();
540        }
541    })
542
543    /**
544     * @tc.name SingleKvStoreGetFloatCallbackTest001
545     * @tc.desc Test Js Api SingleKvStore.GetFloat() testcase 001
546     * @tc.type: FUNC
547     * @tc.require: issueNumber
548     */
549    it('SingleKvStoreGetFloatCallbackTest001', 0, async function (done) {
550        console.info('SingleKvStoreGetFloatCallbackTest001');
551        try {
552            await kvStore.get(KEY_TEST_FLOAT_ELEMENT, function (err,data) {
553                if (err == undefined) {
554                    console.info('SingleKvStoreGetFloatCallbackTest001 get success');
555                    expect(null).assertFail();
556                } else {
557                    console.error('SingleKvStoreGetFloatCallbackTest001 get fail' + `, error code is ${err.code}, message is ${err.message}`);
558                }
559                done();
560            });
561        }catch(e) {
562            console.error('SingleKvStoreGetFloatCallbackTest001 e' + `, error code is ${e.code}, message is ${e.message}`);
563            expect(null).assertFail();
564            done();
565        }
566    })
567
568    /**
569     * @tc.name SingleKvStoreDeleteStringCallbackTest001
570     * @tc.desc Test Js Api SingleKvStore.DeleteString() testcase 001
571     * @tc.type: FUNC
572     * @tc.require: issueNumber
573     */
574    it('SingleKvStoreDeleteStringCallbackTest001', 0, async function (done) {
575        console.info('SingleKvStoreDeleteStringCallbackTest001');
576        try {
577            await kvStore.delete(KEY_TEST_STRING_ELEMENT, function (err,data) {
578                if (err == undefined) {
579                    console.info('SingleKvStoreDeleteStringCallbackTest001 delete success');
580                } else {
581                    console.error('SingleKvStoreDeleteStringCallbackTest001 delete fail' + `, error code is ${err.code}, message is ${err.message}`);
582                    expect(null).assertFail();
583                }
584                done();
585            });
586        }catch(e) {
587            console.error('SingleKvStoreDeleteStringCallbackTest001 e' + `, error code is ${e.code}, message is ${e.message}`);
588            expect(null).assertFail();
589            done();
590        }
591    })
592
593    /**
594     * @tc.name SingleKvStoreDeleteStringCallbackTest002
595     * @tc.desc Test Js Api SingleKvStore.DeleteString() testcase 002
596     * @tc.type: FUNC
597     * @tc.require: issueNumber
598     */
599    it('SingleKvStoreDeleteStringCallbackTest002', 0, async function (done) {
600        console.info('SingleKvStoreDeleteStringCallbackTest002');
601        try {
602            await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, async function (err, data) {
603                console.info('SingleKvStoreDeleteStringCallbackTest002 put success');
604                expect(err == undefined).assertTrue();
605                await kvStore.delete(KEY_TEST_STRING_ELEMENT, function (err,data) {
606                    console.info('SingleKvStoreDeleteStringCallbackTest002 delete success');
607                    expect(err == undefined).assertTrue();
608                    done();
609                });
610            })
611        }catch(e) {
612            console.error('SingleKvStoreDeleteStringCallbackTest002 e' + `, error code is ${e.code}, message is ${e.message}`);
613            expect(null).assertFail();
614            done();
615        }
616    })
617
618    /**
619     * @tc.name SingleKvStoreDeleteIntCallbackTest001
620     * @tc.desc Test Js Api SingleKvStore.DeleteInt() testcase 001
621     * @tc.type: FUNC
622     * @tc.require: issueNumber
623     */
624    it('SingleKvStoreDeleteIntCallbackTest001', 0, async function (done) {
625        console.info('SingleKvStoreDeleteIntCallbackTest001');
626        try{
627            await kvStore.delete(KEY_TEST_INT_ELEMENT, function (err,data) {
628                if (err == undefined) {
629                    console.info('SingleKvStoreDeleteIntCallbackTest001 get success');
630                } else {
631                    console.error('SingleKvStoreDeleteIntCallbackTest001 get fail' + `, error code is ${err.code}, message is ${err.message}`);
632                    expect(null).assertFail();
633                }
634                done();
635            });
636        }catch(e) {
637            console.error('SingleKvStoreDeleteIntCallbackTest001 e' + `, error code is ${e.code}, message is ${e.message}`);
638            expect(null).assertFail();
639            done();
640        }
641    })
642
643    /**
644     * @tc.name SingleKvStoreDeleteIntCallbackTest002
645     * @tc.desc Test Js Api SingleKvStore.DeleteInt() testcase 002
646     * @tc.type: FUNC
647     * @tc.require: issueNumber
648     */
649    it('SingleKvStoreDeleteIntCallbackTest002', 0, async function (done) {
650        console.info('SingleKvStoreDeleteIntCallbackTest002');
651        try{
652            await kvStore.put(KEY_TEST_INT_ELEMENT, VALUE_TEST_INT_ELEMENT, async function (err,data) {
653                console.info('SingleKvStoreDeleteIntCallbackTest002 put success');
654                expect(err == undefined).assertTrue();
655                await kvStore.delete(KEY_TEST_INT_ELEMENT, function (err,data) {
656                    console.info('SingleKvStoreDeleteIntCallbackTest002 delete success');
657                    expect(err == undefined).assertTrue();
658                    done();
659                });
660            })
661        }catch(e) {
662            console.error('SingleKvStoreDeleteIntCallbackTest002 e' + `, error code is ${e.code}, message is ${e.message}`);
663            expect(null).assertFail();
664            done();
665        }
666    })
667
668    /**
669     * @tc.name SingleKvStoreDeleteFloatCallbackTest001
670     * @tc.desc Test Js Api SingleKvStore.DeleteFloat() testcase 001
671     * @tc.type: FUNC
672     * @tc.require: issueNumber
673     */
674    it('SingleKvStoreDeleteFloatCallbackTest001', 0, async function (done) {
675        console.info('SingleKvStoreDeleteFloatCallbackTest001');
676        try{
677            await kvStore.delete(KEY_TEST_FLOAT_ELEMENT, function (err,data) {
678                if (err == undefined) {
679                    console.info('SingleKvStoreDeleteFloatCallbackTest001 get success');
680                } else {
681                    console.error('SingleKvStoreDeleteFloatCallbackTest001 get fail' + `, error code is ${err.code}, message is ${err.message}`);
682                    expect(null).assertFail();
683                }
684                done();
685            });
686        }catch(e) {
687            console.error('SingleKvStoreDeleteFloatCallbackTest001 e' + `, error code is ${e.code}, message is ${e.message}`);
688            expect(null).assertFail();
689            done();
690        }
691    })
692
693    /**
694     * @tc.name SingleKvStoreDeleteFloatCallbackTest002
695     * @tc.desc Test Js Api SingleKvStore.DeleteFloat() testcase 002
696     * @tc.type: FUNC
697     * @tc.require: issueNumber
698     */
699    it('SingleKvStoreDeleteFloatCallbackTest002', 0, async function (done) {
700        console.info('SingleKvStoreDeleteFloatCallbackTest002');
701        try{
702            await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, async function (err, data) {
703                console.info('SingleKvStoreDeleteFloatCallbackTest002 put success');
704                expect(err == undefined).assertTrue();
705                await kvStore.delete(KEY_TEST_FLOAT_ELEMENT, function (err,data) {
706                    console.info('SingleKvStoreDeleteFloatCallbackTest002 delete success');
707                    expect(err == undefined).assertTrue();
708                    done();
709                });
710            })
711        }catch(e) {
712            console.error('SingleKvStoreDeleteFloatCallbackTest002 e' + `, error code is ${e.code}, message is ${e.message}`);
713            expect(null).assertFail();
714            done();
715        }
716    })
717
718    /**
719     * @tc.name SingleKvStoreDeleteBoolCallbackTest001
720     * @tc.desc Test Js Api SingleKvStore.DeleteBool() testcase 001
721     * @tc.type: FUNC
722     * @tc.require: issueNumber
723     */
724    it('SingleKvStoreDeleteBoolCallbackTest001', 0, async function (done) {
725        console.info('SingleKvStoreDeleteBoolCallbackTest001');
726        try{
727            await kvStore.delete(KEY_TEST_BOOLEAN_ELEMENT, function (err,data) {
728                if (err == undefined) {
729                    console.info('SingleKvStoreDeleteBoolCallbackTest001 get success');
730                } else {
731                    console.error('SingleKvStoreDeleteBoolCallbackTest001 get fail' + `, error code is ${err.code}, message is ${err.message}`);
732                    expect(null).assertFail();
733                }
734                done();
735            });
736        }catch(e) {
737            console.error('SingleKvStoreDeleteBoolCallbackTest001 e' + `, error code is ${e.code}, message is ${e.message}`);
738            expect(null).assertFail();
739            done();
740        }
741    })
742
743    /**
744     * @tc.name SingleKvStoreDeleteBoolCallbackTest002
745     * @tc.desc Test Js Api SingleKvStore.DeleteBool() testcase 002
746     * @tc.type: FUNC
747     * @tc.require: issueNumber
748     */
749    it('SingleKvStoreDeleteBoolCallbackTest002', 0, async function (done) {
750        console.info('SingleKvStoreDeleteBoolCallbackTest002');
751        try{
752            await kvStore.put(KEY_TEST_BOOLEAN_ELEMENT, VALUE_TEST_BOOLEAN_ELEMENT, async function (err, data) {
753                console.info('SingleKvStoreDeleteBoolCallbackTest002 put success');
754                expect(err == undefined).assertTrue();
755                await kvStore.delete(KEY_TEST_BOOLEAN_ELEMENT, function (err,data) {
756                    console.info('SingleKvStoreDeleteBoolCallbackTest002 delete success');
757                    expect(err == undefined).assertTrue();
758                    done();
759                });
760            })
761        }catch(e) {
762            console.error('SingleKvStoreDeleteBoolCallbackTest002 e' + `, error code is ${e.code}, message is ${e.message}`);
763            expect(null).assertFail();
764            done();
765        }
766    })
767
768    /**
769     * @tc.name SingleKvStoreOnChangeCallbackTest001
770     * @tc.desc Test Js Api SingleKvStore.OnChange() testcase 001
771     * @tc.type: FUNC
772     * @tc.require: issueNumber
773     */
774    it('SingleKvStoreOnChangeCallbackTest001', 0, async function (done) {
775        console.info('SingleKvStoreOnChangeCallbackTest001');
776        try {
777            kvStore.on('dataChange', 0, function (data) {
778                console.info('SingleKvStoreOnChangeCallbackTest001 dataChange');
779                expect(data != null).assertTrue();
780            });
781            await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, function (err,data) {
782                console.info('SingleKvStoreOnChangeCallbackTest001 put success');
783                expect(err == undefined).assertTrue();
784                done();
785            });
786        }catch(e) {
787            console.error('SingleKvStoreOnChangeCallbackTest001 e' + `, error code is ${e.code}, message is ${e.message}`);
788            expect(null).assertFail();
789            done();
790        }
791    })
792
793    /**
794     * @tc.name SingleKvStoreOnChangeCallbackTest002
795     * @tc.desc Test Js Api SingleKvStore.OnChange() testcase 002
796     * @tc.type: FUNC
797     * @tc.require: issueNumber
798     */
799    it('SingleKvStoreOnChangeCallbackTest002', 0, async function (done) {
800        console.info('SingleKvStoreOnChangeCallbackTest002');
801        try {
802            kvStore.on('dataChange', 1, function (data) {
803                console.info('SingleKvStoreOnChangeCallbackTest002 dataChange');
804                expect(data != null).assertTrue();
805            });
806            await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, function (err,data) {
807                console.info('SingleKvStoreOnChangeCallbackTest002 put success');
808                expect(err == undefined).assertTrue();
809                done();
810            });
811        }catch(e) {
812            console.error('SingleKvStoreOnChangeCallbackTest002 e' + `, error code is ${e.code}, message is ${e.message}`);
813            expect(null).assertFail();
814            done();
815        }
816    })
817
818    /**
819     * @tc.name SingleKvStoreOnChangeCallbackTest003
820     * @tc.desc Test Js Api SingleKvStore.OnChange() testcase 003
821     * @tc.type: FUNC
822     * @tc.require: issueNumber
823     */
824    it('SingleKvStoreOnChangeCallbackTest003', 0, async function (done) {
825        console.info('SingleKvStoreOnChangeCallbackTest003');
826        try {
827            kvStore.on('dataChange', 2, function (data) {
828                console.info('SingleKvStoreOnChangeCallbackTest003 dataChange');
829                expect(data != null).assertTrue();
830            });
831            await kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT, function (err,data) {
832                console.info('SingleKvStoreOnChangeCallbackTest003 put success');
833                expect(err == undefined).assertTrue();
834                done();
835            });
836        }catch(e) {
837            console.error('SingleKvStoreOnChangeCallbackTest003 e' + `, error code is ${e.code}, message is ${e.message}`);
838            expect(null).assertFail();
839            done();
840        }
841    })
842
843    /**
844     * @tc.name SingleKvStoreOnSyncCompleteCallbackTest001
845     * @tc.desc Test Js Api SingleKvStore.OnSyncComplete() testcase 001
846     * @tc.type: FUNC
847     * @tc.require: issueNumber
848     */
849    it('SingleKvStoreOnSyncCompleteCallbackTest001', 0, async function (done) {
850        try {
851            kvStore.on('syncComplete', function (data) {
852                console.info('SingleKvStoreOnSyncCompleteCallbackTest001 dataChange');
853                expect(data != null).assertTrue();
854            });
855            await kvStore.put(KEY_TEST_SYNC_ELEMENT + 'SyncTest001', VALUE_TEST_SYNC_ELEMENT, function (err,data) {
856                console.info('SingleKvStoreOnSyncCompleteCallbackTest001 put success');
857                expect(err == undefined).assertTrue();
858            });
859            try {
860                var mode = factory.SyncMode.PULL_ONLY;
861                console.info('kvStore.sync to ' + JSON.stringify(syncDeviceIds));
862                kvStore.sync(syncDeviceIds, mode, 10);
863            } catch (e) {
864                console.error('SingleKvStoreOnSyncCompleteCallbackTest001 sync no peer device :e:' + `, error code is ${e.code}, message is ${e.message}`);
865            }
866        }catch(e) {
867            console.error('SingleKvStoreOnSyncCompleteCallbackTest001 e' + `, error code is ${e.code}, message is ${e.message}`);
868            expect(null).assertFail();
869        }
870        done();
871    })
872
873    /**
874     * @tc.name SingleKvStoreOnSyncCompleteCallbackTest002
875     * @tc.desc Test Js Api SingleKvStore.OnSyncComplete() testcase 002
876     * @tc.type: FUNC
877     * @tc.require: issueNumber
878     */
879    it('SingleKvStoreOnSyncCompleteCallbackTest002', 0, async function (done) {
880        try {
881            kvStore.on('syncComplete', function (data) {
882                console.info('SingleKvStoreOnSyncCompleteCallbackTest002 dataChange');
883                expect(data != null).assertTrue();
884            });
885            await kvStore.put(KEY_TEST_SYNC_ELEMENT + 'SyncTest002', VALUE_TEST_SYNC_ELEMENT, function (err,data) {
886                console.info('SingleKvStoreOnSyncCompleteCallbackTest002 put success');
887                expect(err == undefined).assertTrue();
888            });
889            try {
890                var mode = factory.SyncMode.PUSH_ONLY;
891                console.info('kvStore.sync to ' + JSON.stringify(syncDeviceIds));
892                kvStore.sync(syncDeviceIds, mode, 10);
893            } catch (e) {
894                console.error('SingleKvStoreOnSyncCompleteCallbackTest002 sync no peer device :e:' + `, error code is ${e.code}, message is ${e.message}`);
895            }
896        }catch(e) {
897            console.error('SingleKvStoreOnSyncCompleteCallbackTest002 e' + `, error code is ${e.code}, message is ${e.message}`);
898            expect(null).assertFail();
899        }
900        done();
901    })
902
903    /**
904     * @tc.name SingleKvStoreOnSyncCompleteCallbackTest003
905     * @tc.desc Test Js Api SingleKvStore.OnSyncComplete() testcase 003
906     * @tc.type: FUNC
907     * @tc.require: issueNumber
908     */
909    it('SingleKvStoreOnSyncCompleteCallbackTest003', 0, async function (done) {
910        try {
911            kvStore.on('syncComplete', function (data) {
912                console.info('SingleKvStoreOnSyncCompleteCallbackTest003 dataChange');
913                expect(data != null).assertTrue();
914            });
915            await kvStore.put(KEY_TEST_SYNC_ELEMENT + 'SyncTest003', VALUE_TEST_SYNC_ELEMENT, function (err,data) {
916                console.info('SingleKvStoreOnSyncCompleteCallbackTest003 put success');
917                expect(err == undefined).assertTrue();
918            });
919            try {
920                var mode = factory.SyncMode.PUSH_PULL;
921                console.info('kvStore.sync to ' + JSON.stringify(syncDeviceIds));
922                kvStore.sync(syncDeviceIds, mode, 10);
923            } catch (e) {
924                console.error('SingleKvStoreOnSyncCompleteCallbackTest003 sync no peer device :e:' + `, error code is ${e.code}, message is ${e.message}`);
925            }
926        }catch(e) {
927            console.error('SingleKvStoreOnSyncCompleteCallbackTest003 e' + `, error code is ${e.code}, message is ${e.message}`);
928            expect(null).assertFail();
929        }
930        done();
931    })
932
933    /**
934     * @tc.name SingleKvStoreSetSyncRangeCallbackTest001
935     * @tc.desc Test Js Api SingleKvStore.SetSyncRange() testcase 001
936     * @tc.type: FUNC
937     * @tc.require: issueNumber
938     */
939    it('SingleKvStoreSetSyncRangeCallbackTest001', 0, async function (done) {
940        console.info('SingleKvStoreSetSyncRangeCallbackTest001');
941        try {
942            var localLabels = ['A', 'B'];
943            var remoteSupportLabels = ['C', 'D'];
944            await kvStore.setSyncRange(localLabels, remoteSupportLabels, function (err,data) {
945                console.info('SingleKvStoreSetSyncRangeCallbackTest001 put success');
946                expect(err == undefined).assertTrue();
947                done();
948            });
949        }catch(e) {
950            console.error('SingleKvStoreSetSyncRangeCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
951            expect(null).assertFail();
952            done();
953        }
954    })
955
956    /**
957     * @tc.name SingleKvStoreSetSyncRangeCallbackTest002
958     * @tc.desc Test Js Api SingleKvStore.SetSyncRange() testcase 002
959     * @tc.type: FUNC
960     * @tc.require: issueNumber
961     */
962    it('SingleKvStoreSetSyncRangeCallbackTest002', 0, async function (done) {
963        console.info('SingleKvStoreSetSyncRangeCallbackTest002');
964        try {
965            var localLabels = ['A', 'B'];
966            var remoteSupportLabels = ['B', 'C'];
967            await kvStore.setSyncRange(localLabels, remoteSupportLabels, function (err,data) {
968                console.info('SingleKvStoreSetSyncRangeCallbackTest002 put success');
969                expect(err == undefined).assertTrue();
970                done();
971            });
972        }catch(e) {
973            console.error('SingleKvStoreSetSyncRangeCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
974            expect(null).assertFail();
975            done();
976        }
977    })
978
979    /**
980     * @tc.name SingleKvStoreSetSyncRangeCallbackTest003
981     * @tc.desc Test Js Api SingleKvStore.SetSyncRange() testcase 003
982     * @tc.type: FUNC
983     * @tc.require: issueNumber
984     */
985    it('SingleKvStoreSetSyncRangeCallbackTest003', 0, async function (done) {
986        console.info('SingleKvStoreSetSyncRangeCallbackTest003');
987        try {
988            var localLabels = ['A', 'B'];
989            var remoteSupportLabels = ['A', 'B'];
990            await kvStore.setSyncRange(localLabels, remoteSupportLabels, function (err,data) {
991                console.info('SingleKvStoreSetSyncRangeCallbackTest003 put success');
992                expect(err == undefined).assertTrue();
993                done();
994            });
995        }catch(e) {
996            console.error('SingleKvStoreSetSyncRangeCallbackTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
997            expect(null).assertFail();
998            done();
999        }
1000    })
1001
1002    /**
1003     * @tc.name SingleKvStorePutBatchCallbackTest001
1004     * @tc.desc Test Js Api SingleKvStore.PutBatch() testcase 001
1005     * @tc.type: FUNC
1006     * @tc.require: issueNumber
1007     */
1008    it('SingleKvStorePutBatchCallbackTest001', 0, async function (done) {
1009        console.info('SingleKvStorePutBatchCallbackTest001');
1010        try {
1011            let entries = [];
1012            for (var i = 0; i < 10; i++) {
1013                var key = 'batch_test_string_key';
1014                var entry = {
1015                    key : key + i,
1016                    value : {
1017                        type : factory.ValueType.STRING,
1018                        value : 'batch_test_string_value'
1019                    }
1020                }
1021                entries.push(entry);
1022            }
1023            console.info('SingleKvStorePutBatchCallbackTest001 entries: ' + JSON.stringify(entries));
1024            await kvStore.putBatch(entries, async function (err,data) {
1025                console.info('SingleKvStorePutBatchCallbackTest001 putBatch success');
1026                expect(err == undefined).assertTrue();
1027                await kvStore.getEntries('batch_test_string_key', function (err,entrys) {
1028                    console.info('SingleKvStorePutBatchCallbackTest001 getEntries success');
1029                    console.info('SingleKvStorePutBatchCallbackTest001 entrys.length: ' + entrys.length);
1030                    console.info('SingleKvStorePutBatchCallbackTest001 entrys[0]: ' + JSON.stringify(entrys[0]));
1031                    expect(entrys.length == 10).assertTrue();
1032                    expect(entrys[0].value.value == 'batch_test_string_value').assertTrue();
1033                    done();
1034                });
1035            });
1036        }catch(e) {
1037            console.error('SingleKvStorePutBatchCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
1038            expect(null).assertFail();
1039            done();
1040        }
1041    })
1042
1043    /**
1044     * @tc.name SingleKvStorePutBatchCallbackTest002
1045     * @tc.desc Test Js Api SingleKvStore.PutBatch() testcase 002
1046     * @tc.type: FUNC
1047     * @tc.require: issueNumber
1048     */
1049    it('SingleKvStorePutBatchCallbackTest002', 0, async function (done) {
1050        console.info('SingleKvStorePutBatchCallbackTest002');
1051        try {
1052            let entries = [];
1053            for (var i = 0; i < 10; i++) {
1054                var key = 'batch_test_number_key';
1055                var entry = {
1056                    key : key + i,
1057                    value : {
1058                        type : factory.ValueType.INTEGER,
1059                        value : 222
1060                    }
1061                }
1062                entries.push(entry);
1063            }
1064            console.info('SingleKvStorePutBatchCallbackTest002 entries: ' + JSON.stringify(entries));
1065            await kvStore.putBatch(entries, async function (err,data) {
1066                console.info('SingleKvStorePutBatchCallbackTest002 putBatch success');
1067                expect(err == undefined).assertTrue();
1068                await kvStore.getEntries('batch_test_number_key', function (err,entrys) {
1069                    console.info('SingleKvStorePutBatchCallbackTest002 getEntries success');
1070                    console.info('SingleKvStorePutBatchCallbackTest002 entrys.length: ' + entrys.length);
1071                    console.info('SingleKvStorePutBatchCallbackTest002 entrys[0]: ' + JSON.stringify(entrys[0]));
1072                    expect(entrys.length == 10).assertTrue();
1073                    expect(entrys[0].value.value == 222).assertTrue();
1074                    done();
1075                });
1076            });
1077        }catch(e) {
1078            console.error('SingleKvStorePutBatchCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
1079            expect(null).assertFail();
1080            done();
1081        }
1082    })
1083
1084    /**
1085     * @tc.name SingleKvStorePutBatchCallbackTest003
1086     * @tc.desc Test Js Api SingleKvStore.PutBatch() testcase 003
1087     * @tc.type: FUNC
1088     * @tc.require: issueNumber
1089     */
1090    it('SingleKvStorePutBatchCallbackTest003', 0, async function (done) {
1091        console.info('SingleKvStorePutBatchCallbackTest003');
1092        try {
1093            let entries = [];
1094            for (var i = 0; i < 10; i++) {
1095                var key = 'batch_test_number_key';
1096                var entry = {
1097                    key : key + i,
1098                    value : {
1099                        type : factory.ValueType.FLOAT,
1100                        value : 2.0
1101                    }
1102                }
1103                entries.push(entry);
1104            }
1105            console.info('SingleKvStorePutBatchCallbackTest003 entries: ' + JSON.stringify(entries));
1106            await kvStore.putBatch(entries, async function (err,data) {
1107                console.info('SingleKvStorePutBatchCallbackTest003 putBatch success');
1108                expect(err == undefined).assertTrue();
1109                await kvStore.getEntries('batch_test_number_key', function (err,entrys) {
1110                    console.info('SingleKvStorePutBatchCallbackTest003 getEntries success');
1111                    console.info('SingleKvStorePutBatchCallbackTest003 entrys.length: ' + entrys.length);
1112                    console.info('SingleKvStorePutBatchCallbackTest003 entrys[0]: ' + JSON.stringify(entrys[0]));
1113                    expect(entrys.length == 10).assertTrue();
1114                    expect(entrys[0].value.value == 2.0).assertTrue();
1115                    done();
1116                });
1117            });
1118        }catch(e) {
1119            console.error('SingleKvStorePutBatchCallbackTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
1120            expect(null).assertFail();
1121            done();
1122        }
1123    })
1124
1125    /**
1126     * @tc.name SingleKvStorePutBatchCallbackTest004
1127     * @tc.desc Test Js Api SingleKvStore.PutBatch() testcase 004
1128     * @tc.type: FUNC
1129     * @tc.require: issueNumber
1130     */
1131    it('SingleKvStorePutBatchCallbackTest004', 0, async function (done) {
1132        console.info('SingleKvStorePutBatchCallbackTest004');
1133        try {
1134            let entries = [];
1135            for (var i = 0; i < 10; i++) {
1136                var key = 'batch_test_number_key';
1137                var entry = {
1138                    key : key + i,
1139                    value : {
1140                        type : factory.ValueType.DOUBLE,
1141                        value : 2.00
1142                    }
1143                }
1144                entries.push(entry);
1145            }
1146            console.info('SingleKvStorePutBatchCallbackTest004 entries: ' + JSON.stringify(entries));
1147            await kvStore.putBatch(entries, async function (err,data) {
1148                console.info('SingleKvStorePutBatchCallbackTest004 putBatch success');
1149                expect(err == undefined).assertTrue();
1150                await kvStore.getEntries('batch_test_number_key', function (err,entrys) {
1151                    console.info('SingleKvStorePutBatchCallbackTest004 getEntries success');
1152                    console.info('SingleKvStorePutBatchCallbackTest004 entrys.length: ' + entrys.length);
1153                    console.info('SingleKvStorePutBatchCallbackTest004 entrys[0]: ' + JSON.stringify(entrys[0]));
1154                    expect(entrys.length == 10).assertTrue();
1155                    expect(entrys[0].value.value == 2.00).assertTrue();
1156                    done();
1157                });
1158            });
1159        }catch(e) {
1160            console.error('SingleKvStorePutBatchCallbackTest004 e ' + `, error code is ${e.code}, message is ${e.message}`);
1161            expect(null).assertFail();
1162            done();
1163        }
1164    })
1165
1166    /**
1167     * @tc.name SingleKvStorePutBatchCallbackTest005
1168     * @tc.desc Test Js Api SingleKvStore.PutBatch() testcase 005
1169     * @tc.type: FUNC
1170     * @tc.require: issueNumber
1171     */
1172    it('SingleKvStorePutBatchCallbackTest005', 0, async function (done) {
1173        console.info('SingleKvStorePutBatchCallbackTest005');
1174        try {
1175            var bo = false;
1176            let entries = [];
1177            for (var i = 0; i < 10; i++) {
1178                var key = 'batch_test_bool_key';
1179                var entry = {
1180                    key : key + i,
1181                    value : {
1182                        type : factory.ValueType.BOOLEAN,
1183                        value : bo
1184                    }
1185                }
1186                entries.push(entry);
1187            }
1188            console.info('SingleKvStorePutBatchCallbackTest005 entries: ' + JSON.stringify(entries));
1189            await kvStore.putBatch(entries, async function (err,data) {
1190                console.info('SingleKvStorePutBatchCallbackTest005 putBatch success');
1191                expect(err == undefined).assertTrue();
1192                await kvStore.getEntries('batch_test_bool_key', function (err,entrys) {
1193                    console.info('SingleKvStorePutBatchCallbackTest005 getEntries success');
1194                    console.info('SingleKvStorePutBatchCallbackTest005 entrys.length: ' + entrys.length);
1195                    console.info('SingleKvStorePutBatchCallbackTest005 entrys[0]: ' + JSON.stringify(entrys[0]));
1196                    expect(entrys.length == 10).assertTrue();
1197                    expect(entrys[0].value.value == bo).assertTrue();
1198                    done();
1199                });
1200            });
1201        }catch(e) {
1202            console.error('SingleKvStorePutBatchCallbackTest005 e ' + `, error code is ${e.code}, message is ${e.message}`);
1203            expect(null).assertFail();
1204            done();
1205        }
1206    })
1207
1208    /**
1209     * @tc.name SingleKvStorePutBatchCallbackTest006
1210     * @tc.desc Test Js Api SingleKvStore.PutBatch() testcase 006
1211     * @tc.type: FUNC
1212     * @tc.require: issueNumber
1213     */
1214    it('SingleKvStorePutBatchCallbackTest006', 0, async function (done) {
1215        console.info('SingleKvStorePutBatchCallbackTest006');
1216        try {
1217            var arr = new Uint8Array([21,31]);
1218            let entries = [];
1219            for (var i = 0; i < 10; i++) {
1220                var key = 'batch_test_bool_key';
1221                var entry = {
1222                    key : key + i,
1223                    value : {
1224                        type : factory.ValueType.BYTE_ARRAY,
1225                        value : arr
1226                    }
1227                }
1228                entries.push(entry);
1229            }
1230            console.info('SingleKvStorePutBatchCallbackTest006 entries: ' + JSON.stringify(entries));
1231            await kvStore.putBatch(entries, async function (err,data) {
1232                console.info('SingleKvStorePutBatchCallbackTest006 putBatch success');
1233                expect(err == undefined).assertTrue();
1234                await kvStore.getEntries('batch_test_bool_key', function (err,entrys) {
1235                    console.info('SingleKvStorePutBatchCallbackTest006 getEntries success');
1236                    console.info('SingleKvStorePutBatchCallbackTest006 entrys.length: ' + entrys.length);
1237                    console.info('SingleKvStorePutBatchCallbackTest006 entrys[0]: ' + JSON.stringify(entrys[0]));
1238                    expect(entrys.length == 10).assertTrue();
1239                    expect(entrys[0].value.value.toString() == arr.toString()).assertTrue();
1240                    done();
1241                });
1242            });
1243        }catch(e) {
1244            console.error('SingleKvStorePutBatchCallbackTest006 e ' + `, error code is ${e.code}, message is ${e.message}`);
1245            expect(null).assertFail();
1246            done();
1247        }
1248    })
1249
1250    /**
1251     * @tc.name SingleKvStoreDeleteBatchCallbackTest001
1252     * @tc.desc Test Js Api SingleKvStore.DeleteBatch() testcase 001
1253     * @tc.type: FUNC
1254     * @tc.require: issueNumber
1255     */
1256    it('SingleKvStoreDeleteBatchCallbackTest001', 0, async function (done) {
1257        console.info('SingleKvStoreDeleteBatchCallbackTest001');
1258        try {
1259            let entries = [];
1260            let keys = [];
1261            for (var i = 0; i < 5; i++) {
1262                var key = 'batch_test_string_key';
1263                var entry = {
1264                    key : key + i,
1265                    value : {
1266                        type : factory.ValueType.STRING,
1267                        value : 'batch_test_string_value'
1268                    }
1269                }
1270                entries.push(entry);
1271                keys.push(key + i);
1272            }
1273            console.info('SingleKvStoreDeleteBatchCallbackTest001 entries: ' + JSON.stringify(entries));
1274            await kvStore.putBatch(entries, async function (err,data) {
1275                console.info('SingleKvStoreDeleteBatchCallbackTest001 putBatch success');
1276                expect(err == undefined).assertTrue();
1277                await kvStore.deleteBatch(keys, async function (err,data) {
1278                    console.info('SingleKvStoreDeleteBatchCallbackTest001 deleteBatch success');
1279                    expect(err == undefined).assertTrue();
1280                    done();
1281                });
1282            });
1283        }catch(e) {
1284            console.error('SingleKvStoreDeleteBatchCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
1285            expect(null).assertFail();
1286            done();
1287        }
1288    })
1289
1290    /**
1291     * @tc.name SingleKvStoreDeleteBatchCallbackTest002
1292     * @tc.desc Test Js Api SingleKvStore.DeleteBatch() testcase 002
1293     * @tc.type: FUNC
1294     * @tc.require: issueNumber
1295     */
1296    it('SingleKvStoreDeleteBatchCallbackTest002', 0, async function (done) {
1297        console.info('SingleKvStoreDeleteBatchCallbackTest002');
1298        try {
1299            let keys = ['batch_test_string_key1', 'batch_test_string_key2'];
1300            await kvStore.deleteBatch(keys, function (err,data) {
1301                console.info('SingleKvStoreDeleteBatchCallbackTest002 deleteBatch success');
1302                expect(err == undefined).assertTrue();
1303                done();
1304            });
1305        }catch(e) {
1306            console.error('SingleKvStoreDeleteBatchCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
1307            expect(null).assertFail();
1308            done();
1309        }
1310    })
1311
1312    /**
1313     * @tc.name SingleKvStoreDeleteBatchCallbackTest003
1314     * @tc.desc Test Js Api SingleKvStore.DeleteBatch() testcase 003
1315     * @tc.type: FUNC
1316     * @tc.require: issueNumber
1317     */
1318    it('SingleKvStoreDeleteBatchCallbackTest003', 0, async function (done) {
1319        console.info('SingleKvStoreDeleteBatchCallbackTest003');
1320        try {
1321            let entries = [];
1322            for (var i = 0; i < 10; i++) {
1323                var key = 'batch_test_string_key';
1324                var entry = {
1325                    key : key + i,
1326                    value : {
1327                        type : factory.ValueType.STRING,
1328                        value : 'batch_test_string_value'
1329                    }
1330                }
1331                entries.push(entry);
1332            }
1333            console.info('SingleKvStoreDeleteBatchCallbackTest003 entries: ' + JSON.stringify(entries));
1334            await kvStore.putBatch(entries, async function (err,data) {
1335                console.info('SingleKvStoreDeleteBatchCallbackTest003 putBatch success');
1336                expect(err == undefined).assertTrue();
1337                let keys = ['batch_test_string_key1', 'batch_test_string_keya'];
1338                await kvStore.deleteBatch(keys, async function (err,data) {
1339                    console.info('SingleKvStoreDeleteBatchCallbackTest003 deleteBatch success');
1340                    expect(err == undefined).assertTrue();
1341                    done();
1342                });
1343            });
1344        }catch(e) {
1345            console.error('SingleKvStoreDeleteBatchCallbackTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
1346            expect(null).assertFail();
1347            done();
1348        }
1349    })
1350
1351    /**
1352     * @tc.name SingleKvStorestartTransactionCallbackTest001
1353     * @tc.desc Test Js Api SingleKvStore.startTransaction() testcase 001
1354     * @tc.type: FUNC
1355     * @tc.require: issueNumber
1356     */
1357    it('SingleKvStorestartTransactionCallbackTest001', 0, async function (done) {
1358        console.info('SingleKvStorestartTransactionCallbackTest001');
1359        try {
1360            var count = 0;
1361            kvStore.on('dataChange', 0, function (data) {
1362                console.info('SingleKvStorestartTransactionCallbackTest001 0' + data)
1363                count++;
1364            });
1365            await kvStore.startTransaction(async function (err,data) {
1366                console.info('SingleKvStorestartTransactionCallbackTest001 startTransaction success');
1367                expect(err == undefined).assertTrue();
1368                let entries = putBatchString(10, 'batch_test_string_key');
1369                console.info('SingleKvStorestartTransactionCallbackTest001 entries: ' + JSON.stringify(entries));
1370                await kvStore.putBatch(entries, async function (err,data) {
1371                    console.info('SingleKvStorestartTransactionCallbackTest001 putBatch success');
1372                    expect(err == undefined).assertTrue();
1373                    let keys = Object.keys(entries).slice(5); //delete 5 beginnings
1374                    await kvStore.deleteBatch(keys, async function (err,data) {
1375                        console.info('SingleKvStorestartTransactionCallbackTest001 deleteBatch success');
1376                        expect(err == undefined).assertTrue();
1377                        await kvStore.commit(async function (err,data) {
1378                            console.info('SingleKvStorestartTransactionCallbackTest001 commit success');
1379                            expect(err == undefined).assertTrue();
1380                            await sleep(2000);
1381                            expect(count == 1).assertTrue();
1382                            done();
1383                        });
1384                    });
1385                });
1386            });
1387        }catch(e) {
1388            console.error('SingleKvStorestartTransactionCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
1389            expect(null).assertFail();
1390            done();
1391        }
1392    })
1393
1394    /**
1395     * @tc.name SingleKvStorestartTransactionCallbackTest002
1396     * @tc.desc Test Js Api SingleKvStore.startTransaction() testcase 002
1397     * @tc.type: FUNC
1398     * @tc.require: issueNumber
1399     */
1400    it('SingleKvStorestartTransactionCallbackTest002', 0, async function (done) {
1401        console.info('SingleKvStorestartTransactionCallbackTest002');
1402        try {
1403            var count = 0;
1404            kvStore.on('dataChange', 0, function (data) {
1405                console.info('SingleKvStorestartTransactionCallbackTest002 0' + data)
1406                count++;
1407            });
1408            await kvStore.startTransaction(async function (err,data) {
1409                console.info('SingleKvStorestartTransactionCallbackTest002 startTransaction success');
1410                expect(err == undefined).assertTrue();
1411                let entries = putBatchString(10, 'batch_test_string_key');
1412                console.info('SingleKvStorestartTransactionCallbackTest002 entries: ' + JSON.stringify(entries));
1413                await kvStore.putBatch(entries, async function (err,data) {
1414                    console.info('SingleKvStorestartTransactionCallbackTest002 putBatch success');
1415                    expect(err == undefined).assertTrue();
1416                    let keys = Object.keys(entries).slice(5); //delete 5 beginnings
1417                    await kvStore.deleteBatch(keys, async function (err,data) {
1418                        console.info('SingleKvStorestartTransactionCallbackTest002 deleteBatch success');
1419                        expect(err == undefined).assertTrue();
1420                        await kvStore.rollback(async function (err,data) {
1421                            console.info('SingleKvStorestartTransactionCallbackTest002 rollback success');
1422                            expect(err == undefined).assertTrue();
1423                            await sleep(2000);
1424                            expect(count == 0).assertTrue();
1425                            done();
1426                        });
1427                    });
1428                });
1429            });
1430        }catch(e) {
1431            console.error('SingleKvStorestartTransactionCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
1432            expect(null).assertFail();
1433            done();
1434        }
1435    })
1436
1437    /**
1438     * @tc.name SingleKvStorestartTransactionCallbackTest003
1439     * @tc.desc Test Js Api SingleKvStore.startTransaction() testcase 003
1440     * @tc.type: FUNC
1441     * @tc.require: issueNumber
1442     */
1443    it('SingleKvStorestartTransactionCallbackTest003', 0, async function (done) {
1444        console.info('SingleKvStorestartTransactionCallbackTest003');
1445        try {
1446            await kvStore.startTransaction(1, function (err,data) {
1447                if (err == undefined) {
1448                    console.info('SingleKvStorestartTransactionCallbackTest003 startTransaction success');
1449                    expect(null).assertFail();
1450                } else {
1451                    console.info('SingleKvStorestartTransactionCallbackTest003 startTransaction fail');
1452                }
1453                done();
1454            });
1455        }catch(e) {
1456            console.error('SingleKvStorestartTransactionCallbackTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
1457            done();
1458        }
1459    })
1460
1461    /**
1462     * @tc.name SingleKvStorestartTransactionCallbackTest004
1463     * @tc.desc Test Js Api SingleKvStore.startTransaction() testcase 004
1464     * @tc.type: FUNC
1465     * @tc.require: issueNumber
1466     */
1467    it('SingleKvStorestartTransactionCallbackTest004', 0, async function (done) {
1468        console.info('SingleKvStorestartTransactionCallbackTest004');
1469        try {
1470            await kvStore.startTransaction('test_string', function (err,data) {
1471                if (err == undefined) {
1472                    console.info('SingleKvStorestartTransactionCallbackTest004 startTransaction success');
1473                    expect(null).assertFail();
1474                } else {
1475                    console.info('SingleKvStorestartTransactionCallbackTest004 startTransaction fail');
1476                }
1477                done();
1478            });
1479        }catch(e) {
1480            console.error('SingleKvStorestartTransactionCallbackTest004 e ' + `, error code is ${e.code}, message is ${e.message}`);
1481            done();
1482        }
1483    })
1484
1485    /**
1486     * @tc.name SingleKvStorestartTransactionCallbackTest005
1487     * @tc.desc Test Js Api SingleKvStore.startTransaction() testcase 005
1488     * @tc.type: FUNC
1489     * @tc.require: issueNumber
1490     */
1491    it('SingleKvStorestartTransactionCallbackTest005', 0, async function (done) {
1492        console.info('SingleKvStorestartTransactionCallbackTest005');
1493        try {
1494            await kvStore.startTransaction(2.000, function (err,data) {
1495                if (err == undefined) {
1496                    console.info('SingleKvStorestartTransactionCallbackTest005 startTransaction success');
1497                    expect(null).assertFail();
1498                } else {
1499                    console.info('SingleKvStorestartTransactionCallbackTest005 startTransaction fail');
1500                }
1501                done();
1502            });
1503        }catch(e) {
1504            console.error('SingleKvStorestartTransactionCallbackTest005 e ' + `, error code is ${e.code}, message is ${e.message}`);
1505            done();
1506        }
1507    })
1508
1509    /**
1510     * @tc.name SingleKvStoreCommitCallbackTest001
1511     * @tc.desc Test Js Api SingleKvStore.Commit() testcase 001
1512     * @tc.type: FUNC
1513     * @tc.require: issueNumber
1514     */
1515    it('SingleKvStoreCommitCallbackTest001', 0, async function (done) {
1516        console.info('SingleKvStoreCommitCallbackTest001');
1517        try {
1518            await kvStore.commit(1, function (err,data) {
1519                if (err == undefined) {
1520                    console.info('SingleKvStoreCommitCallbackTest001 commit success');
1521                    expect(null).assertFail();
1522                } else {
1523                    console.info('SingleKvStoreCommitCallbackTest001 commit fail');
1524                }
1525                done();
1526            });
1527        }catch(e) {
1528            console.error('SingleKvStoreCommitCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
1529            done();
1530        }
1531    })
1532
1533    /**
1534     * @tc.name SingleKvStoreCommitCallbackTest002
1535     * @tc.desc Test Js Api SingleKvStore.Commit() testcase 002
1536     * @tc.type: FUNC
1537     * @tc.require: issueNumber
1538     */
1539    it('SingleKvStoreCommitCallbackTest002', 0, async function (done) {
1540        console.info('SingleKvStoreCommitCallbackTest002');
1541        try {
1542            await kvStore.commit('test_string', function (err,data) {
1543                if (err == undefined) {
1544                    console.info('SingleKvStoreCommitCallbackTest002 commit success');
1545                    expect(null).assertFail();
1546                } else {
1547                    console.info('SingleKvStoreCommitCallbackTest002 commit fail');
1548                }
1549                done();
1550            });
1551        }catch(e) {
1552            console.error('SingleKvStoreCommitCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
1553            done();
1554        }
1555    })
1556
1557    /**
1558     * @tc.name SingleKvStoreCommitCallbackTest003
1559     * @tc.desc Test Js Api SingleKvStore.Commit() testcase 003
1560     * @tc.type: FUNC
1561     * @tc.require: issueNumber
1562     */
1563    it('SingleKvStoreCommitCallbackTest003', 0, async function (done) {
1564        console.info('SingleKvStoreCommitCallbackTest003');
1565        try {
1566            await kvStore.commit(2.000, function (err,data) {
1567                if (err == undefined) {
1568                    console.info('SingleKvStoreCommitCallbackTest003 commit success');
1569                    expect(null).assertFail();
1570                } else {
1571                    console.info('SingleKvStoreCommitCallbackTest003 commit fail');
1572                }
1573                done();
1574            });
1575        }catch(e) {
1576            console.error('SingleKvStoreCommitCallbackTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
1577            done();
1578        }
1579    })
1580
1581    /**
1582     * @tc.name SingleKvStoreRollbackCallbackTest001
1583     * @tc.desc Test Js Api SingleKvStore.Rollback() testcase 001
1584     * @tc.type: FUNC
1585     * @tc.require: issueNumber
1586     */
1587    it('SingleKvStoreRollbackCallbackTest001', 0, async function (done) {
1588        console.info('SingleKvStoreRollbackCallbackTest001');
1589        try {
1590            await kvStore.rollback(1, function (err,data) {
1591                if (err == undefined) {
1592                    console.info('SingleKvStoreRollbackCallbackTest001 commit success');
1593                    expect(null).assertFail();
1594                } else {
1595                    console.info('SingleKvStoreRollbackCallbackTest001 commit fail');
1596                }
1597                done();
1598            });
1599        }catch(e) {
1600            console.error('SingleKvStoreRollbackCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
1601            done();
1602        }
1603    })
1604
1605    /**
1606     * @tc.name SingleKvStoreRollbackCallbackTest002
1607     * @tc.desc Test Js Api SingleKvStore.Rollback() testcase 002
1608     * @tc.type: FUNC
1609     * @tc.require: issueNumber
1610     */
1611    it('SingleKvStoreRollbackCallbackTest002', 0, async function (done) {
1612        console.info('SingleKvStoreRollbackCallbackTest002');
1613        try {
1614            await kvStore.rollback('test_string', function (err,data) {
1615                if (err == undefined) {
1616                    console.info('SingleKvStoreRollbackCallbackTest002 commit success');
1617                    expect(null).assertFail();
1618                } else {
1619                    console.info('SingleKvStoreRollbackCallbackTest002 commit fail');
1620                }
1621                done();
1622            });
1623        }catch(e) {
1624            console.error('SingleKvStoreRollbackCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
1625            done();
1626        }
1627    })
1628
1629    /**
1630     * @tc.name SingleKvStoreRollbackCallbackTest003
1631     * @tc.desc Test Js Api SingleKvStore.Rollback() testcase 003
1632     * @tc.type: FUNC
1633     * @tc.require: issueNumber
1634     */
1635    it('SingleKvStoreRollbackCallbackTest003', 0, async function (done) {
1636        console.info('SingleKvStoreRollbackCallbackTest003');
1637        try {
1638            await kvStore.rollback(2.000, function (err,data) {
1639                if (err == undefined) {
1640                    console.info('SingleKvStoreRollbackCallbackTest003 commit success');
1641                    expect(null).assertFail();
1642                } else {
1643                    console.info('SingleKvStoreRollbackCallbackTest003 commit fail');
1644                }
1645                done();
1646            });
1647        }catch(e) {
1648            console.error('SingleKvStoreRollbackCallbackTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
1649            done();
1650        }
1651    })
1652
1653    /**
1654     * @tc.name SingleKvStoreEnableSyncCallbackTest001
1655     * @tc.desc Test Js Api SingleKvStore.EnableSync() testcase 001
1656     * @tc.type: FUNC
1657     * @tc.require: issueNumber
1658     */
1659    it('SingleKvStoreEnableSyncCallbackTest001', 0, async function (done) {
1660        console.info('SingleKvStoreEnableSyncCallbackTest001');
1661        try {
1662            await kvStore.enableSync(true, function (err,data) {
1663                if (err == undefined) {
1664                    console.info('SingleKvStoreEnableSyncCallbackTest001 enableSync success');
1665                    expect(err == undefined).assertTrue();
1666                } else {
1667                    console.info('SingleKvStoreEnableSyncCallbackTest001 enableSync fail');
1668                    expect(null).assertFail();
1669                }
1670                done();
1671            });
1672        }catch(e) {
1673            console.error('SingleKvStoreEnableSyncCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
1674            expect(null).assertFail();
1675            done();
1676        }
1677    })
1678
1679    /**
1680     * @tc.name SingleKvStoreEnableSyncCallbackTest002
1681     * @tc.desc Test Js Api SingleKvStore.EnableSync() testcase 002
1682     * @tc.type: FUNC
1683     * @tc.require: issueNumber
1684     */
1685    it('SingleKvStoreEnableSyncCallbackTest002', 0, async function (done) {
1686        console.info('SingleKvStoreEnableSyncCallbackTest002');
1687        try {
1688            await kvStore.enableSync(false, function (err,data) {
1689                if (err == undefined) {
1690                    console.info('SingleKvStoreEnableSyncCallbackTest002 enableSync success');
1691                    expect(err == undefined).assertTrue();
1692                } else {
1693                    console.info('SingleKvStoreEnableSyncCallbackTest002 enableSync fail');
1694                    expect(null).assertFail();
1695                }
1696                done();
1697            });
1698        }catch(e) {
1699            console.error('SingleKvStoreEnableSyncCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
1700            expect(null).assertFail();
1701            done();
1702        }
1703    })
1704
1705    /**
1706     * @tc.name SingleKvStoreEnableSyncCallbackTest003
1707     * @tc.desc Test Js Api SingleKvStore.EnableSync() testcase 003
1708     * @tc.type: FUNC
1709     * @tc.require: issueNumber
1710     */
1711    it('SingleKvStoreEnableSyncCallbackTest003', 0, async function (done) {
1712        console.info('SingleKvStoreEnableSyncCallbackTest003');
1713        try {
1714            await kvStore.enableSync(function (err,data) {
1715                if (err == undefined) {
1716                    console.info('SingleKvStoreEnableSyncCallbackTest003 enableSync success');
1717                    expect(null).assertFail();
1718                } else {
1719                    console.info('SingleKvStoreEnableSyncCallbackTest003 enableSync fail');
1720                }
1721                done();
1722            });
1723        }catch(e) {
1724            console.error('SingleKvStoreEnableSyncCallbackTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
1725            done();
1726        }
1727    })
1728
1729    /**
1730     * @tc.name SingleKvStoreEnableSyncCallbackTest004
1731     * @tc.desc Test Js Api SingleKvStore.EnableSync() testcase 004
1732     * @tc.type: FUNC
1733     * @tc.require: issueNumber
1734     */
1735    it('SingleKvStoreEnableSyncCallbackTest004', 0, async function (done) {
1736        console.info('SingleKvStoreEnableSyncCallbackTest004');
1737        try {
1738            await kvStore.enableSync(null, function (err,data) {
1739                if (err == undefined) {
1740                    console.info('SingleKvStoreEnableSyncCallbackTest004 enableSync success');
1741                    expect(null).assertFail();
1742                } else {
1743                    console.info('SingleKvStoreEnableSyncCallbackTest004 enableSync fail');
1744                }
1745                done();
1746            });
1747        }catch(e) {
1748            console.error('SingleKvStoreEnableSyncCallbackTest004 e ' + `, error code is ${e.code}, message is ${e.message}`);
1749            done();
1750        }
1751    })
1752
1753    /**
1754     * @tc.name SingleKvStoreRemoveDeviceDataCallbackTest001
1755     * @tc.desc Test Js Api SingleKvStore.RemoveDeviceData() testcase 001
1756     * @tc.type: FUNC
1757     * @tc.require: issueNumber
1758     */
1759    it('SingleKvStoreRemoveDeviceDataCallbackTest001', 0, async function (done) {
1760        console.info('SingleKvStoreRemoveDeviceDataCallbackTest001');
1761        try {
1762            await kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, async function (err,data) {
1763                console.info('SingleKvStoreRemoveDeviceDataCallbackTest001 put success');
1764                expect(err == undefined).assertTrue();
1765                var deviceid = 'no_exist_device_id';
1766                await kvStore.removeDeviceData(deviceid, async function (err,data) {
1767                    if (err == undefined) {
1768                        console.info('SingleKvStoreRemoveDeviceDataCallbackTest001 removeDeviceData success');
1769                        expect(null).assertFail();
1770                        done();
1771                    } else {
1772                        console.info('SingleKvStoreRemoveDeviceDataCallbackTest001 removeDeviceData fail');
1773                        await kvStore.get(KEY_TEST_STRING_ELEMENT, async function (err,data) {
1774                            console.info('SingleKvStoreRemoveDeviceDataCallbackTest001 get success');
1775                            expect(data == VALUE_TEST_STRING_ELEMENT).assertTrue();
1776                            done();
1777                        });
1778                    }
1779                });
1780            });
1781        }catch(e) {
1782            console.error('SingleKvStoreRemoveDeviceDataCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
1783            expect(null).assertFail();
1784            done();
1785        }
1786    })
1787
1788    /**
1789     * @tc.name SingleKvStoreRemoveDeviceDataCallbackTest002
1790     * @tc.desc Test Js Api SingleKvStore.RemoveDeviceData() testcase 002
1791     * @tc.type: FUNC
1792     * @tc.require: issueNumber
1793     */
1794    it('SingleKvStoreRemoveDeviceDataCallbackTest002', 0, async function (done) {
1795        console.info('SingleKvStoreRemoveDeviceDataCallbackTest002');
1796        try {
1797            await kvStore.removeDeviceData(function (err,data) {
1798                if (err == undefined) {
1799                    console.info('SingleKvStoreRemoveDeviceDataCallbackTest002 removeDeviceData success');
1800                    expect(null).assertFail();
1801                } else {
1802                    console.info('SingleKvStoreRemoveDeviceDataCallbackTest002 removeDeviceData fail');
1803                }
1804                done();
1805            });
1806        }catch(e) {
1807            console.error('SingleKvStoreRemoveDeviceDataCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
1808            done();
1809        }
1810    })
1811
1812    /**
1813     * @tc.name SingleKvStoreRemoveDeviceDataCallbackTest003
1814     * @tc.desc Test Js Api SingleKvStore.RemoveDeviceData() testcase 003
1815     * @tc.type: FUNC
1816     * @tc.require: issueNumber
1817     */
1818     it('SingleKvStoreRemoveDeviceDataCallbackTest003', 0, async function (done) {
1819        console.info('SingleKvStoreRemoveDeviceDataCallbackTest003');
1820        try {
1821            await kvStore.removeDeviceData('', function (err,data) {
1822                if (err == undefined) {
1823                    console.info('SingleKvStoreRemoveDeviceDataCallbackTest003 removeDeviceData success');
1824                    expect(null).assertFail();
1825                } else {
1826                    console.info('SingleKvStoreRemoveDeviceDataCallbackTest003 removeDeviceData fail');
1827                }
1828                done();
1829            });
1830        }catch(e) {
1831            console.error('SingleKvStoreRemoveDeviceDataCallbackTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
1832            done();
1833        }
1834    })
1835
1836    /**
1837     * @tc.name SingleKvStoreRemoveDeviceDataCallbackTest004
1838     * @tc.desc Test Js Api SingleKvStore.RemoveDeviceData() testcase 004
1839     * @tc.type: FUNC
1840     * @tc.require: issueNumber
1841     */
1842    it('SingleKvStoreRemoveDeviceDataCallbackTest004', 0, async function (done) {
1843        console.info('SingleKvStoreRemoveDeviceDataCallbackTest004');
1844        try {
1845            await kvStore.removeDeviceData(null, function (err,data) {
1846                if (err == undefined) {
1847                    console.info('SingleKvStoreRemoveDeviceDataCallbackTest004 removeDeviceData success');
1848                    expect(null).assertFail();
1849                } else {
1850                    console.info('SingleKvStoreRemoveDeviceDataCallbackTest004 removeDeviceData fail');
1851                }
1852                done();
1853            });
1854        }catch(e) {
1855            console.error('SingleKvStoreRemoveDeviceDataCallbackTest004 e ' + `, error code is ${e.code}, message is ${e.message}`);
1856            done();
1857        }
1858    })
1859
1860    /**
1861     * @tc.name SingleKvStoreSetSyncParamCallbackTest001
1862     * @tc.desc Test Js Api SingleKvStore.SetSyncParam() testcase 001
1863     * @tc.type: FUNC
1864     * @tc.require: issueNumber
1865     */
1866    it('SingleKvStoreSetSyncParamCallbackTest001', 0, async function (done) {
1867        console.info('SingleKvStoreSetSyncParamCallbackTest001');
1868        try {
1869            var defaultAllowedDelayMs = 500;
1870            await kvStore.setSyncParam(defaultAllowedDelayMs, function (err,data) {
1871                console.info('SingleKvStoreSetSyncParamCallbackTest001 put success');
1872                expect(err == undefined).assertTrue();
1873                done();
1874            });
1875        }catch(e) {
1876            console.error('SingleKvStoreSetSyncParamCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
1877            expect(null).assertFail();
1878            done();
1879        }
1880    })
1881
1882    /**
1883     * @tc.name SingleKvStoreSetSyncParamCallbackTest002
1884     * @tc.desc Test Js Api SingleKvStore.SetSyncParam() testcase 002
1885     * @tc.type: FUNC
1886     * @tc.require: issueNumber
1887     */
1888    it('SingleKvStoreSetSyncParamCallbackTest002', 0, async function (done) {
1889        console.info('SingleKvStoreSetSyncParamCallbackTest002');
1890        try {
1891            await kvStore.setSyncParam(function (err,data) {
1892                if (err == undefined) {
1893                    console.info('SingleKvStoreSetSyncParamCallbackTest002 put success');
1894                    expect(null).assertFail();
1895                } else {
1896                    console.error('SingleKvStoreSetSyncParamCallbackTest002 put err' + `, error code is ${err.code}, message is ${err.message}`);
1897                }
1898                done();
1899            });
1900        }catch(e) {
1901            console.error('SingleKvStoreSetSyncParamCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
1902            done();
1903        }
1904    })
1905
1906    /**
1907     * @tc.name SingleKvStoreSetSyncParamCallbackTest003
1908     * @tc.desc Test Js Api SingleKvStore.SetSyncParam() testcase 003
1909     * @tc.type: FUNC
1910     * @tc.require: issueNumber
1911     */
1912    it('SingleKvStoreSetSyncParamCallbackTest003', 0, async function (done) {
1913        console.info('SingleKvStoreSetSyncParamCallbackTest003');
1914        try {
1915            await kvStore.setSyncParam('', function (err,data) {
1916                if (err == undefined) {
1917                    console.info('SingleKvStoreSetSyncParamCallbackTest003 put success');
1918                    expect(null).assertFail();
1919                } else {
1920                    console.error('SingleKvStoreSetSyncParamCallbackTest003 put err' + `, error code is ${err.code}, message is ${err.message}`);
1921                }
1922                done();
1923            });
1924        }catch(e) {
1925            console.error('SingleKvStoreSetSyncParamCallbackTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
1926            done();
1927        }
1928    })
1929
1930    /**
1931     * @tc.name SingleKvStoreSetSyncParamCallbackTest004
1932     * @tc.desc Test Js Api SingleKvStore.SetSyncParam() testcase 004
1933     * @tc.type: FUNC
1934     * @tc.require: issueNumber
1935     */
1936    it('SingleKvStoreSetSyncParamCallbackTest004', 0, async function (done) {
1937        console.info('SingleKvStoreSetSyncParamCallbackTest004');
1938        try {
1939            await kvStore.setSyncParam(null, function (err,data) {
1940                if (err == undefined) {
1941                    console.info('SingleKvStoreSetSyncParamCallbackTest004 put success');
1942                    expect(null).assertFail();
1943                } else {
1944                    console.error('SingleKvStoreSetSyncParamCallbackTest004 put err' + `, error code is ${err.code}, message is ${err.message}`);
1945                }
1946                done();
1947            });
1948        }catch(e) {
1949            console.error('SingleKvStoreSetSyncParamCallbackTest004 e ' + `, error code is ${e.code}, message is ${e.message}`);
1950            done();
1951        }
1952    })
1953
1954    /**
1955     * @tc.name SingleKvStoreGetSecurityLevelCallbackTest002
1956     * @tc.desc Test Js Api SingleKvStore.GetSecurityLevel() testcase 002
1957     * @tc.type: FUNC
1958     * @tc.require: issueNumber
1959     */
1960    it('SingleKvStoreGetSecurityLevelCallbackTest002', 0, async function (done) {
1961        console.info('SingleKvStoreGetSecurityLevelCallbackTest002');
1962        try {
1963            await kvStore.getSecurityLevel(1, function (err,data) {
1964                if (err == undefined) {
1965                    console.info('SingleKvStoreGetSecurityLevelCallbackTest002 getSecurityLevel success');
1966                    expect(null).assertFail();
1967                } else {
1968                    console.error('SingleKvStoreGetSecurityLevelCallbackTest002 getSecurityLevel fail' + `, error code is ${err.code}, message is ${err.message}`);
1969                }
1970                done();
1971            });
1972        }catch(e) {
1973            console.error('SingleKvStoreGetSecurityLevelCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
1974            expect(null).assertFail();
1975            done();
1976        }
1977    })
1978
1979    /**
1980     * @tc.name SingleKvStoreGetSecurityLevelCallbackTest003
1981     * @tc.desc Test Js Api SingleKvStore.GetSecurityLevel() testcase 003
1982     * @tc.type: FUNC
1983     * @tc.require: issueNumber
1984     */
1985    it('SingleKvStoreGetSecurityLevelCallbackTest003', 0, async function (done) {
1986        console.info('SingleKvStoreGetSecurityLevelCallbackTest003');
1987        try {
1988            await kvStore.getSecurityLevel('test_string', function (err,data) {
1989                if (err == undefined) {
1990                    console.info('SingleKvStoreGetSecurityLevelCallbackTest003 getSecurityLevel success');
1991                    expect(null).assertFail();
1992                } else {
1993                    console.error('SingleKvStoreGetSecurityLevelCallbackTest003 getSecurityLevel fail' + `, error code is ${err.code}, message is ${err.message}`);
1994                }
1995                done();
1996            });
1997        }catch(e) {
1998            console.error('SingleKvStoreGetSecurityLevelCallbackTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
1999            expect(null).assertFail();
2000            done();
2001        }
2002    })
2003
2004    /**
2005     * @tc.name SingleKvStoreGetSecurityLevelCallbackTest004
2006     * @tc.desc Test Js Api SingleKvStore.GetSecurityLevel() testcase 004
2007     * @tc.type: FUNC
2008     * @tc.require: issueNumber
2009     */
2010    it('SingleKvStoreGetSecurityLevelCallbackTest004', 0, async function (done) {
2011        console.info('SingleKvStoreGetSecurityLevelCallbackTest004');
2012        try {
2013            await kvStore.getSecurityLevel(2.00, function (err,data) {
2014                if (err == undefined) {
2015                    console.info('SingleKvStoreGetSecurityLevelCallbackTest004 getSecurityLevel success');
2016                    expect(null).assertFail();
2017                } else {
2018                    console.error('SingleKvStoreGetSecurityLevelCallbackTest004 getSecurityLevel fail' + `, error code is ${err.code}, message is ${err.message}`);
2019                }
2020                done();
2021            });
2022        }catch(e) {
2023            console.error('SingleKvStoreGetSecurityLevelCallbackTest004 e ' + `, error code is ${e.code}, message is ${e.message}`);
2024            expect(null).assertFail();
2025            done();
2026        }
2027    })
2028
2029    /**
2030     * @tc.name SingleKvStoreGetResultSetCallbackTest001
2031     * @tc.desc Test Js Api SingleKvStore.GetResultSet() testcase 001
2032     * @tc.type: FUNC
2033     * @tc.require: issueNumber
2034     */
2035    it('SingleKvStoreGetResultSetCallbackTest001', 0, async function (done) {
2036        console.info('SingleKvStoreGetResultSetCallbackTest001');
2037        try {
2038            let resultSet;
2039            let entries = [];
2040            for (var i = 0; i < 10; i++) {
2041                var key = 'batch_test_string_key';
2042                var entry = {
2043                    key : key + i,
2044                    value : {
2045                        type : factory.ValueType.STRING,
2046                        value : 'batch_test_string_value'
2047                    }
2048                }
2049                entries.push(entry);
2050            }
2051            await kvStore.putBatch(entries, async function (err, data) {
2052                console.info('SingleKvStoreGetResultSetCallbackTest001 putBatch success');
2053                expect(err == undefined).assertTrue();
2054                await kvStore.getResultSet('batch_test_string_key', async function (err, result) {
2055                    console.info('SingleKvStoreGetResultSetCallbackTest001 getResultSet success');
2056                    resultSet = result;
2057                    expect(resultSet.getCount() == 10).assertTrue();
2058                    await kvStore.closeResultSet(resultSet, function (err, data) {
2059                        console.info('SingleKvStoreGetResultSetCallbackTest001 closeResultSet success');
2060                        expect(err == undefined).assertTrue();
2061                        done();
2062                    })
2063                });
2064            });
2065        }catch(e) {
2066            console.error('SingleKvStoreGetResultSetCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
2067            expect(null).assertFail();
2068            done();
2069        }
2070    })
2071
2072    /**
2073     * @tc.name SingleKvStoreGetResultSetCallbackTest002
2074     * @tc.desc Test Js Api SingleKvStore.GetResultSet() testcase 002
2075     * @tc.type: FUNC
2076     * @tc.require: issueNumber
2077     */
2078    it('SingleKvStoreGetResultSetCallbackTest002', 0, async function (done) {
2079        console.info('SingleKvStoreGetResultSetCallbackTest002');
2080        try {
2081            let resultSet;
2082            await kvStore.getResultSet('batch_test_string_key', async function (err, result) {
2083                console.info('SingleKvStoreGetResultSetCallbackTest002 getResultSet success');
2084                resultSet = result;
2085                expect(resultSet.getCount() == 0).assertTrue();
2086                await kvStore.closeResultSet(resultSet, function (err, data) {
2087                    console.info('SingleKvStoreGetResultSetCallbackTest002 closeResultSet success');
2088                    expect(err == undefined).assertTrue();
2089                    done();
2090                })
2091            });
2092        }catch(e) {
2093            console.error('SingleKvStoreGetResultSetCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
2094            expect(null).assertFail();
2095            done();
2096        }
2097    })
2098
2099    /**
2100     * @tc.name SingleKvStoreGetResultSetCallbackTest003
2101     * @tc.desc Test Js Api SingleKvStore.GetResultSet() testcase 003
2102     * @tc.type: FUNC
2103     * @tc.require: issueNumber
2104     */
2105    it('SingleKvStoreGetResultSetCallbackTest003', 0, async function (done) {
2106        console.info('SingleKvStoreGetResultSetCallbackTest003');
2107        try {
2108            let resultSet;
2109            await kvStore.getResultSet(function (err, result) {
2110                console.info('SingleKvStoreGetResultSetCallbackTest003 getResultSet success');
2111                expect(err != undefined).assertTrue();
2112                done();
2113            });
2114        }catch(e) {
2115            console.error('SingleKvStoreGetResultSetCallbackTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
2116            expect(null).assertFail();
2117            done();
2118        }
2119    })
2120
2121    /**
2122     * @tc.name SingleKvStoreGetResultSetCallbackTest004
2123     * @tc.desc Test Js Api SingleKvStore.GetResultSet() testcase 004
2124     * @tc.type: FUNC
2125     * @tc.require: issueNumber
2126     */
2127    it('SingleKvStoreGetResultSetCallbackTest004', 0, async function (done) {
2128        console.info('SingleKvStoreGetResultSetCallbackTest004');
2129        try {
2130            let resultSet;
2131            await kvStore.getResultSet('test_key_string', 123, function (err, result) {
2132                console.info('SingleKvStoreGetResultSetCallbackTest004 getResultSet success');
2133                expect(err != undefined).assertTrue();
2134                done();
2135            });
2136        }catch(e) {
2137            console.error('SingleKvStoreGetResultSetCallbackTest004 e ' + `, error code is ${e.code}, message is ${e.message}`);
2138            expect(null).assertFail();
2139            done();
2140        }
2141    })
2142
2143    /**
2144     * @tc.name SingleKvStoreGetResultSetCallbackTest005
2145     * @tc.desc Test Js Api SingleKvStore.GetResultSet() testcase 005
2146     * @tc.type: FUNC
2147     * @tc.require: issueNumber
2148     */
2149    it('SingleKvStoreGetResultSetCallbackTest005', 0, async function (done) {
2150        console.info('SingleKvStoreGetResultSetCallbackTest005');
2151        try {
2152            let resultSet;
2153            let entries = [];
2154            for (var i = 0; i < 10; i++) {
2155                var key = 'batch_test_string_key';
2156                var entry = {
2157                    key : key + i,
2158                    value : {
2159                        type : factory.ValueType.STRING,
2160                        value : 'batch_test_string_value'
2161                    }
2162                }
2163                entries.push(entry);
2164            }
2165            await kvStore.putBatch(entries, async function (err, data) {
2166                console.info('SingleKvStoreGetResultSetCallbackTest005 putBatch success');
2167                expect(err == undefined).assertTrue();
2168                var query = new factory.Query();
2169                query.prefixKey("batch_test");
2170                await kvStore.getResultSet(query, async function (err, result) {
2171                    console.info('SingleKvStoreGetResultSetCallbackTest005 getResultSet success');
2172                    resultSet = result;
2173                    expect(resultSet.getCount() == 10).assertTrue();
2174                    await kvStore.closeResultSet(resultSet, function (err, data) {
2175                        console.info('SingleKvStoreGetResultSetCallbackTest005 closeResultSet success');
2176                        expect(err == undefined).assertTrue();
2177                        done();
2178                    })
2179                });
2180            });
2181        } catch(e) {
2182            console.error('SingleKvStoreGetResultSetCallbackTest005 e ' + `, error code is ${e.code}, message is ${e.message}`);
2183            expect(null).assertFail();
2184            done();
2185        }
2186    })
2187
2188    /**
2189     * @tc.name SingleKvStoreGetResultSetCallbackTest006
2190     * @tc.desc Test Js Api SingleKvStore.GetResultSet() testcase 006
2191     * @tc.type: FUNC
2192     * @tc.require: issueNumber
2193     */
2194    it('SingleKvStoreGetResultSetCallbackTest006', 0, async function (done) {
2195        console.info('SingleKvStoreGetResultSetCallbackTest006');
2196        try {
2197            let resultSet;
2198            let entries = [];
2199            for (var i = 0; i < 10; i++) {
2200                var key = 'batch_test_string_key';
2201                var entry = {
2202                    key : key + i,
2203                    value : {
2204                        type : factory.ValueType.STRING,
2205                        value : 'batch_test_string_value'
2206                    }
2207                }
2208                entries.push(entry);
2209            }
2210            await kvStore.putBatch(entries, async function (err, data) {
2211                console.info('SingleKvStoreGetResultSetCallbackTest006 putBatch success');
2212                expect(err == undefined).assertTrue();
2213                var query = new factory.Query();
2214                query.prefixKey("batch_test");
2215                await kvStore.getResultSet(query, async function (err, result) {
2216                    console.info('SingleKvStoreGetResultSetCallbackTest006 getResultSet success');
2217                    resultSet = result;
2218                    expect(resultSet.getCount() == 10).assertTrue();
2219                    await kvStore.closeResultSet(resultSet, function (err, data) {
2220                        console.info('SingleKvStoreGetResultSetCallbackTest006 closeResultSet success');
2221                        expect(err == undefined).assertTrue();
2222                        done();
2223                    })
2224                });
2225            });
2226        } catch(e) {
2227            console.error('SingleKvStoreGetResultSetCallbackTest006 e ' + `, error code is ${e.code}, message is ${e.message}`);
2228            expect(null).assertFail();
2229            done();
2230        }
2231    })
2232
2233    /**
2234     * @tc.name SingleKvStoreCloseResultSetCallbackTest001
2235     * @tc.desc Test Js Api SingleKvStore.CloseResultSet() testcase 001
2236     * @tc.type: FUNC
2237     * @tc.require: issueNumber
2238     */
2239    it('SingleKvStoreCloseResultSetCallbackTest001', 0, async function (done) {
2240        console.info('SingleKvStoreCloseResultSetCallbackTest001');
2241        try {
2242            console.info('SingleKvStoreCloseResultSetCallbackTest001 success');
2243            let resultSet = null;
2244            await kvStore.closeResultSet(resultSet, function (err, data) {
2245                if (err == undefined) {
2246                    console.info('SingleKvStoreCloseResultSetCallbackTest001 closeResultSet success');
2247                    expect(null).assertFail();
2248                } else {
2249                    console.info('SingleKvStoreCloseResultSetCallbackTest001 closeResultSet fail');
2250                }
2251                done();
2252            });
2253        }catch(e) {
2254            console.error('SingleKvStoreCloseResultSetCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
2255            expect(null).assertFail();
2256            done();
2257        }
2258    })
2259
2260    /**
2261     * @tc.name SingleKvStoreCloseResultSetCallbackTest002
2262     * @tc.desc Test Js Api SingleKvStore.CloseResultSet() testcase 002
2263     * @tc.type: FUNC
2264     * @tc.require: issueNumber
2265     */
2266    it('SingleKvStoreCloseResultSetCallbackTest002', 0, async function (done) {
2267        console.info('SingleKvStoreCloseResultSetCallbackTest002');
2268        try {
2269            let resultSet = null;
2270            await kvStore.getResultSet('batch_test_string_key', async function(err, result) {
2271                console.info('SingleKvStoreCloseResultSetCallbackTest002 getResultSet success');
2272                resultSet = result;
2273                await kvStore.closeResultSet(resultSet, function (err, data) {
2274                    if (err == undefined) {
2275                        console.info('SingleKvStoreCloseResultSetCallbackTest002 closeResultSet success');
2276                        expect(err == undefined).assertTrue();
2277                    } else {
2278                        console.info('SingleKvStoreCloseResultSetCallbackTest002 closeResultSet fail');
2279                        expect(null).assertFail();
2280                    }
2281                    done();
2282                });
2283            });
2284        }catch(e) {
2285            console.error('SingleKvStoreCloseResultSetCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
2286            expect(null).assertFail();
2287            done();
2288        }
2289    })
2290
2291    /**
2292     * @tc.name SingleKvStoreCloseResultSetCallbackTest003
2293     * @tc.desc Test Js Api SingleKvStore.CloseResultSet() testcase 003
2294     * @tc.type: FUNC
2295     * @tc.require: issueNumber
2296     */
2297    it('SingleKvStoreCloseResultSetCallbackTest003', 0, async function (done) {
2298        console.info('SingleKvStoreCloseResultSetCallbackTest003');
2299        try {
2300            console.info('SingleKvStoreCloseResultSetCallbackTest003 success');
2301            await kvStore.closeResultSet(function (err, data) {
2302                if (err == undefined) {
2303                    console.info('SingleKvStoreCloseResultSetCallbackTest003 closeResultSet success');
2304                    expect(null).assertFail();
2305                } else {
2306                    console.info('SingleKvStoreCloseResultSetCallbackTest003 closeResultSet fail');
2307                }
2308                done();
2309            });
2310        }catch(e) {
2311            console.error('SingleKvStoreCloseResultSetCallbackTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
2312            expect(null).assertFail();
2313            done();
2314        }
2315    })
2316
2317    /**
2318     * @tc.name SingleKvStoreCloseResultSetCallbackTest004
2319     * @tc.desc Test Js Api SingleKvStore.CloseResultSet() testcase 004
2320     * @tc.type: FUNC
2321     * @tc.require: issueNumber
2322     */
2323    it('SingleKvStoreCloseResultSetCallbackTest004', 0, async function (done) {
2324        console.info('SingleKvStoreCloseResultSetCallbackTest004');
2325        try {
2326            console.info('SingleKvStoreCloseResultSetCallbackTest004 success');
2327        }catch(e) {
2328            console.error('SingleKvStoreCloseResultSetCallbackTest004 e ' + `, error code is ${e.code}, message is ${e.message}`);
2329            expect(null).assertFail();
2330        }
2331        done();
2332    })
2333
2334    /**
2335     * @tc.name SingleKvStoreGetResultSizeCallbackTest001
2336     * @tc.desc Test Js Api SingleKvStore.GetResultSize() testcase 001
2337     * @tc.type: FUNC
2338     * @tc.require: issueNumber
2339     */
2340    it('SingleKvStoreGetResultSizeCallbackTest001', 0, async function (done) {
2341        console.info('SingleKvStoreGetResultSizeCallbackTest001');
2342        try {
2343            let entries = [];
2344            for (var i = 0; i < 10; i++) {
2345                var key = 'batch_test_string_key';
2346                var entry = {
2347                    key : key + i,
2348                    value : {
2349                        type : factory.ValueType.STRING,
2350                        value : 'batch_test_string_value'
2351                    }
2352                }
2353                entries.push(entry);
2354            }
2355            await kvStore.putBatch(entries, async function (err, data) {
2356                console.info('SingleKvStoreGetResultSizeCallbackTest001 putBatch success');
2357                expect(err == undefined).assertTrue();
2358                var query = new factory.Query();
2359                query.prefixKey("batch_test");
2360                await kvStore.getResultSize(query, async function (err, resultSize) {
2361                    console.info('SingleKvStoreGetResultSizeCallbackTest001 getResultSet success');
2362                    expect(resultSize == 10).assertTrue();
2363                    done();
2364                });
2365            });
2366        } catch(e) {
2367            console.error('SingleKvStoreGetResultSizeCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
2368            expect(null).assertFail();
2369            done();
2370        }
2371    })
2372
2373    /**
2374     * @tc.name SingleKvStoreGetResultSizeCallbackTest002
2375     * @tc.desc Test Js Api SingleKvStore.GetResultSize() testcase 002
2376     * @tc.type: FUNC
2377     * @tc.require: issueNumber
2378     */
2379    it('SingleKvStoreGetResultSizeCallbackTest002', 0, async function (done) {
2380        console.info('SingleKvStoreGetResultSizeCallbackTest002');
2381        try {
2382            let entries = [];
2383            for (var i = 0; i < 10; i++) {
2384                var key = 'batch_test_string_key';
2385                var entry = {
2386                    key : key + i,
2387                    value : {
2388                        type : factory.ValueType.STRING,
2389                        value : 'batch_test_string_value'
2390                    }
2391                }
2392                entries.push(entry);
2393            }
2394            await kvStore.putBatch(entries, async function (err, data) {
2395                console.info('SingleKvStoreGetResultSizeCallbackTest002 putBatch success');
2396                expect(err == undefined).assertTrue();
2397                var query = new factory.Query();
2398                query.prefixKey("batch_test");
2399                await kvStore.getResultSize(query, async function (err, resultSize) {
2400                    console.info('SingleKvStoreGetResultSizeCallbackTest002 getResultSet success');
2401                    expect(resultSize == 10).assertTrue();
2402                    done();
2403                });
2404            });
2405        } catch(e) {
2406            console.error('SingleKvStoreGetResultSizeCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
2407            expect(null).assertFail();
2408            done();
2409        }
2410    })
2411
2412    /**
2413     * @tc.name SingleKvStoreGetEntriesCallbackTest001
2414     * @tc.desc Test Js Api SingleKvStore.GetEntries() testcase 001
2415     * @tc.type: FUNC
2416     * @tc.require: issueNumber
2417     */
2418    it('SingleKvStoreGetEntriesCallbackTest001', 0, async function (done) {
2419        console.info('SingleKvStoreGetEntriesCallbackTest001');
2420        try {
2421            var arr = new Uint8Array([21,31]);
2422            let entries = [];
2423            for (var i = 0; i < 10; i++) {
2424                var key = 'batch_test_bool_key';
2425                var entry = {
2426                    key : key + i,
2427                    value : {
2428                        type : factory.ValueType.BYTE_ARRAY,
2429                        value : arr
2430                    }
2431                }
2432                entries.push(entry);
2433            }
2434            console.info('SingleKvStoreGetEntriesCallbackTest001 entries: ' + JSON.stringify(entries));
2435            await kvStore.putBatch(entries, async function (err,data) {
2436                console.info('SingleKvStoreGetEntriesCallbackTest001 putBatch success');
2437                expect(err == undefined).assertTrue();
2438                var query = new factory.Query();
2439                query.prefixKey("batch_test");
2440                await kvStore.getEntries(query, function (err,entrys) {
2441                    console.info('SingleKvStoreGetEntriesCallbackTest001 getEntries success');
2442                    console.info('SingleKvStoreGetEntriesCallbackTest001 entrys.length: ' + entrys.length);
2443                    console.info('SingleKvStoreGetEntriesCallbackTest001 entrys[0]: ' + JSON.stringify(entrys[0]));
2444                    expect(entrys.length == 10).assertTrue();
2445                    expect(entrys[0].value.value.toString() == arr.toString()).assertTrue();
2446                    done();
2447                });
2448            });
2449            console.info('SingleKvStoreGetEntriesCallbackTest001 success');
2450        }catch(e) {
2451            console.error('SingleKvStoreGetEntriesCallbackTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
2452            expect(null).assertFail();
2453        }
2454        done();
2455    })
2456
2457    /**
2458     * @tc.name SingleKvStoreGetEntriesCallbackTest002
2459     * @tc.desc Test Js Api SingleKvStore.GetEntries() testcase 002
2460     * @tc.type: FUNC
2461     * @tc.require: issueNumber
2462     */
2463    it('SingleKvStoreGetEntriesCallbackTest002', 0, async function (done) {
2464        console.info('SingleKvStoreGetEntriesCallbackTest002');
2465        try {
2466            var arr = new Uint8Array([21,31]);
2467            let entries = [];
2468            for (var i = 0; i < 10; i++) {
2469                var key = 'batch_test_bool_key';
2470                var entry = {
2471                    key : key + i,
2472                    value : {
2473                        type : factory.ValueType.BYTE_ARRAY,
2474                        value : arr
2475                    }
2476                }
2477                entries.push(entry);
2478            }
2479            console.info('SingleKvStoreGetEntriesCallbackTest002 entries: ' + JSON.stringify(entries));
2480            await kvStore.putBatch(entries, async function (err,data) {
2481                console.info('SingleKvStoreGetEntriesCallbackTest002 putBatch success');
2482                expect(err == undefined).assertTrue();
2483                var query = new factory.Query();
2484                query.prefixKey("batch_test");
2485                await kvStore.getEntries(query, function (err,entrys) {
2486                    console.info('SingleKvStoreGetEntriesCallbackTest002 getEntries success');
2487                    console.info('SingleKvStoreGetEntriesCallbackTest002 entrys.length: ' + entrys.length);
2488                    console.info('SingleKvStoreGetEntriesCallbackTest002 entrys[0]: ' + JSON.stringify(entrys[0]));
2489                    expect(entrys.length == 10).assertTrue();
2490                    expect(entrys[0].value.value.toString() == arr.toString()).assertTrue();
2491                    done();
2492                });
2493            });
2494            console.info('SingleKvStoreGetEntriesCallbackTest002 success');
2495        }catch(e) {
2496            console.error('SingleKvStoreGetEntriesCallbackTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
2497            expect(null).assertFail();
2498        }
2499        done();
2500    })
2501})
2502