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        console.log('testGetTime001 end');
632        done();
633    })
634
635    /**
636     * @tc.number: TestGetTime002
637     * @tc.name: TestGetTime002
638     * @tc.desc: test getTime ns.
639     * @tc.size: MediumTest
640     * @tc.type: Function
641     * @tc.level: Level 1
642     * @tc.require:
643     */
644    it('testGetTime002', 0, function (done) {
645        console.log("testGetTime002 start");
646        const nowTime = new Date().getTime();
647        const time = systemDateTime.getTime(false);
648        console.log('Get current time is ' + time);
649        expect(typeof (time) === 'number' && time >= nowTime).assertTrue();
650        console.log('testGetTime002 end');
651        done();
652    })
653
654    /**
655     * @tc.number: TestGetUptime001
656     * @tc.name: TestGetUptime001
657     * @tc.desc: test getUptime ms for STARTUP.
658     * @tc.size: MediumTest
659     * @tc.type: Function
660     * @tc.level: Level 1
661     * @tc.require:
662     */
663    it('testGetUptime001', 0,  function (done) {
664        console.log("testGetUptime001 start");
665        const time = systemDateTime.getUptime(systemDateTime.TimeType.STARTUP, false);
666        console.log('get uptime time is ' + time);
667        expect(typeof (time) === 'number' && time / MILLI_TO_BASE > 0).assertTrue();
668        console.log('testGetUptime001 end');
669        done();
670    })
671
672    /**
673     * @tc.number: TestGetUptime002
674     * @tc.name: TestGetUptime002
675     * @tc.desc: test getUptime ms for STARTUP.
676     * @tc.size: MediumTest
677     * @tc.type: Function
678     * @tc.level: Level 1
679     * @tc.require:
680     */
681    it('TestGetUptime002', 0,  function (done) {
682        console.log("testGetUptime002 start");
683        const time = systemDateTime.getUptime(systemDateTime.TimeType.STARTUP);
684        console.log('get uptime time is ' + time);
685        expect(typeof (time) === 'number' && time / MILLI_TO_BASE > 0).assertTrue();
686        console.log('testGetUptime002 end');
687        done();
688    })
689
690    /**
691     * @tc.number: TestGetUptime003
692     * @tc.name: TestGetUptime003
693     * @tc.desc: test getUptime ns for STARTUP.
694     * @tc.size: MediumTest
695     * @tc.type: Function
696     * @tc.level: Level 1
697     * @tc.require:
698     */
699    it('testGetUptime003', 0,  function (done) {
700        console.log("testGetUptime003 start");
701        const time = systemDateTime.getUptime(systemDateTime.TimeType.STARTUP, true);
702        console.log('get uptime time is ' + time);
703        expect(typeof (time) === 'number' && time / NANO_TO_BASE > 0).assertTrue();
704        console.log('testGetUptime003 end');
705        done();
706    })
707
708    /**
709     * @tc.number: TestGetUptime004
710     * @tc.name: TestGetUptime004
711     * @tc.desc: test getUptime ms for ACTIVE.
712     * @tc.size: MediumTest
713     * @tc.type: Function
714     * @tc.level: Level 1
715     * @tc.require:
716     */
717    it('testGetUptime004', 0,  function (done) {
718        console.log("testGetUptime004 start");
719        const time = systemDateTime.getUptime(systemDateTime.TimeType.ACTIVE, false);
720        console.log('get uptime time is ' + time);
721        expect(typeof (time) === 'number' && time / MILLI_TO_BASE > 0).assertTrue();
722        console.log('testGetUptime004 end');
723        done();
724    })
725
726    /**
727     * @tc.number: TestGetUptime005
728     * @tc.name: TestGetUptime005
729     * @tc.desc: test getUptime ms for ACTIVE.
730     * @tc.size: MediumTest
731     * @tc.type: Function
732     * @tc.level: Level 1
733     * @tc.require:
734     */
735    it('TestGetUptime005', 0,  function (done) {
736        console.log("testGetUptime005 start");
737        const time = systemDateTime.getUptime(systemDateTime.TimeType.ACTIVE);
738        console.log('get uptime time is ' + time);
739        expect(typeof (time) === 'number' && time / MILLI_TO_BASE > 0).assertTrue();
740        console.log('testGetUptime005 end');
741        done();
742    })
743
744    /**
745     * @tc.number: TestGetUptime006
746     * @tc.name: TestGetUptime006
747     * @tc.desc: test getUptime ns for ACTIVE.
748     * @tc.size: MediumTest
749     * @tc.type: Function
750     * @tc.level: Level 1
751     * @tc.require:
752     */
753    it('testGetUptime006', 0,  function (done) {
754        console.log("testGetUptime006 start");
755        const time = systemDateTime.getUptime(systemDateTime.TimeType.ACTIVE, true);
756        console.log('get uptime time is ' + time);
757        expect(typeof (time) === 'number' && time / NANO_TO_BASE > 0).assertTrue();
758        console.log('testGetUptime006 end');
759        done();
760    })
761
762    /**
763     * @tc.number: TestGetUptime007
764     * @tc.name: TestGetUptime007
765     * @tc.desc: test getUptime ms for invalid type.
766     * @tc.size: MediumTest
767     * @tc.type: Function
768     * @tc.level: Level 1
769     * @tc.require:
770     */
771    it('testGetUptime007', 0,  function (done) {
772        console.log("testGetUptime007 start");
773        try {
774            systemDateTime.getUptime(2);
775        } catch (err) {
776            expect(err.code).assertEqual(401)
777            done();
778        }
779        console.log('testGetUptime007 end');
780    })
781
782    /**
783     * @tc.number: TestGetTimezoneSync001
784     * @tc.name: TestGetTimezoneSync001
785     * @tc.desc: test getTimezoneSync.
786     * @tc.size: MediumTest
787     * @tc.type: Function
788     * @tc.level: Level 1
789     * @tc.require:
790     */
791    it('testGetTimezoneSync001', 0, async function (done) {
792        console.log("testGetTimezoneSync001 start");
793        let timezone = "Pacific/Majuro";
794        await systemDateTime.setTimezone(timezone);
795        const currentTimezone = systemDateTime.getTimezoneSync();
796        expect(typeof (currentTimezone) == 'string' && timezone === currentTimezone).assertTrue();
797        await systemDateTime.setTimezone('Asia/Shanghai');
798        done();
799        console.log('testGetTimezoneSync001 end');
800    })
801
802    /**
803     * @tc.number: TestUpdateAndGetNtpTime001
804     * @tc.name: TestUpdateAndGetNtpTime001
805     * @tc.desc: test getNtpTime.
806     * @tc.size: MediumTest
807     * @tc.type: Function
808     * @tc.level: Level 1
809     * @tc.require:
810     */
811    it('testUpdateAndGetNtpTime001', 0, async function (done) {
812        console.log("testUpdateAndGetNtpTime001 start");
813        try {
814            systemDateTime.getNtpTime();
815        } catch (err) {
816            expect(err.code).assertEqual(13000002);
817        }
818        const nowTime = new Date().getTime();
819        await systemDateTime.updateNtpTime();
820        const milliTime = systemDateTime.getNtpTime();
821        console.log('Get ntp time is ' + milliTime);
822        expect(typeof (milliTime) === 'number' && milliTime >= nowTime).assertTrue();
823        console.log('testUpdateAndGetNtpTime001 end');
824        done();
825    })
826})