1/* 2 * Copyright (c) 2021-2023 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 dataShare from '@ohos.data.dataShare'; 17import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'deccjsunit/index'; 18 19const URI_CALLLOG = 'datashare:///com.ohos.calllogability'; 20const calllogUri = 'datashare:///com.ohos.calllogability/calls/calllog'; 21 22const URI_VOICEMAIL = 'datashare:///com.ohos.voicemailability'; 23const voicemailUri = 'datashare:///com.ohos.voicemailability/calls/voicemail'; 24 25const URI_CONTACTS = 'datashare:///com.ohos.contactsdataability'; 26const rawContactUri = 'datashare:///com.ohos.contactsdataability/contacts/raw_contact'; 27const contactDataUri = 'datashare:///com.ohos.contactsdataability/contacts/contact_data'; 28const deletedUri = 'datashare:///com.ohos.contactsdataability/contacts/deleted_raw_contact'; 29const PHONE_NUM_LEN_NINE = 9; 30const PHONE_NUM_LEN_TEN = 10; 31const CYCLE_INDEX = 1000; 32const USED_TIME_70000 = 70000; 33const USED_TIME_90000 = 90000; 34const SLEEP_TIME = 5000; 35const ROW_COUNT = 10000; 36 37describe('PerformanceTest', function () { 38 console.log(' PerformanceTest is start'); 39 function sleep(numberMillis) { 40 let now = new Date(); 41 let exitTime = now.getTime() + numberMillis; 42 while (true) { 43 now = new Date(); 44 if (now.getTime() > exitTime) { 45 return; 46 } 47 } 48 } 49 50 /** 51 * @tc.number raw_contact_insert_performance_test_900 52 * @tc.name The raw_contact table adds 10000 pieces of data, and the time consumption is calculated according to 53 * the running time of the use case 54 * @tc.desc Function test 55 */ 56 it('raw_contact_insert_performance_test_900', 0, async function (done) { 57 let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS); 58 console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper); 59 let listAddBluk = []; 60 for (let i = 0; i < CYCLE_INDEX; i++) { 61 let add = { 'display_name': 'xiaoli' + i, 'company': 'testCompany' + i, 'position': 'testPosition' + i }; 62 listAddBluk[i] = add; 63 } 64 try { 65 let old = new Date(); 66 let batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, listAddBluk); 67 batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, listAddBluk); 68 batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, listAddBluk); 69 batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, listAddBluk); 70 batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, listAddBluk); 71 batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, listAddBluk); 72 batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, listAddBluk); 73 batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, listAddBluk); 74 batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, listAddBluk); 75 batchInsertCode = await dataShareHelper.batchInsert(rawContactUri, listAddBluk); 76 let now = new Date(); 77 let usedTime = now - old; 78 console.info('raw_contact_insert_performance_test_900 usedTime = ' + usedTime); 79 expect(usedTime < USED_TIME_70000).assertTrue(); 80 sleep(SLEEP_TIME); 81 console.info('logMessage raw_contact_insert_performance_test_900: batchInsertCode = ' + batchInsertCode); 82 expect(batchInsertCode === 0).assertTrue(); 83 done(); 84 } catch (error) { 85 console.info('logMessage raw_contact_insert_performance_test_900: insert error = ' + error); 86 done(); 87 } 88 }); 89 90 /** 91 * @tc.number raw_contact_update_performance_test_1000 92 * @tc.name The raw_contact table updates data whose ID is not equal to 0, and the time consumption is calculated 93 * according to the running time of the use case 94 * @tc.desc Function test 95 */ 96 it('raw_contact_update_performance_test_1000', 0, async function (done) { 97 let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS); 98 console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper); 99 let updateValues = { 'favorite': 1 }; 100 let usedTime2000 = 2000; 101 let condition = new dataShare.DataSharePredicates(); 102 condition.greaterThan('id', '0'); 103 condition.and(); 104 condition.equalTo('is_deleted', '0'); 105 try { 106 let old = new Date(); 107 let updateCode = await dataShareHelper.update(rawContactUri, updateValues, condition); 108 let now = new Date(); 109 let usedTime = now - old; 110 console.info('raw_contact_update_performance_test_1000 usedTime = ' + usedTime); 111 expect(usedTime < usedTime2000).assertTrue(); 112 sleep(SLEEP_TIME); 113 console.info('logMessage raw_contact_update_performance_test_1000: updateCode = ' + updateCode); 114 expect(updateCode === 0).assertTrue(); 115 done(); 116 } catch (error) { 117 console.info('logMessage raw_contact_update_performance_test_1000: update error = ' + error); 118 done(); 119 } 120 }); 121 122 /** 123 * @tc.number raw_contact_query_performance_test_1100 124 * @tc.name The raw_ contact table queries 10000 pieces of data and calculates the time consumption according to 125 * the running time of the use case 126 * @tc.desc Function test 127 */ 128 it('raw_contact_query_performance_test_1100', 0, async function (done) { 129 let tag = 'raw_contact_query_performance_test_1100'; 130 let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS); 131 console.info(tag + ': start ! dataShareHelper = ' + dataShareHelper); 132 let usedTime200 = 200; 133 let resultColumns = []; 134 let condition = new dataShare.DataSharePredicates(); 135 condition.greaterThan('id', '0'); 136 condition.and(); 137 condition.equalTo('is_deleted', '0'); 138 try { 139 let old = new Date(); 140 let resultSet = await dataShareHelper.query(rawContactUri, resultColumns, condition); 141 let now = new Date(); 142 let usedTime = now - old; 143 console.info('raw_contact_query_performance_test_1100 usedTime = ' + usedTime); 144 expect(usedTime < usedTime200).assertTrue(); 145 sleep(SLEEP_TIME); 146 console.info(tag + ' : logMessage : rowCount' + resultSet.rowCount); 147 expect(resultSet.rowCount === ROW_COUNT).assertTrue(); 148 resultSet.close(); 149 done(); 150 } catch (error) { 151 console.info(tag + ' :logMessage : error = ' + error); 152 done(); 153 } 154 }); 155 156 /** 157 * @tc.number raw_contact_delete_performance_test_1200 158 * @tc.name The raw_contact table deletes 10000 pieces of data, and the time consumption is calculated according 159 * to the running time of the use case 160 * @tc.desc Function test 161 */ 162 it('raw_contact_delete_performance_test_1200', 0, async function (done) { 163 let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS); 164 console.info('raw_contact_delete_performance_test_1200 : start ! dataShareHelper = ' + dataShareHelper); 165 let usedTime7000 = 7000; 166 let condition = new dataShare.DataSharePredicates(); 167 condition.greaterThan('id', '0'); 168 condition.and(); 169 condition.equalTo('is_deleted', '0'); 170 try { 171 let old = new Date(); 172 let deleteCode = await dataShareHelper.delete(rawContactUri, condition); 173 let now = new Date(); 174 let usedTime = now - old; 175 console.info('raw_contact_delete_performance_test_1200 usedTime = ' + usedTime); 176 expect(usedTime < usedTime7000).assertTrue(); 177 sleep(SLEEP_TIME); 178 console.info('logMessage raw_contact_delete_performance_test_1200: deleteCode = ' + deleteCode); 179 expect(deleteCode === 0).assertTrue(); 180 done(); 181 } catch (error) { 182 console.info('logMessage raw_contact_delete_performance_test_1200: delete error = ' + error); 183 done(); 184 } 185 }); 186 187 /** 188 * @tc.number contact_data_insert_performance_test_1300 189 * @tc.name The contact_data table adds 10000 pieces of data, and the time consumption is calculated according to 190 * the running time of the use case 191 * @tc.desc Function test 192 */ 193 it('contact_data_insert_performance_test_1300', 0, async function (done) { 194 let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS); 195 console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper); 196 197 let rawContactValues = { 198 'display_name': 'xiaoli' 199 }; 200 try { 201 let rawContactId = await dataShareHelper.insert(rawContactUri, rawContactValues); 202 let sleepTime = 1000; 203 sleep(sleepTime); 204 console.info('logMessage contact_data_insert_performance_test_1300: rawContactId = ' + rawContactId); 205 } catch (error) { 206 console.info('logMessage contact_data_insert_performance_test_1300: raw_contact insert error = ' + error); 207 } 208 209 let condition = new dataShare.DataSharePredicates(); 210 condition.equalTo('id', rawContactId.toString()); 211 let deleteCode = await dataShareHelper.delete(rawContactUri, condition); 212 let sleepTime = 1000; 213 sleep(sleepTime); 214 console.info('logMessage contact_data_insert_performance_test_1300: deleteCode = ' + deleteCode); 215 216 let listAddBluk = []; 217 for (let i = 0; i < CYCLE_INDEX; i++) { 218 let add = { 'raw_contact_id': rawContactId, 'detail_info': 'xxx' + i, 'content_type': 'name' }; 219 listAddBluk[i] = add; 220 } 221 try { 222 let old = new Date(); 223 let batchInsertCode = await dataShareHelper.batchInsert(contactDataUri, listAddBluk); 224 batchInsertCode = await dataShareHelper.batchInsert(contactDataUri, listAddBluk); 225 batchInsertCode = await dataShareHelper.batchInsert(contactDataUri, listAddBluk); 226 batchInsertCode = await dataShareHelper.batchInsert(contactDataUri, listAddBluk); 227 batchInsertCode = await dataShareHelper.batchInsert(contactDataUri, listAddBluk); 228 batchInsertCode = await dataShareHelper.batchInsert(contactDataUri, listAddBluk); 229 batchInsertCode = await dataShareHelper.batchInsert(contactDataUri, listAddBluk); 230 batchInsertCode = await dataShareHelper.batchInsert(contactDataUri, listAddBluk); 231 batchInsertCode = await dataShareHelper.batchInsert(contactDataUri, listAddBluk); 232 batchInsertCode = await dataShareHelper.batchInsert(contactDataUri, listAddBluk); 233 let now = new Date(); 234 let usedTime = now - old; 235 console.info('contact_data_insert_performance_test_1300 usedTime = ' + usedTime); 236 expect(usedTime < USED_TIME_70000).assertTrue(); 237 sleep(SLEEP_TIME); 238 console.info('logMessage contact_data_insert_performance_test_1300: batchInsertCode = ' + batchInsertCode); 239 expect(batchInsertCode === 0).assertTrue(); 240 done(); 241 } catch (error) { 242 console.info('logMessage contact_data_insert_performance_test_1300: insert error = ' + error); 243 done(); 244 } 245 }); 246 247 /** 248 * @tc.number contact_data_update_performance_test_1400 249 * @tc.name The contact_data table updates data whose ID is not equal to 0, and the time consumption is 250 * calculated according to the running time of the use case 251 * @tc.desc Function test 252 */ 253 it('contact_data_update_performance_test_1400', 0, async function (done) { 254 let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS); 255 console.info( 256 'logMessage contact_data_update_performance_test_1400 dataShareHelper success! dataShareHelper = ' + 257 dataShareHelper 258 ); 259 let sleepTime8000 = 8000; 260 let usedTime35000 = 35000; 261 let updateValues = { 'syn_1': 'test' }; 262 let condition = new dataShare.DataSharePredicates(); 263 condition.greaterThan('id', '0'); 264 try { 265 let old = new Date(); 266 let updateCode = await dataShareHelper.update(contactDataUri, updateValues, condition); 267 let now = new Date(); 268 let usedTime = now - old; 269 console.info('contact_data_update_performance_test_1400 usedTime = ' + usedTime); 270 expect(usedTime < usedTime35000).assertTrue(); 271 sleep(sleepTime8000); 272 console.info('logMessage contact_data_update_performance_test_1400: updateCode = ' + updateCode); 273 expect(updateCode === 0).assertTrue(); 274 done(); 275 } catch (error) { 276 console.info('logMessage contact_data_update_performance_test_1400: update error = ' + error); 277 done(); 278 } 279 }); 280 281 /** 282 * @tc.number contact_data_query_performance_test_1500 283 * @tc.name The contact_datat table queries 10000 pieces of data and calculates the time consumption according to 284 * the running time of the use case 285 * @tc.desc Function test 286 */ 287 it('contact_data_query_performance_test_1500', 0, async function (done) { 288 let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS); 289 console.info('contact_data_query_performance_test_1500 start ! dataShareHelper = ' + dataShareHelper); 290 let usedTime220 = 220; 291 let resultColumns = []; 292 let condition = new dataShare.DataSharePredicates(); 293 condition.greaterThan('id', '0'); 294 try { 295 let old = new Date(); 296 let resultSet = await dataShareHelper.query(contactDataUri, resultColumns, condition); 297 let now = new Date(); 298 let usedTime = now - old; 299 console.info('contact_data_query_performance_test_1500 usedTime = ' + usedTime); 300 expect(usedTime < usedTime220).assertTrue(); 301 sleep(SLEEP_TIME); 302 console.info('logMessage contact_data_query_performance_test_1500: goToFirstRow' + resultSet.rowCount); 303 expect(resultSet.rowCount === ROW_COUNT).assertEqual(true); 304 resultSet.close(); 305 done(); 306 } catch (error) { 307 console.info('logMessage contact_data_query_performance_test_1500: error = ' + error); 308 done(); 309 } 310 }); 311 312 /** 313 * @tc.number contact_data_delete_performance_test_1600 314 * @tc.name The contact_data table deletes 10000 pieces of data, and the time consumption is calculated according 315 * to the running time of the use case 316 * @tc.desc Function test 317 */ 318 it('contact_data_delete_performance_test_1600', 0, async function (done) { 319 let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS); 320 console.info('contact_data_delete_performance_test_1600 : start ! dataShareHelper = ' + dataShareHelper); 321 let usedTime32000 = 32000; 322 let condition = new dataShare.DataSharePredicates(); 323 condition.greaterThan('id', '0'); 324 try { 325 let old = new Date(); 326 let deleteCode = await dataShareHelper.delete(contactDataUri, condition); 327 let now = new Date(); 328 let usedTime = now - old; 329 console.info('contact_data_delete_performance_test_1600 usedTime = ' + usedTime); 330 expect(usedTime < usedTime32000).assertTrue(); 331 sleep(SLEEP_TIME); 332 console.info('logMessage contact_data_delete_performance_test_1600: deleteCode = ' + deleteCode); 333 expect(deleteCode === 0).assertTrue(); 334 done(); 335 } catch (error) { 336 console.info('logMessage contact_data_delete_performance_test_1600: delete error = ' + error); 337 done(); 338 } 339 }); 340 341 /** 342 * @tc.number calllog_insert_performance_test_100 343 * @tc.name The callog table adds 10000 pieces of data, and the time consumption is calculated according to the 344 * running time of the use case 345 * @tc.desc Function test 346 */ 347 it('calllog_insert_performance_test_100', 0, async function (done) { 348 console.info('---------logMessage calllog_insert_performance_test_100 is starting!----------'); 349 let dataShareHelper = dataShare.createDataShareHelper(URI_CALLLOG); 350 console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper); 351 let phoneNumberLenSix = 6; 352 let listAddBluk = []; 353 let phoneNumber = randomNum(phoneNumberLenSix); 354 for (let i = 0; i < CYCLE_INDEX; i++) { 355 let add = { 'phone_number': phoneNumber + i }; 356 listAddBluk[i] = add; 357 } 358 try { 359 let old = new Date(); 360 let batchInsertCode = await dataShareHelper.batchInsert(calllogUri, listAddBluk); 361 batchInsertCode = await dataShareHelper.batchInsert(calllogUri, listAddBluk); 362 batchInsertCode = await dataShareHelper.batchInsert(calllogUri, listAddBluk); 363 batchInsertCode = await dataShareHelper.batchInsert(calllogUri, listAddBluk); 364 batchInsertCode = await dataShareHelper.batchInsert(calllogUri, listAddBluk); 365 batchInsertCode = await dataShareHelper.batchInsert(calllogUri, listAddBluk); 366 batchInsertCode = await dataShareHelper.batchInsert(calllogUri, listAddBluk); 367 batchInsertCode = await dataShareHelper.batchInsert(calllogUri, listAddBluk); 368 batchInsertCode = await dataShareHelper.batchInsert(calllogUri, listAddBluk); 369 batchInsertCode = await dataShareHelper.batchInsert(calllogUri, listAddBluk); 370 let now = new Date(); 371 let usedTime = now - old; 372 console.info('calllog_insert_performance_test_100 usedTime = ' + usedTime); 373 expect(usedTime < USED_TIME_90000).assertTrue(); 374 sleep(SLEEP_TIME); 375 console.info('logMessage calllog_insert_performance_test_100: batchInsertCode = ' + batchInsertCode); 376 expect(batchInsertCode === 0).assertTrue(); 377 done(); 378 } catch (error) { 379 console.info('logMessage calllog_insert_performance_test_100: batchInsert error = ' + error); 380 done(); 381 } 382 }); 383 384 /** 385 * @tc.number calllog_update_performance_test_200 386 * @tc.name The callog table updates data whose ID is not equal to 0, and the time consumption is calculated 387 * according to the running time of the use case 388 * @tc.desc Function test 389 */ 390 it('calllog_update_performance_test_200', 0, async function (done) { 391 let dataShareHelper = dataShare.createDataShareHelper(URI_CALLLOG); 392 console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper); 393 let updateValues = { 'answer_state': '1' }; 394 let usedTime300 = 300; 395 try { 396 let condition = new dataShare.DataSharePredicates(); 397 condition.notEqualTo('id', 0); 398 let old = new Date(); 399 let updateCode = await dataShareHelper.update(calllogUri, updateValues, condition); 400 let now = new Date(); 401 let usedTime = now - old; 402 console.info('calllog_update_performance_test_200 usedTime = ' + usedTime); 403 expect(usedTime < usedTime300).assertTrue(); 404 sleep(SLEEP_TIME); 405 console.info('logMessage calllog_update_performance_test_200: updateCode = ' + updateCode); 406 expect(updateCode === 0).assertTrue(); 407 done(); 408 } catch (error) { 409 console.info('logMessage calllog_update_performance_test_200: update error = ' + error); 410 done(); 411 } 412 }); 413 414 /** 415 * @tc.number calllog_query_performance_test_300 416 * @tc.name The callog table queries 10000 pieces of data to see whether they can be queried successfully 417 * @tc.desc Function test 418 */ 419 it('calllog_query_performance_test_300', 0, async function (done) { 420 let tag = 'calllog_query_performance_test_300'; 421 let dataShareHelper = dataShare.createDataShareHelper(URI_CALLLOG); 422 console.info(tag + ': start ! dataShareHelper = ' + dataShareHelper); 423 let usedTime30 = 30; 424 let resultColumns = []; 425 let condition = new dataShare.DataSharePredicates(); 426 condition.notEqualTo('id', 0); 427 428 try { 429 let old = new Date(); 430 let resultSet = await dataShareHelper.query(calllogUri, resultColumns, condition); 431 let now = new Date(); 432 let usedTime = now - old; 433 console.info('calllog_query_performance_test_300 usedTime = ' + usedTime); 434 expect(usedTime < usedTime30).assertTrue(); 435 sleep(SLEEP_TIME); 436 console.info(tag + ' : logMessage : rowCount' + resultSet.rowCount); 437 expect(resultSet.rowCount === ROW_COUNT).assertTrue(); 438 resultSet.close(); 439 done(); 440 } catch (error) { 441 console.info('logMessage calllog_query_performance_test_300: error = ' + error); 442 done(); 443 } 444 }); 445 446 /** 447 * @tc.number calllog_delete_performance_test_400 448 * @tc.name The callog table deletes 10000 pieces of data, and the time consumption is calculated according to 449 * the running time of the use case 450 * @tc.desc Function test 451 */ 452 it('calllog_delete_performance_test_400', 0, async function (done) { 453 let tag = 'calllog_delete_performance_test_400'; 454 let dataShareHelper = dataShare.createDataShareHelper(URI_CALLLOG); 455 console.info(tag + ': start ! dataShareHelper = ' + dataShareHelper); 456 let usedTime200 = 200; 457 let condition = new dataShare.DataSharePredicates(); 458 condition.greaterThan('id', '0'); 459 let old = new Date(); 460 let deleteCode = await dataShareHelper.delete(calllogUri, condition); 461 let now = new Date(); 462 let usedTime = now - old; 463 console.info('calllog_delete_performance_test_400 usedTime = ' + usedTime); 464 expect(usedTime < usedTime200).assertTrue(); 465 sleep(SLEEP_TIME); 466 console.info(tag + ' : logMessage : deleteCode = ' + deleteCode); 467 expect(deleteCode === 0).assertTrue(); 468 done(); 469 }); 470 471 /** 472 * @tc.number voicemail_insert_performance_test_500 473 * @tc.name The voicemail table adds 10000 pieces of data, and the time consumption is calculated according to 474 * the running time of the use case 475 * @tc.desc Function test 476 */ 477 it('voicemail_insert_performance_test_500', 0, async function (done) { 478 console.info('---------logMessage voicemail_insert_performance_test_500 is starting!----------'); 479 let dataShareHelper = dataShare.createDataShareHelper(URI_VOICEMAIL); 480 console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper); 481 let phoneNumberLenFour = 4; 482 let listAddBluk = []; 483 let phoneNumber = randomNum(phoneNumberLenFour); 484 for (let i = 0; i < CYCLE_INDEX; i++) { 485 let add = { 'phone_number': phoneNumber + i }; 486 listAddBluk[i] = add; 487 } 488 try { 489 let old = new Date(); 490 let batchInsertCode = await dataShareHelper.batchInsert(voicemailUri, listAddBluk); 491 batchInsertCode = await dataShareHelper.batchInsert(voicemailUri, listAddBluk); 492 batchInsertCode = await dataShareHelper.batchInsert(voicemailUri, listAddBluk); 493 batchInsertCode = await dataShareHelper.batchInsert(voicemailUri, listAddBluk); 494 batchInsertCode = await dataShareHelper.batchInsert(voicemailUri, listAddBluk); 495 batchInsertCode = await dataShareHelper.batchInsert(voicemailUri, listAddBluk); 496 batchInsertCode = await dataShareHelper.batchInsert(voicemailUri, listAddBluk); 497 batchInsertCode = await dataShareHelper.batchInsert(voicemailUri, listAddBluk); 498 batchInsertCode = await dataShareHelper.batchInsert(voicemailUri, listAddBluk); 499 batchInsertCode = await dataShareHelper.batchInsert(voicemailUri, listAddBluk); 500 let now = new Date(); 501 let usedTime = now - old; 502 console.info('voicemail_insert_performance_test_500 usedTime = ' + usedTime); 503 expect(usedTime < USED_TIME_90000).assertTrue(); 504 sleep(SLEEP_TIME); 505 console.info('logMessage voicemail_insert_performance_test_500: batchInsertCode = ' + batchInsertCode); 506 expect(batchInsertCode === 0).assertTrue(); 507 done(); 508 } catch (error) { 509 console.info('logMessage voicemail_insert_performance_test_500: batchInsert error = ' + error); 510 done(); 511 } 512 }); 513 514 /** 515 * @tc.number voicemail_update_performance_test_600 516 * @tc.name The voicemail table updates data whose ID is not equal to 0, and the time consumption is calculated 517 * according to the running time of the use case 518 * @tc.desc Function test 519 */ 520 it('voicemail_update_performance_test_600', 0, async function (done) { 521 let dataShareHelper = dataShare.createDataShareHelper(URI_VOICEMAIL); 522 console.info('logMessage get dataShareHelper success! dataShareHelper = ' + dataShareHelper); 523 let updateValues = { 'origin_type': 'test' }; 524 let usedTime250 = 250; 525 try { 526 let condition = new dataShare.DataSharePredicates(); 527 condition.notEqualTo('id', 0); 528 let old = new Date(); 529 let updateCode = await dataShareHelper.update(voicemailUri, updateValues, condition); 530 let now = new Date(); 531 let usedTime = now - old; 532 console.info('voicemail_update_performance_test_600 usedTime = ' + usedTime); 533 expect(usedTime < usedTime250).assertTrue(); 534 sleep(SLEEP_TIME); 535 console.info('logMessage voicemail_update_performance_test_600: updateCode = ' + updateCode); 536 expect(updateCode === 0).assertTrue(); 537 done(); 538 } catch (error) { 539 console.info('logMessage voicemail_update_performance_test_600: update error = ' + error); 540 done(); 541 } 542 }); 543 544 /** 545 * @tc.number voicemail_query_performance_test_700 546 * @tc.name The voicemail table queries 10000 items, and the time consumption is calculated according to the 547 * running time of the use case 548 * @tc.desc Function test 549 */ 550 it('voicemail_query_performance_test_700', 0, async function (done) { 551 let tag = 'voicemail_query_performance_test_700'; 552 let dataShareHelper = dataShare.createDataShareHelper(URI_VOICEMAIL); 553 console.info(tag + ': start ! dataShareHelper = ' + dataShareHelper); 554 let resultColumns = []; 555 let condition = new dataShare.DataSharePredicates(); 556 condition.greaterThan('id', '0'); 557 let usedTime20 = 20; 558 try { 559 let old = new Date(); 560 let resultSet = await dataShareHelper.query(voicemailUri, resultColumns, condition); 561 let now = new Date(); 562 let usedTime = now - old; 563 console.info('voicemail_query_performance_test_700 usedTime = ' + usedTime); 564 expect(usedTime < usedTime20).assertTrue(); 565 sleep(SLEEP_TIME); 566 console.info(tag + ' : logMessage : rowCount' + resultSet.rowCount); 567 expect(resultSet.rowCount === ROW_COUNT).assertTrue(); 568 resultSet.close(); 569 done(); 570 } catch (error) { 571 console.info('logMessage voicemail_query_performance_test_700: error = ' + error); 572 done(); 573 } 574 }); 575 576 /** 577 * @tc.number voicemail_delete_performance_test_800 578 * @tc.name The voicemail table deletes 10000 pieces of data, and the time consumption is calculated according to 579 * the running time of the use case 580 * @tc.desc Function test 581 */ 582 it('voicemail_delete_performance_test_800', 0, async function (done) { 583 let tag = 'voicemail_delete_performance_test_800'; 584 let dataShareHelper = dataShare.createDataShareHelper(URI_VOICEMAIL); 585 console.info(tag + ': start ! dataShareHelper = ' + dataShareHelper); 586 let condition = new dataShare.DataSharePredicates(); 587 condition.greaterThan('id', '0'); 588 let usedTime100 = 100; 589 try { 590 let old = new Date(); 591 let deleteCode = await dataShareHelper.delete(voicemailUri, condition); 592 let now = new Date(); 593 let usedTime = now - old; 594 console.info('voicemail_delete_performance_test_800 usedTime = ' + usedTime); 595 expect(usedTime < usedTime100).assertTrue(); 596 sleep(SLEEP_TIME); 597 console.info(tag + ' : logMessage : deleteCode = ' + deleteCode); 598 expect(deleteCode === 0).assertTrue(); 599 done(); 600 } catch (error) { 601 console.info('logMessage voicemail_delete_performance_test_800: error = ' + error); 602 done(); 603 } 604 }); 605 606 afterAll(async function () { 607 let dataShareHelper = dataShare.createDataShareHelper(URI_CONTACTS); 608 console.info('DeleteContact : start ! dataShareHelper = ' + dataShareHelper); 609 let condition = new dataShare.DataSharePredicates(); 610 condition.notEqualTo('id', '0'); 611 try { 612 let resultColumns = ['id']; 613 let conditionDelete = new dataShare.DataSharePredicates(); 614 conditionDelete.greaterThan('id', '0'); 615 let count = 0; 616 let deleteCount = 9999; 617 while (count < deleteCount) { 618 let result = await dataShareHelper.query(deletedUri, resultColumns, conditionDelete); 619 console.info('performance : result.rowCount = ' + result.rowCount); 620 count = result.rowCount; 621 result.close(); 622 sleep(SLEEP_TIME); 623 } 624 let deleteCode = await dataShareHelper.delete(deletedUri, condition); 625 console.info('afterAll logMessage DeleteContact: deleteCode = ' + deleteCode); 626 } catch (error) { 627 console.info('afterAll logMessage DeleteContact: delete error = ' + error); 628 } 629 }); 630}); 631 632function randomNum(num) { 633 let number = toString(Math.floor(Math.random() * (PHONE_NUM_LEN_NINE * Math.pow(PHONE_NUM_LEN_TEN, num))) + 1 * 634 Math.pow(PHONE_NUM_LEN_TEN, num)); 635 return number; 636} 637