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