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 16// @ts-nocheck 17import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' 18import systemDateTime from '@ohos.systemDateTime' 19 20describe('SystemDateTimeGetTest', function () { 21 const MILLI_TO_BASE = 1000; 22 const NANO_TO_BASE = 1000000000; 23 const NANO_TO_MILLI = NANO_TO_BASE / MILLI_TO_BASE; 24 25 /** 26 * @tc.number: TestGetCurrentTimeMs001 27 * @tc.name: TestGetCurrentTimeMs001 28 * @tc.desc: test getCurrentTime ms for promise. 29 * @tc.size: MediumTest 30 * @tc.type: Function 31 * @tc.level: Level 1 32 * @tc.require: 33 */ 34 it('testGetCurrentTimeMs001', 0, async function (done) { 35 console.log("testGetCurrentTimeMs001 start"); 36 const nowTime = new Date().getTime(); 37 const milliTime = await systemDateTime.getCurrentTime(); 38 console.log('Get current time is ' + milliTime); 39 expect(typeof (milliTime) === 'number' && milliTime >= nowTime).assertTrue(); 40 console.log('testGetCurrentTimeMs001 end'); 41 done(); 42 }) 43 44 /** 45 * @tc.number: TestGetCurrentTimeMs002 46 * @tc.name: TestGetCurrentTimeMs002 47 * @tc.desc: test getCurrentTime ms for callback. 48 * @tc.size: MediumTest 49 * @tc.type: Function 50 * @tc.level: Level 1 51 * @tc.require: 52 */ 53 it('testGetCurrentTimeMs002', 0, async function (done) { 54 console.log("testGetCurrentTimeMs002 start"); 55 const nowTime = new Date().getTime(); 56 systemDateTime.getCurrentTime((err, data) => { 57 if (err) { 58 expect(false).assertTrue(); 59 } 60 expect(typeof (data) === 'number' && data >= nowTime).assertTrue(); 61 done(); 62 }) 63 console.log('testGetCurrentTimeMs002 end'); 64 }) 65 66 /** 67 * @tc.number: TestGetCurrentTimeMs003 68 * @tc.name: TestGetCurrentTimeMs003 69 * @tc.desc: test getCurrentTime ms for promise when isNano is false. 70 * @tc.size: MediumTest 71 * @tc.type: Function 72 * @tc.level: Level 1 73 * @tc.require: 74 */ 75 it('testGetCurrentTimeMs003', 0, async function (done) { 76 console.log("testGetCurrentTimeMs003 start"); 77 const nowTime = new Date().getTime(); 78 const milliTime = await systemDateTime.getCurrentTime(false); 79 console.log('Get current time is ' + milliTime); 80 expect(milliTime >= nowTime && typeof (milliTime) === 'number').assertTrue(); 81 console.log('testGetCurrentTimeMs003 end'); 82 done(); 83 }) 84 85 /** 86 * @tc.number: TestGetCurrentTimeMs004 87 * @tc.name: TestGetCurrentTimeMs004 88 * @tc.desc: test getCurrentTime ms for callback when isNano is false. 89 * @tc.size: MediumTest 90 * @tc.type: Function 91 * @tc.level: Level 1 92 * @tc.require: 93 */ 94 it('testGetCurrentTimeMs004', 0, async function (done) { 95 console.log("testGetCurrentTimeMs004 start"); 96 const nowTime = new Date().getTime(); 97 systemDateTime.getCurrentTime(false, (err, data) => { 98 if (err) { 99 expect(false).assertTrue(); 100 } 101 expect(typeof (data) === 'number' && data >= nowTime).assertTrue(); 102 done(); 103 }); 104 console.log('testGetCurrentTimeMs004 end'); 105 }) 106 107 /** 108 * @tc.number: TestGetCurrentTimeNs001 109 * @tc.name: TestGetCurrentTimeNs001 110 * @tc.desc: test getCurrentTime ns for promise when inNano is true 111 * @tc.size: MediumTest 112 * @tc.type: Function 113 * @tc.level: Level 1 114 * @tc.require: 115 */ 116 it('testGetCurrentTimeNs001', 0, async function (done) { 117 console.log("testGetCurrentTimeNs001 start"); 118 const nowTime = new Date().getTime(); 119 const nanoTime = await systemDateTime.getCurrentTime(true); 120 console.log('Get current nano time is ' + nanoTime); 121 const milliTime = nanoTime / NANO_TO_MILLI; 122 expect(milliTime >= nowTime).assertTrue(); 123 console.log('testGetCurrentTimeNs001 end'); 124 done(); 125 }) 126 127 /** 128 * @tc.number: TestGetCurrentTimeNs002 129 * @tc.name: TestGetCurrentTimeNs002 130 * @tc.desc: test getCurrentTime ns for promise when inNano is true 131 * @tc.size: MediumTest 132 * @tc.type: Function 133 * @tc.level: Level 1 134 * @tc.require: 135 */ 136 it('testGetCurrentTimeNs002', 0, async function (done) { 137 console.log("testGetCurrentTimeNs002 start"); 138 const nowTime = new Date().getTime(); 139 systemDateTime.getCurrentTime(true, (err, data) => { 140 if (err) { 141 expect(false).assertTrue(); 142 } 143 expect((data / NANO_TO_MILLI) >= nowTime).assertTrue(); 144 done(); 145 }) 146 console.log('testGetCurrentTimeNs002 end'); 147 }) 148 149 /** 150 * @tc.number: TestGetRealActiveTimeMs001 151 * @tc.name: TestGetRealActiveTimeMs001 152 * @tc.desc: test getRealActiveTime ms for promise. 153 * @tc.size: MediumTest 154 * @tc.type: Function 155 * @tc.level: Level 1 156 * @tc.require: 157 */ 158 it('testGetRealActiveTimeMs001', 0, async function (done) { 159 console.log("testGetRealActiveTimeMs001 start"); 160 const milliTime = await systemDateTime.getRealActiveTime(); 161 console.log('Get real active time is ' + milliTime); 162 expect(typeof (milliTime) === 'number' && milliTime / MILLI_TO_BASE > 0).assertTrue(); 163 console.log('testGetRealActiveTimeMs001 end'); 164 done(); 165 }) 166 167 /** 168 * @tc.number: TestGetRealActiveTimeMs002 169 * @tc.name: TestGetRealActiveTimeMs002 170 * @tc.desc: test getRealActiveTime ms for callback. 171 * @tc.size: MediumTest 172 * @tc.type: Function 173 * @tc.level: Level 1 174 * @tc.require: 175 */ 176 it('testGetRealActiveTimeMs002', 0, async function (done) { 177 console.log("testGetRealActiveTimeMs002 start"); 178 systemDateTime.getRealActiveTime((err, data) => { 179 if (err) { 180 expect(false).assertTrue(); 181 } 182 expect(typeof (data) === 'number' && (data / MILLI_TO_BASE) > 0).assertTrue(); 183 done(); 184 }) 185 console.log('testGetRealActiveTimeMs002 end'); 186 }) 187 188 /** 189 * @tc.number: TestGetRealActiveTimeMs003 190 * @tc.name: TestGetRealActiveTimeMs003 191 * @tc.desc: test getRealActiveTime ms for promise when isNano is false. 192 * @tc.size: MediumTest 193 * @tc.type: Function 194 * @tc.level: Level 1 195 * @tc.require: 196 */ 197 it('testGetRealActiveTimeMs003', 0, async function (done) { 198 console.log("testGetRealActiveTimeMs003 start"); 199 const milliTime = await systemDateTime.getRealActiveTime(false); 200 expect(typeof (milliTime) === 'number' && milliTime / MILLI_TO_BASE > 0).assertTrue(); 201 console.log('testGetRealActiveTimeMs003 end'); 202 done(); 203 }) 204 205 /** 206 * @tc.number: TestGetRealActiveTimeMs004 207 * @tc.name: TestGetRealActiveTimeMs004 208 * @tc.desc: test getRealActiveTime ms for callback when isNano is false. 209 * @tc.size: MediumTest 210 * @tc.type: Function 211 * @tc.level: Level 1 212 * @tc.require: 213 */ 214 it('testGetRealActiveTimeMs004', 0, async function (done) { 215 console.log("testGetRealActiveTimeMs004 start"); 216 systemDateTime.getRealActiveTime(false, (err, data) => { 217 if (err) { 218 expect(false).assertTrue(); 219 } 220 expect(typeof (data) === 'number' && (data / MILLI_TO_BASE) > 0).assertTrue(); 221 done(); 222 }) 223 console.log('testGetRealActiveTimeMs004 end'); 224 }) 225 226 /** 227 * @tc.number: TestGetRealActiveTimeNs001 228 * @tc.name: TestGetRealActiveTimeNs001 229 * @tc.desc: test getRealActiveTime ns for promise when isNano is true. 230 * @tc.size: MediumTest 231 * @tc.type: Function 232 * @tc.level: Level 1 233 * @tc.require: 234 */ 235 it('testGetRealActiveTimeNs001', 0, async function (done) { 236 console.log("testGetRealActiveTimeNs001 start"); 237 const nanoTime = await systemDateTime.getRealActiveTime(true); 238 console.log('Get real active nano time is ' + nanoTime); 239 expect(nanoTime / NANO_TO_BASE > 0).assertTrue(); 240 console.log('testGetRealActiveTimeNs001 end'); 241 done(); 242 }) 243 244 /** 245 * @tc.number: TestGetRealActiveTimeNs002 246 * @tc.name: TestGetRealActiveTimeNs002 247 * @tc.desc: test getRealActiveTime ns for callback when isNano is true. 248 * @tc.size: MediumTest 249 * @tc.type: Function 250 * @tc.level: Level 1 251 * @tc.require: 252 */ 253 it('testGetRealActiveTimeNs002', 0, async function (done) { 254 console.log("testGetRealActiveTimeNs002 start"); 255 systemDateTime.getRealActiveTime(true, (err, data) => { 256 if (err) { 257 expect(false).assertTrue(); 258 } 259 expect((data / MILLI_TO_BASE) > 0).assertTrue(); 260 done(); 261 }) 262 console.log('testGetRealActiveTimeNs002 end'); 263 }) 264 265 /** 266 * @tc.number: TestGetRealTimeMs001 267 * @tc.name: TestGetRealTimeMs001 268 * @tc.desc: test getRealTime ms for promise. 269 * @tc.size: MediumTest 270 * @tc.type: Function 271 * @tc.level: Level 1 272 * @tc.require: 273 */ 274 it('testGetRealTimeMs001', 0, async function (done) { 275 console.log("testGetRealTimeMs001 start"); 276 const milliTime = await systemDateTime.getRealTime(); 277 console.log('Get real time is ' + milliTime); 278 expect(typeof (milliTime) === 'number' && milliTime / MILLI_TO_BASE >= 0).assertTrue(); 279 console.log('testGetRealTimeMs001 end'); 280 done(); 281 }) 282 283 /** 284 * @tc.number: TestGetRealTimeMs002 285 * @tc.name: TestGetRealTimeMs002 286 * @tc.desc: test getRealTime ms for callback. 287 * @tc.size: MediumTest 288 * @tc.type: Function 289 * @tc.level: Level 1 290 * @tc.require: 291 */ 292 it('testGetRealTimeMs002', 0, async function (done) { 293 console.log("testGetRealTimeMs002 start"); 294 systemDateTime.getRealTime((err, data) => { 295 if (err) { 296 expect(false).assertTrue(); 297 } 298 expect(typeof (data) === 'number' && (data / MILLI_TO_BASE) > 0).assertTrue(); 299 done(); 300 }) 301 console.log('testGetRealTimeMs002 end'); 302 }) 303 304 /** 305 * @tc.number: TestGetRealTimeMs003 306 * @tc.name: TestGetRealTimeMs003 307 * @tc.desc: test getRealTime ms for promise when isNano is false. 308 * @tc.size: MediumTest 309 * @tc.type: Function 310 * @tc.level: Level 1 311 * @tc.require: 312 */ 313 it('testGetRealTimeMs003', 0, async function (done) { 314 console.log("testGetRealTimeMs003 start"); 315 const milliTime = await systemDateTime.getRealTime(false); 316 console.log('Get real time is ' + milliTime); 317 expect(typeof (milliTime) === 'number' && milliTime / MILLI_TO_BASE > 0).assertTrue(); 318 console.log('testGetRealTimeMs003 end'); 319 done(); 320 }) 321 322 /** 323 * @tc.number: TestGetRealTimeMs004 324 * @tc.name: TestGetRealTimeMs004 325 * @tc.desc: test getRealTime ms for callback when isNano is false. 326 * @tc.size: MediumTest 327 * @tc.type: Function 328 * @tc.level: Level 1 329 * @tc.require: 330 */ 331 it('testGetRealTimeMs004', 0, async function (done) { 332 console.log("testGetRealTimeMs004 start"); 333 systemDateTime.getRealTime(false, (err, data) => { 334 if (err) { 335 expect(false).assertTrue(); 336 } 337 expect(typeof (data) === 'number' && (data / MILLI_TO_BASE) > 0).assertTrue(); 338 done(); 339 }) 340 console.log('testGetRealTimeMs004 end'); 341 }) 342 343 /** 344 * @tc.number: TestGetRealTimeNs001 345 * @tc.name: TestGetRealTimeNs001 346 * @tc.desc: test getRealTime ns for promise when isNano is true. 347 * @tc.size: MediumTest 348 * @tc.type: Function 349 * @tc.level: Level 1 350 * @tc.require: 351 */ 352 it('testGetRealTimeNs001', 0, async function (done) { 353 console.log("testGetRealTimeNs001 start"); 354 const nanoTime = await systemDateTime.getRealTime(true); 355 console.log('Get real nano time is ' + nanoTime); 356 expect(nanoTime / NANO_TO_BASE > 0).assertTrue(); 357 console.log('testGetRealTimeNs001 end'); 358 done(); 359 }) 360 361 /** 362 * @tc.number: TestGetRealTimeNs002 363 * @tc.name: TestGetRealTimeNs002 364 * @tc.desc: test getRealTime ns for callback when isNano is true. 365 * @tc.size: MediumTest 366 * @tc.type: Function 367 * @tc.level: Level 1 368 * @tc.require: 369 */ 370 it('testGetRealTimeNs002', 0, async function (done) { 371 console.log("testGetRealTimeNs002 start"); 372 systemDateTime.getRealTime(true, (err, data) => { 373 if (err) { 374 expect(false).assertTrue(); 375 } 376 expect((data / MILLI_TO_BASE) > 0).assertTrue(); 377 done(); 378 }) 379 console.log('testGetRealTimeNs002 end'); 380 }) 381 382 /** 383 * @tc.number: TestGetDate001 384 * @tc.name: TestGetDate001 385 * @tc.desc: test getDate for promise. 386 * @tc.size: MediumTest 387 * @tc.type: Function 388 * @tc.level: Level 1 389 * @tc.require: 390 */ 391 it('testGetDate001', 0, async function (done) { 392 console.log("testGetDate001 start"); 393 let date = new Date(2022, 1, 1); 394 await systemDateTime.setDate(date); 395 const currentDate = await systemDateTime.getDate(); 396 expect(currentDate instanceof Date && currentDate.toDateString() === date.toDateString()).assertTrue(); 397 done(); 398 console.log('testGetDate001 end'); 399 }) 400 401 /** 402 * @tc.number: TestGetDate002 403 * @tc.name: TestGetDate002 404 * @tc.desc: test getDate for callback. 405 * @tc.size: MediumTest 406 * @tc.type: Function 407 * @tc.level: Level 1 408 * @tc.require: 409 */ 410 it('testGetDate002', 0, async function (done) { 411 console.log("testGetDate002 start"); 412 let date = new Date(2022, 1, 1); 413 await systemDateTime.setDate(date); 414 systemDateTime.getDate((err, data) => { 415 if (err) { 416 expect(false).assertTrue(); 417 } 418 expect(data instanceof Date && data.toDateString() === date.toDateString()).assertTrue(); 419 done(); 420 }) 421 console.log('testGetDate002 end'); 422 }) 423 424 /** 425 * @tc.number: TestGetCurrentTimeInvalidParam001 426 * @tc.name: TestGetCurrentTimeInvalidParam001 427 * @tc.desc: test getCurrentTime for promise with invalid param. 428 * @tc.size: MediumTest 429 * @tc.type: Function 430 * @tc.level: Level 1 431 * @tc.require: 432 */ 433 it('testGetCurrentTimeInvalidParam001', 0, async function (done) { 434 console.log("testGetCurrentTimeInvalidParam001 start"); 435 try { 436 systemDateTime.getCurrentTime("true").then((time) => { 437 expect(true).assertTrue(); 438 done(); 439 }); 440 } catch (err) { 441 expect(false).assertTrue(); 442 done(); 443 } 444 console.log('testGetCurrentTimeInvalidParam001 end'); 445 }) 446 447 /** 448 * @tc.number: TestGetCurrentTimeInvalidParam002 449 * @tc.name: TestGetCurrentTimeInvalidParam002 450 * @tc.desc: test getCurrentTime for callback with invalid param. 451 * @tc.size: MediumTest 452 * @tc.type: Function 453 * @tc.level: Level 1 454 * @tc.require: 455 */ 456 it('testGetCurrentTimeInvalidParam001', 0, async function (done) { 457 console.log("testGetCurrentTimeInvalidParam001 start"); 458 try { 459 systemDateTime.getCurrentTime("true", function (err) { 460 if (err) { 461 expect(false).assertTrue(); 462 } 463 expect(true).assertTrue(); 464 done(); 465 }); 466 } catch (err) { 467 expect(false).assertTrue(); 468 done(); 469 } 470 console.log('testGetCurrentTimeInvalidParam001 end'); 471 }) 472 473 /** 474 * @tc.number: TestGetCurrentTimeInvalidParam002 475 * @tc.name: TestGetCurrentTimeInvalidParam002 476 * @tc.desc: test getRealActiveTime for callback with invalid param. 477 * @tc.size: MediumTest 478 * @tc.type: Function 479 * @tc.level: Level 1 480 * @tc.require: 481 */ 482 it('testGetCurrentTimeInvalidParam002', 0, async function (done) { 483 console.log("testGetCurrentTimeInvalidParam002 start"); 484 try { 485 systemDateTime.getRealActiveTime("true").then((time) => { 486 expect(true).assertTrue(); 487 done(); 488 }); 489 } catch (err) { 490 expect(false).assertTrue(); 491 done(); 492 } 493 console.log('testGetCurrentTimeInvalidParam002 end'); 494 }) 495 496 /** 497 * @tc.number: TestGetRealActiveTimeInvalidParam001 498 * @tc.name: TestGetRealActiveTimeInvalidParam001 499 * @tc.desc: test getRealActiveTime for promise with invalid param. 500 * @tc.size: MediumTest 501 * @tc.type: Function 502 * @tc.level: Level 1 503 * @tc.require: 504 */ 505 it('testGetRealActiveTimeInvalidParam001', 0, async function (done) { 506 console.log("testGetRealActiveTimeInvalidParam001 start"); 507 try { 508 systemDateTime.getRealActiveTime("true", function (err) { 509 if (err) { 510 expect(false).assertTrue(); 511 } 512 expect(true).assertTrue(); 513 done(); 514 }); 515 } catch (err) { 516 expect(false).assertTrue(); 517 done(); 518 } 519 console.log('testGetRealActiveTimeInvalidParam001 end'); 520 }) 521 522 /** 523 * @tc.number: TestGetRealActiveTimeInvalidParam001 524 * @tc.name: TestGetRealActiveTimeInvalidParam001 525 * @tc.desc: test getRealTime for promise with invalid param. 526 * @tc.size: MediumTest 527 * @tc.type: Function 528 * @tc.level: Level 1 529 * @tc.require: 530 */ 531 it('testGetRealTimeInvalidParam001', 0, async function (done) { 532 console.log("testGetRealTimeInvalidParam001 start"); 533 try { 534 systemDateTime.getRealTime("true").then((time) => { 535 expect(true).assertTrue(); 536 done(); 537 }); 538 } catch (err) { 539 expect(false).assertTrue(); 540 done(); 541 } 542 console.log('testGetRealTimeInvalidParam001 end'); 543 }) 544 545 /** 546 * @tc.number: TestGetRealTimeInvalidParam002 547 * @tc.name: TestGetRealTimeInvalidParam002 548 * @tc.desc: test getRealTime for callback with invalid param. 549 * @tc.size: MediumTest 550 * @tc.type: Function 551 * @tc.level: Level 1 552 * @tc.require: 553 */ 554 it('testGetRealTimeInvalidParam002', 0, async function (done) { 555 console.log("testGetRealTimeInvalidParam002 start"); 556 try { 557 systemDateTime.getRealTime("true", function (err) { 558 if (err) { 559 expect(false).assertTrue(); 560 } 561 expect(true).assertTrue(); 562 done(); 563 }); 564 } catch (err) { 565 expect(false).assertTrue(); 566 done(); 567 } 568 console.log('testGetRealTimeInvalidParam002 end'); 569 }) 570 571 /** 572 * @tc.number: TestGetTimezone001 573 * @tc.name: TestGetTimezone001 574 * @tc.desc: test getTimezone for promise. 575 * @tc.size: MediumTest 576 * @tc.type: Function 577 * @tc.level: Level 1 578 * @tc.require: 579 */ 580 it('testGetTimezone001', 0, async function (done) { 581 console.log("testGetTimezone001 start"); 582 let timezone = "Pacific/Majuro"; 583 await systemDateTime.setTimezone(timezone); 584 const currentTimezone = await systemDateTime.getTimezone(); 585 expect(typeof (currentTimezone) == 'string' && timezone === currentTimezone).assertTrue(); 586 await systemDateTime.setTimezone('Asia/Shanghai'); 587 done(); 588 console.log('testGetTimezone001 end'); 589 }) 590 591 /** 592 * @tc.number: TestGetTimezone002 593 * @tc.name: TestGetTimezone002 594 * @tc.desc: test getTimezone for callback. 595 * @tc.size: MediumTest 596 * @tc.type: Function 597 * @tc.level: Level 1 598 * @tc.require: 599 */ 600 it('testGetTimezone002', 0, async function (done) { 601 console.log("testGetTimezone002 start"); 602 let timezone = "Pacific/Majuro"; 603 await systemDateTime.setTimezone(timezone); 604 systemDateTime.getTimezone((err, data) => { 605 if (err) { 606 expect(false).assertTrue(); 607 done(); 608 } 609 systemDateTime.setTimezone('Asia/Shanghai'); 610 expect(typeof(data) == 'string' && data === timezone).assertTrue(); 611 done(); 612 }) 613 console.log('testGetTimezone002 end'); 614 }) 615 616 /** 617 * @tc.number: TestGetTime001 618 * @tc.name: TestGetTime001 619 * @tc.desc: test getTime ms. 620 * @tc.size: MediumTest 621 * @tc.type: Function 622 * @tc.level: Level 1 623 * @tc.require: 624 */ 625 it('testGetTime001', 0, function (done) { 626 console.log("testGetTime001 start"); 627 const nowTime = new Date().getTime(); 628 const time = systemDateTime.getTime(true); 629 console.log('Get current time is ' + time); 630 expect(typeof (time) === 'number' && time >= nowTime).assertTrue(); 631 expect(time.toString().length-6===nowTime.toString().length ).assertTrue(); 632 console.log('testGetTime001 end'); 633 done(); 634 }) 635 636 /** 637 * @tc.number: TestGetTime002 638 * @tc.name: TestGetTime002 639 * @tc.desc: test getTime ns. 640 * @tc.size: MediumTest 641 * @tc.type: Function 642 * @tc.level: Level 1 643 * @tc.require: 644 */ 645 it('testGetTime002', 0, function (done) { 646 console.log("testGetTime002 start"); 647 const nowTime = new Date().getTime(); 648 const time = systemDateTime.getTime(false); 649 console.log('Get current time is ' + time); 650 expect(typeof (time) === 'number' && time >= nowTime).assertTrue(); 651 expect(time.toString().length===nowTime.toString().length ).assertTrue(); 652 console.log('testGetTime002 end'); 653 done(); 654 }) 655 656 /** 657 * @tc.number: TestGetTime003 658 * @tc.name: TestGetTime003 659 * @tc.desc: test getTime with Default parameter. 660 * @tc.size: MediumTest 661 * @tc.type: Function 662 * @tc.level: Level 1 663 * @tc.require: 664 */ 665 it('testGetTime003', 0, function (done) { 666 console.log("testGetTime003 start"); 667 const nowTime = new Date().getTime(); 668 const time1 = systemDateTime.getTime(); 669 const time2 = systemDateTime.getTime(123); 670 const time3 = systemDateTime.getTime("true"); 671 console.log('Get current time1 is:' + time1+' time2 is:'+time2+' time3 is:'+time3); 672 expect(typeof (time1) === 'number' && time1 >= nowTime).assertTrue(); 673 expect(time1.toString().length===nowTime.toString().length ).assertTrue(); 674 expect(typeof (time2) === 'number' && time2 >= nowTime).assertTrue(); 675 expect(time2.toString().length===nowTime.toString().length ).assertTrue(); 676 expect(typeof (time3) === 'number' && time3 >= nowTime).assertTrue(); 677 expect(time3.toString().length===nowTime.toString().length ).assertTrue(); 678 console.log('testGetTime003 end'); 679 done(); 680 }) 681 682 683 /** 684 * @tc.number: TestGetUptime001 685 * @tc.name: TestGetUptime001 686 * @tc.desc: test getUptime ms for STARTUP. 687 * @tc.size: MediumTest 688 * @tc.type: Function 689 * @tc.level: Level 1 690 * @tc.require: 691 */ 692 it('testGetUptime001', 0, function (done) { 693 console.log("testGetUptime001 start"); 694 const time = systemDateTime.getUptime(systemDateTime.TimeType.STARTUP, false); 695 console.log('get uptime time is ' + time); 696 expect(typeof (time) === 'number' && time / MILLI_TO_BASE > 0).assertTrue(); 697 console.log('testGetUptime001 end'); 698 done(); 699 }) 700 701 /** 702 * @tc.number: TestGetUptime002 703 * @tc.name: TestGetUptime002 704 * @tc.desc: test getUptime ms for STARTUP. 705 * @tc.size: MediumTest 706 * @tc.type: Function 707 * @tc.level: Level 1 708 * @tc.require: 709 */ 710 it('TestGetUptime002', 0, function (done) { 711 console.log("testGetUptime002 start"); 712 const time = systemDateTime.getUptime(systemDateTime.TimeType.STARTUP); 713 console.log('get uptime time is ' + time); 714 expect(typeof (time) === 'number' && time / MILLI_TO_BASE > 0).assertTrue(); 715 console.log('testGetUptime002 end'); 716 done(); 717 }) 718 719 /** 720 * @tc.number: TestGetUptime003 721 * @tc.name: TestGetUptime003 722 * @tc.desc: test getUptime ns for STARTUP. 723 * @tc.size: MediumTest 724 * @tc.type: Function 725 * @tc.level: Level 1 726 * @tc.require: 727 */ 728 it('testGetUptime003', 0, function (done) { 729 console.log("testGetUptime003 start"); 730 const time = systemDateTime.getUptime(systemDateTime.TimeType.STARTUP, true); 731 console.log('get uptime time is ' + time); 732 expect(typeof (time) === 'number' && time / NANO_TO_BASE > 0).assertTrue(); 733 console.log('testGetUptime003 end'); 734 done(); 735 }) 736 737 /** 738 * @tc.number: TestGetUptime004 739 * @tc.name: TestGetUptime004 740 * @tc.desc: test getUptime ms for ACTIVE. 741 * @tc.size: MediumTest 742 * @tc.type: Function 743 * @tc.level: Level 1 744 * @tc.require: 745 */ 746 it('testGetUptime004', 0, function (done) { 747 console.log("testGetUptime004 start"); 748 const time = systemDateTime.getUptime(systemDateTime.TimeType.ACTIVE, false); 749 console.log('get uptime time is ' + time); 750 expect(typeof (time) === 'number' && time / MILLI_TO_BASE > 0).assertTrue(); 751 console.log('testGetUptime004 end'); 752 done(); 753 }) 754 755 /** 756 * @tc.number: TestGetUptime005 757 * @tc.name: TestGetUptime005 758 * @tc.desc: test getUptime ms for ACTIVE. 759 * @tc.size: MediumTest 760 * @tc.type: Function 761 * @tc.level: Level 1 762 * @tc.require: 763 */ 764 it('TestGetUptime005', 0, function (done) { 765 console.log("testGetUptime005 start"); 766 const time = systemDateTime.getUptime(systemDateTime.TimeType.ACTIVE); 767 console.log('get uptime time is ' + time); 768 expect(typeof (time) === 'number' && time / MILLI_TO_BASE > 0).assertTrue(); 769 console.log('testGetUptime005 end'); 770 done(); 771 }) 772 773 /** 774 * @tc.number: TestGetUptime006 775 * @tc.name: TestGetUptime006 776 * @tc.desc: test getUptime ns for ACTIVE. 777 * @tc.size: MediumTest 778 * @tc.type: Function 779 * @tc.level: Level 1 780 * @tc.require: 781 */ 782 it('testGetUptime006', 0, function (done) { 783 console.log("testGetUptime006 start"); 784 const time = systemDateTime.getUptime(systemDateTime.TimeType.ACTIVE, true); 785 console.log('get uptime time is ' + time); 786 expect(typeof (time) === 'number' && time / NANO_TO_BASE > 0).assertTrue(); 787 console.log('testGetUptime006 end'); 788 done(); 789 }) 790 791 /** 792 * @tc.number: TestGetUptime007 793 * @tc.name: TestGetUptime007 794 * @tc.desc: test getUptime ms for invalid type. 795 * @tc.size: MediumTest 796 * @tc.type: Function 797 * @tc.level: Level 1 798 * @tc.require: 799 */ 800 it('testGetUptime007', 0, function (done) { 801 console.log("testGetUptime007 start"); 802 try { 803 systemDateTime.getUptime(2); 804 } catch (err) { 805 expect(err.code).assertEqual(401) 806 done(); 807 } 808 console.log('testGetUptime007 end'); 809 }) 810 811 /** 812 * @tc.number: TestGetTimezoneSync001 813 * @tc.name: TestGetTimezoneSync001 814 * @tc.desc: test getTimezoneSync. 815 * @tc.size: MediumTest 816 * @tc.type: Function 817 * @tc.level: Level 1 818 * @tc.require: 819 */ 820 it('testGetTimezoneSync001', 0, async function (done) { 821 console.log("testGetTimezoneSync001 start"); 822 let timezone = "Pacific/Majuro"; 823 await systemDateTime.setTimezone(timezone); 824 const currentTimezone = systemDateTime.getTimezoneSync(); 825 expect(typeof (currentTimezone) == 'string' && timezone === currentTimezone).assertTrue(); 826 await systemDateTime.setTimezone('Asia/Shanghai'); 827 done(); 828 console.log('testGetTimezoneSync001 end'); 829 }) 830 831 /** 832 * @tc.number: TestUpdateAndGetNtpTime001 833 * @tc.name: TestUpdateAndGetNtpTime001 834 * @tc.desc: test getNtpTime. 835 * @tc.size: MediumTest 836 * @tc.type: Function 837 * @tc.level: Level 1 838 * @tc.require: 839 */ 840 it('testUpdateAndGetNtpTime001', 0, async function (done) { 841 console.log("testUpdateAndGetNtpTime001 start"); 842 try { 843 systemDateTime.getNtpTime(); 844 } catch (err) { 845 expect(err.code).assertEqual(13000002); 846 done(); 847 } 848 const nowTime = new Date().getTime(); 849 await systemDateTime.updateNtpTime(); 850 const milliTime = systemDateTime.getNtpTime(); 851 console.log('Get ntp time is ' + milliTime); 852 expect(typeof (milliTime) === 'number' && milliTime >= nowTime).assertTrue(); 853 console.log('testUpdateAndGetNtpTime001 end'); 854 done(); 855 }) 856})