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