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 SingleKvStoreGetSecurityLevelPromiseTest002
2151     * @tc.desc Test Js Api SingleKvStoreGetSecurityLevel testcase 002
2152     * @tc.type: FUNC
2153     * @tc.require: issueNumber
2154     */
2155    it('SingleKvStoreGetSecurityLevelPromiseTest002', 0, async function (done) {
2156        console.info('SingleKvStoreGetSecurityLevelPromiseTest002');
2157        try {
2158            await kvStore.getSecurityLevel(1).then((data) => {
2159                console.info('SingleKvStoreGetSecurityLevelPromiseTest002 getSecurityLevel success');
2160                expect(null).assertFail();
2161            }).catch((err) => {
2162                console.error('SingleKvStoreGetSecurityLevelPromiseTest002 getSecurityLevel fail ' + `, error code is ${err.code}, message is ${err.message}`);
2163            });
2164        }catch(e) {
2165            console.error('SingleKvStoreGetSecurityLevelPromiseTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
2166        }
2167        done();
2168    })
2169
2170    /**
2171     * @tc.name SingleKvStoreGetSecurityLevelPromiseTest003
2172     * @tc.desc Test Js Api SingleKvStoreGetSecurityLevel testcase 003
2173     * @tc.type: FUNC
2174     * @tc.require: issueNumber
2175     */
2176    it('SingleKvStoreGetSecurityLevelPromiseTest003', 0, async function (done) {
2177        console.info('SingleKvStoreGetSecurityLevelPromiseTest003');
2178        try {
2179            await kvStore.getSecurityLevel('test_string').then((data) => {
2180                console.info('SingleKvStoreGetSecurityLevelPromiseTest003 getSecurityLevel success');
2181                expect(null).assertFail();
2182            }).catch((err) => {
2183                console.error('SingleKvStoreGetSecurityLevelPromiseTest003 getSecurityLevel fail ' + `, error code is ${err.code}, message is ${err.message}`);
2184            });
2185        }catch(e) {
2186            console.error('SingleKvStoreGetSecurityLevelPromiseTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
2187        }
2188        done();
2189    })
2190
2191    /**
2192     * @tc.name SingleKvStoreGetSecurityLevelPromiseTest004
2193     * @tc.desc Test Js Api SingleKvStoreGetSecurityLevel testcase 004
2194     * @tc.type: FUNC
2195     * @tc.require: issueNumber
2196     */
2197    it('SingleKvStoreGetSecurityLevelPromiseTest004', 0, async function (done) {
2198        console.info('SingleKvStoreGetSecurityLevelPromiseTest004');
2199        try {
2200            await kvStore.getSecurityLevel(2.000).then((data) => {
2201                console.info('SingleKvStoreGetSecurityLevelPromiseTest004 getSecurityLevel success');
2202                expect(null).assertFail();
2203            }).catch((err) => {
2204                console.error('SingleKvStoreGetSecurityLevelPromiseTest004 getSecurityLevel fail ' + `, error code is ${err.code}, message is ${err.message}`);
2205            });
2206        }catch(e) {
2207            console.error('SingleKvStoreGetSecurityLevelPromiseTest004 e ' + `, error code is ${e.code}, message is ${e.message}`);
2208        }
2209        done();
2210    })
2211
2212    /**
2213     * @tc.name SingleKvStoreGetResultSetPromiseTest001
2214     * @tc.desc Test Js Api SingleKvStoreGetResultSet testcase 001
2215     * @tc.type: FUNC
2216     * @tc.require: issueNumber
2217     */
2218    it('SingleKvStoreGetResultSetPromiseTest001', 0, async function (done) {
2219        console.info('SingleKvStoreGetResultSetPromiseTest001');
2220        try {
2221            let resultSet;
2222            let entries = [];
2223            for (var i = 0; i < 10; i++) {
2224                var key = 'batch_test_string_key';
2225                var entry = {
2226                    key : key + i,
2227                    value : {
2228                        type : factory.ValueType.STRING,
2229                        value : 'batch_test_string_value'
2230                    }
2231                }
2232                entries.push(entry);
2233            }
2234            await kvStore.putBatch(entries).then(async (err) => {
2235                console.info('SingleKvStoreGetResultSetPromiseTest001 putBatch success');
2236                expect(err == undefined).assertTrue();
2237            }).catch((err) => {
2238                console.error('SingleKvStorePutBatchPromiseTest001 putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`);
2239                expect(null).assertFail();
2240            });
2241            await kvStore.getResultSet('batch_test_string_key').then((result) => {
2242                console.info('SingleKvStoreGetResultSetPromiseTest001 getResultSet success');
2243                resultSet = result;
2244                expect(resultSet.getCount() == 10).assertTrue();
2245            }).catch((err) => {
2246                console.error('SingleKvStoreGetResultSetPromiseTest001 getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2247                expect(null).assertFail();
2248            });
2249            await kvStore.closeResultSet(resultSet).then((err) => {
2250                console.info('SingleKvStoreGetResultSetPromiseTest001 closeResultSet success');
2251                expect(err == undefined).assertTrue();
2252            }).catch((err) => {
2253                console.error('SingleKvStoreGetResultSetPromiseTest001 closeResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2254                expect(null).assertFail();
2255            });
2256        }catch(e) {
2257            console.error('SingleKvStoreGetResultSetPromiseTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
2258            expect(null).assertFail();
2259        }
2260        done();
2261    })
2262
2263    /**
2264     * @tc.name SingleKvStoreGetResultSetPromiseTest002
2265     * @tc.desc Test Js Api SingleKvStoreGetResultSet testcase 002
2266     * @tc.type: FUNC
2267     * @tc.require: issueNumber
2268     */
2269    it('SingleKvStoreGetResultSetPromiseTest002', 0, async function (done) {
2270        console.info('SingleKvStoreGetResultSetPromiseTest002');
2271        try {
2272            let resultSet;
2273            await kvStore.getResultSet('batch_test_string_key').then((result) => {
2274                console.info('SingleKvStoreGetResultSetPromiseTest002 getResultSet success');
2275                resultSet = result;
2276                expect(resultSet.getCount() == 0).assertTrue();
2277            }).catch((err) => {
2278                console.error('SingleKvStoreGetResultSetPromiseTest002 getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2279                expect(null).assertFail();
2280            });
2281            await kvStore.closeResultSet(resultSet).then((err) => {
2282                console.info('SingleKvStoreGetResultSetPromiseTest002 closeResultSet success');
2283                expect(err == undefined).assertTrue();
2284            }).catch((err) => {
2285                console.error('SingleKvStoreGetResultSetPromiseTest002 closeResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2286                expect(null).assertFail();
2287            });
2288        }catch(e) {
2289            console.error('SingleKvStoreGetResultSetPromiseTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
2290            expect(null).assertFail();
2291        }
2292        done();
2293    })
2294
2295    /**
2296     * @tc.name SingleKvStoreGetResultSetPromiseTest003
2297     * @tc.desc Test Js Api SingleKvStoreGetResultSet testcase 003
2298     * @tc.type: FUNC
2299     * @tc.require: issueNumber
2300     */
2301    it('SingleKvStoreGetResultSetPromiseTest003', 0, async function (done) {
2302        console.info('SingleKvStoreGetResultSetPromiseTest003');
2303        try {
2304            let resultSet;
2305            await kvStore.getResultSet().then((result) => {
2306                console.info('SingleKvStoreGetResultSetPromiseTest003 getResultSet success');
2307                expect(null).assertFail();
2308            }).catch((err) => {
2309                console.error('SingleKvStoreGetResultSetPromiseTest003 getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2310            });
2311        }catch(e) {
2312            console.error('SingleKvStoreGetResultSetPromiseTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
2313            expect(null).assertFail();
2314        }
2315        done();
2316    })
2317
2318    /**
2319     * @tc.name SingleKvStoreGetResultSetPromiseTest004
2320     * @tc.desc Test Js Api SingleKvStoreGetResultSet testcase 004
2321     * @tc.type: FUNC
2322     * @tc.require: issueNumber
2323     */
2324    it('SingleKvStoreGetResultSetPromiseTest004', 0, async function (done) {
2325        console.info('SingleKvStoreGetResultSetPromiseTest004');
2326        try {
2327            let resultSet;
2328            await kvStore.getResultSet('test_key_string', 123).then((result) => {
2329                console.info('SingleKvStoreGetResultSetPromiseTest004 getResultSet success');
2330                expect(null).assertFail();
2331            }).catch((err) => {
2332                console.error('SingleKvStoreGetResultSetPromiseTest004 getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2333            });
2334        }catch(e) {
2335            console.error('SingleKvStoreGetResultSetPromiseTest004 e ' + `, error code is ${e.code}, message is ${e.message}`);
2336            expect(null).assertFail();
2337        }
2338        done();
2339    })
2340
2341    /**
2342     * @tc.name SingleKvStoreGetResultSetPromiseTest005
2343     * @tc.desc Test Js Api SingleKvStoreGetResultSet testcase 005
2344     * @tc.type: FUNC
2345     * @tc.require: issueNumber
2346     */
2347    it('SingleKvStoreGetResultSetPromiseTest005', 0, async function (done) {
2348        console.info('SingleKvStoreGetResultSetPromiseTest005');
2349        try {
2350            let resultSet;
2351            let entries = [];
2352            for (var i = 0; i < 10; i++) {
2353                var key = 'batch_test_string_key';
2354                var entry = {
2355                    key : key + i,
2356                    value : {
2357                        type : factory.ValueType.STRING,
2358                        value : 'batch_test_string_value'
2359                    }
2360                }
2361                entries.push(entry);
2362            }
2363            await kvStore.putBatch(entries).then(async (err) => {
2364                console.info('SingleKvStoreGetResultSetPromiseTest005 putBatch success');
2365                expect(err == undefined).assertTrue();
2366            }).catch((err) => {
2367                console.error('SingleKvStorePutBatchPromiseTest001 putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`);
2368                expect(null).assertFail();
2369            });
2370            var query = new factory.Query();
2371            query.prefixKey("batch_test");
2372            await kvStore.getResultSet(query).then((result) => {
2373                console.info('SingleKvStoreGetResultSetPromiseTest005 getResultSet success');
2374                resultSet = result;
2375                expect(resultSet.getCount() == 10).assertTrue();
2376            }).catch((err) => {
2377                console.error('SingleKvStoreGetResultSetPromiseTest005 getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2378                expect(null).assertFail();
2379            });
2380            await kvStore.closeResultSet(resultSet).then((err) => {
2381                console.info('SingleKvStoreGetResultSetPromiseTest005 closeResultSet success');
2382                expect(err == undefined).assertTrue();
2383            }).catch((err) => {
2384                console.error('SingleKvStoreGetResultSetPromiseTest005 closeResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2385                expect(null).assertFail();
2386            });
2387        }catch(e) {
2388            console.error('SingleKvStoreGetResultSetPromiseTest005 e ' + `, error code is ${e.code}, message is ${e.message}`);
2389            expect(null).assertFail();
2390        }
2391        done();
2392    })
2393
2394    /**
2395     * @tc.name SingleKvStoreGetResultSetPromiseTest006
2396     * @tc.desc Test Js Api SingleKvStoreGetResultSet testcase 006
2397     * @tc.type: FUNC
2398     * @tc.require: issueNumber
2399     */
2400    it('SingleKvStoreGetResultSetPromiseTest006', 0, async function (done) {
2401        console.info('SingleKvStoreGetResultSetPromiseTest006');
2402        try {
2403            let resultSet;
2404            let entries = [];
2405            for (var i = 0; i < 10; i++) {
2406                var key = 'batch_test_string_key';
2407                var entry = {
2408                    key : key + i,
2409                    value : {
2410                        type : factory.ValueType.STRING,
2411                        value : 'batch_test_string_value'
2412                    }
2413                }
2414                entries.push(entry);
2415            }
2416            await kvStore.putBatch(entries).then(async (err) => {
2417                console.info('SingleKvStoreGetResultSetPromiseTest006 putBatch success');
2418                expect(err == undefined).assertTrue();
2419            }).catch((err) => {
2420                console.error('SingleKvStorePutBatchPromiseTest001 putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`);
2421                expect(null).assertFail();
2422            });
2423            var query = new factory.Query();
2424            query.prefixKey("batch_test");
2425            await kvStore.getResultSet(query).then((result) => {
2426                console.info('SingleKvStoreGetResultSetPromiseTest006 getResultSet success');
2427                resultSet = result;
2428                expect(resultSet.getCount() == 10).assertTrue();
2429            }).catch((err) => {
2430                console.error('SingleKvStoreGetResultSetPromiseTest006 getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2431                expect(null).assertFail();
2432            });
2433            await kvStore.closeResultSet(resultSet).then((err) => {
2434                console.info('SingleKvStoreGetResultSetPromiseTest006 closeResultSet success');
2435                expect(err == undefined).assertTrue();
2436            }).catch((err) => {
2437                console.error('SingleKvStoreGetResultSetPromiseTest006 closeResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2438                expect(null).assertFail();
2439            });
2440        }catch(e) {
2441            console.error('SingleKvStoreGetResultSetPromiseTest006 e ' + `, error code is ${e.code}, message is ${e.message}`);
2442            expect(null).assertFail();
2443        }
2444        done();
2445    })
2446
2447    /**
2448     * @tc.name SingleKvStoreCloseResultSetPromiseTest001
2449     * @tc.desc Test Js Api SingleKvStoreCloseResultSet testcase 001
2450     * @tc.type: FUNC
2451     * @tc.require: issueNumber
2452     */
2453    it('SingleKvStoreCloseResultSetPromiseTest001', 0, async function (done) {
2454        console.info('SingleKvStoreCloseResultSetPromiseTest001');
2455        try {
2456            console.info('SingleKvStoreCloseResultSetPromiseTest001 success');
2457            let resultSet = null;
2458            await kvStore.closeResultSet(resultSet).then(() => {
2459                console.info('SingleKvStoreCloseResultSetPromiseTest001 closeResultSet success');
2460                expect(null).assertFail();
2461            }).catch((err) => {
2462                console.error('SingleKvStoreCloseResultSetPromiseTest001 closeResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2463            });
2464        }catch(e) {
2465            console.error('SingleKvStoreCloseResultSetPromiseTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
2466            expect(null).assertFail();
2467        }
2468        done();
2469    })
2470
2471    /**
2472     * @tc.name SingleKvStoreCloseResultSetPromiseTest002
2473     * @tc.desc Test Js Api SingleKvStoreCloseResultSet testcase 002
2474     * @tc.type: FUNC
2475     * @tc.require: issueNumber
2476     */
2477    it('SingleKvStoreCloseResultSetPromiseTest002', 0, async function (done) {
2478        console.info('SingleKvStoreCloseResultSetPromiseTest002');
2479        try {
2480            console.info('SingleKvStoreCloseResultSetPromiseTest002 success');
2481            let resultSet = null;
2482            await kvStore.getResultSet('batch_test_string_key').then((result) => {
2483                console.info('SingleKvStoreCloseResultSetPromiseTest002 getResultSet success');
2484                resultSet = result;
2485            }).catch((err) => {
2486                console.error('SingleKvStoreCloseResultSetPromiseTest002 getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2487                expect(null).assertFail();
2488            });
2489            await kvStore.closeResultSet(resultSet).then((err) => {
2490                console.info('SingleKvStoreCloseResultSetPromiseTest002 closeResultSet success');
2491                expect(err == undefined).assertTrue();
2492            }).catch((err) => {
2493                console.error('SingleKvStoreCloseResultSetPromiseTest002 closeResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2494                expect(null).assertFail();
2495            });
2496        }catch(e) {
2497            console.error('SingleKvStoreCloseResultSetPromiseTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
2498            expect(null).assertFail();
2499        }
2500        done();
2501    })
2502
2503    /**
2504     * @tc.name SingleKvStoreCloseResultSetPromiseTest003
2505     * @tc.desc Test Js Api SingleKvStoreCloseResultSet testcase 003
2506     * @tc.type: FUNC
2507     * @tc.require: issueNumber
2508     */
2509    it('SingleKvStoreCloseResultSetPromiseTest003', 0, async function (done) {
2510        console.info('SingleKvStoreCloseResultSetPromiseTest003');
2511        try {
2512            console.info('SingleKvStoreCloseResultSetPromiseTest003 success');
2513            let resultSet = null;
2514            await kvStore.closeResultSet().then(() => {
2515                console.info('SingleKvStoreCloseResultSetPromiseTest003 closeResultSet success');
2516                expect(null).assertFail();
2517            }).catch((err) => {
2518                console.error('SingleKvStoreCloseResultSetPromiseTest003 closeResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2519            });
2520        }catch(e) {
2521            console.error('SingleKvStoreCloseResultSetPromiseTest003 e ' + `, error code is ${e.code}, message is ${e.message}`);
2522            expect(null).assertFail();
2523        }
2524        done();
2525    })
2526
2527    /**
2528     * @tc.name SingleKvStoreCloseResultSetPromiseTest004
2529     * @tc.desc Test Js Api SingleKvStoreCloseResultSet testcase 004
2530     * @tc.type: FUNC
2531     * @tc.require: issueNumber
2532     */
2533    it('SingleKvStoreCloseResultSetPromiseTest004', 0, async function (done) {
2534        console.info('SingleKvStoreCloseResultSetPromiseTest004');
2535        try {
2536            console.info('SingleKvStoreCloseResultSetPromiseTest004 success');
2537        }catch(e) {
2538            console.error('SingleKvStoreCloseResultSetPromiseTest004 e ' + `, error code is ${e.code}, message is ${e.message}`);
2539            expect(null).assertFail();
2540        }
2541        done();
2542    })
2543
2544    /**
2545     * @tc.name SingleKvStoreGetResultSizePromiseTest001
2546     * @tc.desc Test Js Api SingleKvStoreGetResultSize testcase 001
2547     * @tc.type: FUNC
2548     * @tc.require: issueNumber
2549     */
2550    it('SingleKvStoreGetResultSizePromiseTest001', 0, async function (done) {
2551        console.info('SingleKvStoreGetResultSizePromiseTest001');
2552        try {
2553            let entries = [];
2554            for (var i = 0; i < 10; i++) {
2555                var key = 'batch_test_string_key';
2556                var entry = {
2557                    key : key + i,
2558                    value : {
2559                        type : factory.ValueType.STRING,
2560                        value : 'batch_test_string_value'
2561                    }
2562                }
2563                entries.push(entry);
2564            }
2565            await kvStore.putBatch(entries).then(async (err) => {
2566                console.info('SingleKvStoreGetResultSizePromiseTest001 putBatch success');
2567                expect(err == undefined).assertTrue();
2568            }).catch((err) => {
2569                console.error('SingleKvStorePutBatchPromiseTest001 putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`);
2570                expect(null).assertFail();
2571            });
2572            var query = new factory.Query();
2573            query.prefixKey("batch_test");
2574            await kvStore.getResultSize(query).then((resultSize) => {
2575                console.info('SingleKvStoreGetResultSizePromiseTest001 getResultSet success');
2576                expect(resultSize == 10).assertTrue();
2577            }).catch((err) => {
2578                console.error('SingleKvStoreGetResultSizePromiseTest001 getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2579                expect(null).assertFail();
2580            });
2581        }catch(e) {
2582            console.error('SingleKvStoreGetResultSizePromiseTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
2583            expect(null).assertFail();
2584        }
2585        done();
2586    })
2587
2588    /**
2589     * @tc.name SingleKvStoreGetResultSizePromiseTest002
2590     * @tc.desc Test Js Api SingleKvStoreGetResultSize testcase 002
2591     * @tc.type: FUNC
2592     * @tc.require: issueNumber
2593     */
2594    it('SingleKvStoreGetResultSizePromiseTest002', 0, async function (done) {
2595        console.info('SingleKvStoreGetResultSizePromiseTest001');
2596        try {
2597            let entries = [];
2598            for (var i = 0; i < 10; i++) {
2599                var key = 'batch_test_string_key';
2600                var entry = {
2601                    key : key + i,
2602                    value : {
2603                        type : factory.ValueType.STRING,
2604                        value : 'batch_test_string_value'
2605                    }
2606                }
2607                entries.push(entry);
2608            }
2609            await kvStore.putBatch(entries).then(async (err) => {
2610                console.info('SingleKvStoreGetResultSizePromiseTest001 putBatch success');
2611                expect(err == undefined).assertTrue();
2612            }).catch((err) => {
2613                console.error('SingleKvStorePutBatchPromiseTest001 putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`);
2614                expect(null).assertFail();
2615            });
2616            var query = new factory.Query();
2617            query.prefixKey("batch_test");
2618            await kvStore.getResultSize(query).then((resultSize) => {
2619                console.info('SingleKvStoreGetResultSizePromiseTest001 getResultSet success');
2620                expect(resultSize == 10).assertTrue();
2621            }).catch((err) => {
2622                console.error('SingleKvStoreGetResultSizePromiseTest001 getResultSet fail ' + `, error code is ${err.code}, message is ${err.message}`);
2623                expect(null).assertFail();
2624            });
2625        }catch(e) {
2626            console.error('SingleKvStoreGetResultSizePromiseTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
2627            expect(null).assertFail();
2628        }
2629        done();
2630    })
2631
2632    /**
2633     * @tc.name SingleKvStoreGetEntriesPromiseTest001
2634     * @tc.desc Test Js Api SingleKvStoreGetEntries testcase 001
2635     * @tc.type: FUNC
2636     * @tc.require: issueNumber
2637     */
2638    it('SingleKvStoreGetEntriesPromiseTest001', 0, async function (done) {
2639        console.info('SingleKvStoreGetEntriesPromiseTest001');
2640        try {
2641            var arr = new Uint8Array([21,31]);
2642            let entries = [];
2643            for (var i = 0; i < 10; i++) {
2644                var key = 'batch_test_bool_key';
2645                var entry = {
2646                    key : key + i,
2647                    value : {
2648                        type : factory.ValueType.BYTE_ARRAY,
2649                        value : arr
2650                    }
2651                }
2652                entries.push(entry);
2653            }
2654            console.info('SingleKvStoreGetEntriesPromiseTest001 entries: ' + JSON.stringify(entries));
2655            await kvStore.putBatch(entries).then(async (err) => {
2656                console.info('SingleKvStoreGetEntriesPromiseTest001 putBatch success');
2657                expect(err == undefined).assertTrue();
2658                var query = new factory.Query();
2659                query.prefixKey("batch_test");
2660                await kvStore.getEntries(query).then((entrys) => {
2661                    console.info('SingleKvStoreGetEntriesPromiseTest001 getEntries success');
2662                    expect(entrys.length == 10).assertTrue();
2663                    expect(entrys[0].value.value.toString() == arr.toString()).assertTrue();
2664                }).catch((err) => {
2665                    console.error('SingleKvStoreGetEntriesPromiseTest001 getEntries fail ' + `, error code is ${err.code}, message is ${err.message}`);
2666                    expect(null).assertFail();
2667                });
2668            }).catch((err) => {
2669                console.error('SingleKvStoreGetEntriesPromiseTest001 putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`);
2670                expect(null).assertFail();
2671            });
2672            console.info('SingleKvStoreGetEntriesPromiseTest001 success');
2673        }catch(e) {
2674            console.error('SingleKvStoreGetEntriesPromiseTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
2675            expect(null).assertFail();
2676        }
2677        done();
2678    })
2679
2680    /**
2681     * @tc.name SingleKvStoreGetEntriesPromiseTest002
2682     * @tc.desc Test Js Api SingleKvStoreGetEntries testcase 002
2683     * @tc.type: FUNC
2684     * @tc.require: issueNumber
2685     */
2686    it('SingleKvStoreGetEntriesPromiseTest002', 0, async function (done) {
2687        console.info('SingleKvStoreGetEntriesPromiseTest002');
2688        try {
2689            var arr = new Uint8Array([21,31]);
2690            let entries = [];
2691            for (var i = 0; i < 10; i++) {
2692                var key = 'batch_test_bool_key';
2693                var entry = {
2694                    key : key + i,
2695                    value : {
2696                        type : factory.ValueType.BYTE_ARRAY,
2697                        value : arr
2698                    }
2699                }
2700                entries.push(entry);
2701            }
2702            console.info('SingleKvStoreGetEntriesPromiseTest002 entries: ' + JSON.stringify(entries));
2703            await kvStore.putBatch(entries).then(async (err) => {
2704                console.info('SingleKvStoreGetEntriesPromiseTest002 putBatch success');
2705                expect(err == undefined).assertTrue();
2706                var query = new factory.Query();
2707                query.prefixKey("batch_test");
2708                await kvStore.getEntries(query).then((entrys) => {
2709                    console.info('SingleKvStoreGetEntriesPromiseTest002 getEntries success');
2710                    expect(entrys.length == 10).assertTrue();
2711                    expect(entrys[0].value.value.toString() == arr.toString()).assertTrue();
2712                }).catch((err) => {
2713                    console.error('SingleKvStoreGetEntriesPromiseTest002 getEntries fail ' + `, error code is ${err.code}, message is ${err.message}`);
2714                    expect(null).assertFail();
2715                });
2716            }).catch((err) => {
2717                console.error('SingleKvStoreGetEntriesPromiseTest002 putBatch fail ' + `, error code is ${err.code}, message is ${err.message}`);
2718                expect(null).assertFail();
2719            });
2720            console.info('SingleKvStoreGetEntriesPromiseTest002 success');
2721        }catch(e) {
2722            console.error('SingleKvStoreGetEntriesPromiseTest002 e ' + `, error code is ${e.code}, message is ${e.message}`);
2723            expect(null).assertFail();
2724        }
2725        done();
2726    })
2727
2728    /**
2729     * @tc.name SingleKvStoreChangeNotificationPromiseTest001
2730     * @tc.desc Test Js Api SingleKvStoreChangeNotification testcase 001
2731     * @tc.type: FUNC
2732     * @tc.require: issueNumber
2733     */
2734     it('SingleKvStoreChangeNotificationPromiseTest001', 0, async function (done) {
2735        var getInsertEntries = new Promise((resolve, reject) => {
2736            kvStore.on('dataChange', 0, function(ChangeNotification){
2737                resolve(ChangeNotification.insertEntries);
2738            });
2739            kvStore.put("getInsertEntries", "byPut").then(() => {
2740                console.info('SingleKvStoreChangeNotificationPromiseTest001 put success');
2741            });
2742        });
2743        await getInsertEntries.then(function(insertEntries){
2744            console.info('SingleKvStoreChangeNotificationPromiseTest001 getInsertEntries' + JSON.stringify(insertEntries));
2745            expect(insertEntries).assertNotNull();
2746        }).catch((error) => {
2747            console.error('SingleKvStoreChangeNotificationPromiseTest001 can NOT getInsertEntries, fail:' + `, error code is ${error.code}, message is ${error.message}`);
2748        });
2749        done();
2750    })
2751
2752    /**
2753    * @tc.number SUB_DISTRIBUTEDDATAMGR_SINGLEKVSTORE_CHANGENOTIFICATION_0200
2754    * @tc.name [JS-API8]SingleKvStoreChangeNotification.
2755    * @tc.desc Test Js Api SingleKvStoreChangeNotification testcase 002
2756    */
2757    it('SingleKvStoreChangeNotificationPromiseTest002', 0, async function (done) {
2758        await kvStore.put('getUpdateEntries', 'byPut').then(() => {
2759                console.info('SingleKvStoreChangeNotificationPromiseTest002 put success');
2760        });
2761        var getUpdateEntries = new Promise((resolve, reject) => {
2762            kvStore.on('dataChange', 0, function(ChangeNotification){
2763                resolve(ChangeNotification.updateEntries);
2764            });
2765            kvStore.put("getUpdateEntries", "byPut").then(() => {
2766                console.info('SingleKvStoreChangeNotificationPromiseTest002 update success');
2767            });
2768        });
2769        await getUpdateEntries.then(function(updateEntries){
2770            console.info('SingleKvStoreChangeNotificationPromiseTest002 getUpdateEntries' + JSON.stringify(updateEntries));
2771            expect(updateEntries).assertNotNull();
2772        }).catch((error) => {
2773            console.error('SingleKvStoreChangeNotificationPromiseTest002 can NOT getUpdateEntries, fail:' + `, error code is ${error.code}, message is ${error.message}`);
2774        });
2775        done();
2776    })
2777
2778    /**
2779    * @tc.number SUB_DISTRIBUTEDDATAMGR_SINGLEKVSTORE_CHANGENOTIFICATION_0300
2780    * @tc.name [JS-API8]SingleKvStoreChangeNotification.
2781    * @tc.desc Test Js Api SingleKvStoreChangeNotification testcase 003
2782    */
2783    it('SingleKvStoreChangeNotificationPromiseTest003', 0, async function (done) {
2784        await kvStore.put('deleteEntries', 'byPut').then(() => {
2785            console.info('SingleKvStoreChangeNotificationPromiseTest003 put success');
2786        });
2787        var getdeleteEntries = new Promise((resolve, reject) => {
2788            kvStore.on('dataChange', 0, function(ChangeNotification){
2789                resolve(ChangeNotification.deleteEntries);
2790            });
2791            kvStore.delete("deleteEntries").then(() => {
2792                console.info('SingleKvStoreChangeNotificationPromiseTest003 delete success');
2793            });
2794        });
2795        await getdeleteEntries.then(function(deleteEntries){
2796            console.info('SingleKvStoreChangeNotificationPromiseTest003 deleteEntries' + JSON.stringify(getdeleteEntries));
2797            expect(deleteEntries != null).assertNotNull();
2798        }).catch((error) => {
2799            console.error('SingleKvStoreChangeNotificationPromiseTest003 can NOT getdeleteEntries, fail:' + `, error code is ${error.code}, message is ${error.message}`);
2800        });
2801        done();
2802    })
2803
2804    /**
2805     * @tc.name: KVStorePutPromiseTest001
2806     * @tc.desc: Test Js Api KVManager.Put() testcase 001
2807     * @tc.type: FUNC
2808     * @tc.require: issueNumber
2809     */
2810    it('KVStorePutPromiseTest001', 0, async function (done) {
2811        console.info('KVStorePutPromiseTest001');
2812        try {
2813            await kvStore.put(TEST_BUNDLE_NAME, TEST_STORE_ID).then((data) => {
2814                if (err != undefined) {
2815                    console.info('KVStorePutPromiseTest001 put promise fail');
2816                } else {
2817                    console.info('KVStorePutPromiseTest001 put promise success');
2818                    expect(null).assertFail();
2819                }
2820                done();
2821            });
2822        } catch (e) {
2823            console.error('KVStorePutPromiseTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
2824            done();
2825        }
2826    })
2827
2828    /**
2829     * @tc.name: KVStoreDeletePromiseTest001
2830     * @tc.desc: Test Js Api KVManager.Delete testcase 001
2831     * @tc.type: FUNC
2832     * @tc.require: issueNumber
2833     */
2834    it('KVStoreDeletePromiseTest001', 0, async function (done) {
2835        console.info('KVStoreDeletePromiseTest001');
2836        try {
2837            kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((data) => {
2838                console.info('KVStoreDeletePromiseTest001 getKVStore success');
2839                kvStore.delete(KEY_TEST_STRING_ELEMENT).then((data) => {
2840                    console.info("testKVStoreDelete001  promise delete success");
2841                    expect(null).assertFail();
2842                }).catch((err) => {
2843                    console.error('KVStoreDeletePromiseTest001 promise delete fail err' + `, error code is ${err.code}, message is ${err.message}`);
2844                });
2845            }).catch((err) => {
2846                console.error('KVStoreDeletePromiseTest001 promise delete fail err' + `, error code is ${err.code}, message is ${err.message}`);
2847            });
2848        } catch (e) {
2849            console.error('KVStoreDeletePromiseTest001 promise delete fail err' + `, error code is ${err.code}, message is ${err.message}`);
2850        }
2851        done();
2852    })
2853})
2854