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