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