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