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 systemTime from '@ohos.systemTime'
19
20describe('SystemTimeGetTest', 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.name: TestGetCurrentTimeMs001
27     * @tc.desc: test getCurrentTime ms for promise.
28     * @tc.size: MediumTest
29     * @tc.type: Function
30     * @tc.level: Level 1
31     * @tc.require:
32     */
33    it('testGetCurrentTimeMs001', 0, async function (done) {
34        console.log("testGetCurrentTimeMs001 start");
35        const nowTime = new Date().getTime();
36        const milliTime = await systemTime.getCurrentTime();
37        console.log('Get current time is ' + milliTime);
38        expect(typeof (milliTime) === 'number' && milliTime >= nowTime).assertTrue();
39        console.log('testGetCurrentTimeMs001 end');
40        done();
41    })
42
43    /**
44     * @tc.name: TestGetCurrentTimeMs002
45     * @tc.desc: test getCurrentTime ms for callback.
46     * @tc.size: MediumTest
47     * @tc.type: Function
48     * @tc.level: Level 1
49     * @tc.require:
50     */
51    it('testGetCurrentTimeMs002', 0, async function (done) {
52        console.log("testGetCurrentTimeMs002 start");
53        const nowTime = new Date().getTime();
54        systemTime.getCurrentTime((err, data) => {
55            if (err) {
56                expect(false).assertTrue();
57            }
58            expect(typeof (data) === 'number' && data >= nowTime).assertTrue();
59            done();
60        })
61        console.log('testGetCurrentTimeMs002 end');
62    })
63
64    /**
65     * @tc.name: TestGetCurrentTimeMs003
66     * @tc.desc: test getCurrentTime ms for promise when isNano is false.
67     * @tc.size: MediumTest
68     * @tc.type: Function
69     * @tc.level: Level 1
70     * @tc.require:
71     */
72    it('testGetCurrentTimeMs003', 0, async function (done) {
73        console.log("testGetCurrentTimeMs003 start");
74        const nowTime = new Date().getTime();
75        const milliTime = await systemTime.getCurrentTime(false);
76        console.log('Get current time is ' + milliTime);
77        expect(milliTime >= nowTime && typeof (milliTime) === 'number').assertTrue();
78        console.log('testGetCurrentTimeMs003 end');
79        done();
80    })
81
82    /**
83     * @tc.name: TestGetCurrentTimeMs004
84     * @tc.desc: test getCurrentTime ms for callback when isNano is false.
85     * @tc.size: MediumTest
86     * @tc.type: Function
87     * @tc.level: Level 1
88     * @tc.require:
89     */
90    it('testGetCurrentTimeMs004', 0, async function (done) {
91        console.log("testGetCurrentTimeMs004 start");
92        const nowTime = new Date().getTime();
93        systemTime.getCurrentTime(false, (err, data) => {
94            if (err) {
95                expect(false).assertTrue();
96            }
97            expect(typeof (data) === 'number' && data >= nowTime).assertTrue();
98            done();
99        });
100        console.log('testGetCurrentTimeMs004 end');
101    })
102
103    /**
104     * @tc.name: TestGetCurrentTimeNs001
105     * @tc.desc: test getCurrentTime ns for promise when inNano is true
106     * @tc.size: MediumTest
107     * @tc.type: Function
108     * @tc.level: Level 1
109     * @tc.require:
110     */
111    it('testGetCurrentTimeNs001', 0, async function (done) {
112        console.log("testGetCurrentTimeNs001 start");
113        const nowTime = new Date().getTime();
114        const nanoTime = await systemTime.getCurrentTime(true);
115        console.log('Get current nano time is ' + nanoTime);
116        const milliTime = nanoTime / NANO_TO_MILLI;
117        expect(milliTime >= nowTime).assertTrue();
118        console.log('testGetCurrentTimeNs001 end');
119        done();
120    })
121
122    /**
123     * @tc.name: TestGetCurrentTimeNs002
124     * @tc.desc: test getCurrentTime ns for promise when inNano is true
125     * @tc.size: MediumTest
126     * @tc.type: Function
127     * @tc.level: Level 1
128     * @tc.require:
129     */
130    it('testGetCurrentTimeNs002', 0, async function (done) {
131        console.log("testGetCurrentTimeNs002 start");
132        const nowTime = new Date().getTime();
133        systemTime.getCurrentTime(true, (err, data) => {
134            if (err) {
135                expect(false).assertTrue();
136            }
137            expect((data / NANO_TO_MILLI) >= nowTime).assertTrue();
138            done();
139        })
140        console.log('testGetCurrentTimeNs002 end');
141    })
142
143    /**
144     * @tc.name: TestGetRealActiveTimeMs001
145     * @tc.desc: test getRealActiveTime ms for promise.
146     * @tc.size: MediumTest
147     * @tc.type: Function
148     * @tc.level: Level 1
149     * @tc.require:
150     */
151    it('testGetRealActiveTimeMs001', 0, async function (done) {
152        console.log("testGetRealActiveTimeMs001 start");
153        const milliTime = await systemTime.getRealActiveTime();
154        console.log('Get real active time is ' + milliTime);
155        expect(typeof (milliTime) === 'number' && milliTime / MILLI_TO_BASE > 0).assertTrue();
156        console.log('testGetRealActiveTimeMs001 end');
157        done();
158    })
159
160    /**
161     * @tc.name: TestGetRealActiveTimeMs002
162     * @tc.desc: test getRealActiveTime ms for callback.
163     * @tc.size: MediumTest
164     * @tc.type: Function
165     * @tc.level: Level 1
166     * @tc.require:
167     */
168    it('testGetRealActiveTimeMs002', 0, async function (done) {
169        console.log("testGetRealActiveTimeMs002 start");
170        systemTime.getRealActiveTime((err, data) => {
171            if (err) {
172                expect(false).assertTrue();
173            }
174            expect(typeof (data) === 'number' && (data / MILLI_TO_BASE) > 0).assertTrue();
175            done();
176        })
177        console.log('testGetRealActiveTimeMs002 end');
178    })
179
180    /**
181     * @tc.name: TestGetRealActiveTimeMs003
182     * @tc.desc: test getRealActiveTime ms for promise when isNano is false.
183     * @tc.size: MediumTest
184     * @tc.type: Function
185     * @tc.level: Level 1
186     * @tc.require:
187     */
188    it('testGetRealActiveTimeMs003', 0, async function (done) {
189        console.log("testGetRealActiveTimeMs003 start");
190        const milliTime = await systemTime.getRealActiveTime(false);
191        expect(typeof (milliTime) === 'number' && milliTime / MILLI_TO_BASE > 0).assertTrue();
192        console.log('testGetRealActiveTimeMs003 end');
193        done();
194    })
195
196    /**
197     * @tc.name: TestGetRealActiveTimeMs004
198     * @tc.desc: test getRealActiveTime ms for callback when isNano is false.
199     * @tc.size: MediumTest
200     * @tc.type: Function
201     * @tc.level: Level 1
202     * @tc.require:
203     */
204    it('testGetRealActiveTimeMs004', 0, async function (done) {
205        console.log("testGetRealActiveTimeMs004 start");
206        systemTime.getRealActiveTime(false, (err, data) => {
207            if (err) {
208                expect(false).assertTrue();
209            }
210            expect(typeof (data) === 'number' && (data / MILLI_TO_BASE) > 0).assertTrue();
211            done();
212        })
213        console.log('testGetRealActiveTimeMs004 end');
214    })
215
216    /**
217     * @tc.name: TestGetRealActiveTimeNs001
218     * @tc.desc: test getRealActiveTime ns for promise when isNano is true.
219     * @tc.size: MediumTest
220     * @tc.type: Function
221     * @tc.level: Level 1
222     * @tc.require:
223     */
224    it('testGetRealActiveTimeNs001', 0, async function (done) {
225        console.log("testGetRealActiveTimeNs001 start");
226        const nanoTime = await systemTime.getRealActiveTime(true);
227        console.log('Get real active nano time is ' + nanoTime);
228        expect(nanoTime / NANO_TO_BASE > 0).assertTrue();
229        console.log('testGetRealActiveTimeNs001 end');
230        done();
231    })
232
233    /**
234     * @tc.name: TestGetRealActiveTimeNs002
235     * @tc.desc: test getRealActiveTime ns for callback when isNano is true.
236     * @tc.size: MediumTest
237     * @tc.type: Function
238     * @tc.level: Level 1
239     * @tc.require:
240     */
241    it('testGetRealActiveTimeNs002', 0, async function (done) {
242        console.log("testGetRealActiveTimeNs002 start");
243        systemTime.getRealActiveTime(true, (err, data) => {
244            if (err) {
245                expect(false).assertTrue();
246            }
247            expect((data / MILLI_TO_BASE) > 0).assertTrue();
248            done();
249        })
250        console.log('testGetRealActiveTimeNs002 end');
251    })
252
253    /**
254     * @tc.name: TestGetRealTimeMs001
255     * @tc.desc: test getRealTime ms for promise.
256     * @tc.size: MediumTest
257     * @tc.type: Function
258     * @tc.level: Level 1
259     * @tc.require:
260     */
261    it('testGetRealTimeMs001', 0, async function (done) {
262        console.log("testGetRealTimeMs001 start");
263        const milliTime = await systemTime.getRealTime();
264        console.log('Get real time is ' + milliTime);
265        expect(typeof (milliTime) === 'number' && milliTime / MILLI_TO_BASE >= 0).assertTrue();
266        console.log('testGetRealTimeMs001 end');
267        done();
268    })
269
270    /**
271     * @tc.name: TestGetRealTimeMs002
272     * @tc.desc: test getRealTime ms for callback.
273     * @tc.size: MediumTest
274     * @tc.type: Function
275     * @tc.level: Level 1
276     * @tc.require:
277     */
278    it('testGetRealTimeMs002', 0, async function (done) {
279        console.log("testGetRealTimeMs002 start");
280        systemTime.getRealTime((err, data) => {
281            if (err) {
282                expect(false).assertTrue();
283            }
284            expect(typeof (data) === 'number' && (data / MILLI_TO_BASE) > 0).assertTrue();
285            done();
286        })
287        console.log('testGetRealTimeMs002 end');
288    })
289
290    /**
291     * @tc.name: TestGetRealTimeMs003
292     * @tc.desc: test getRealTime ms for promise when isNano is false.
293     * @tc.size: MediumTest
294     * @tc.type: Function
295     * @tc.level: Level 1
296     * @tc.require:
297     */
298    it('testGetRealTimeMs003', 0, async function (done) {
299        console.log("testGetRealTimeMs003 start");
300        const milliTime = await systemTime.getRealTime(false);
301        console.log('Get real time is ' + milliTime);
302        expect(typeof (milliTime) === 'number' && milliTime / MILLI_TO_BASE > 0).assertTrue();
303        console.log('testGetRealTimeMs003 end');
304        done();
305    })
306
307    /**
308     * @tc.name: TestGetRealTimeMs004
309     * @tc.desc: test getRealTime ms for callback when isNano is false.
310     * @tc.size: MediumTest
311     * @tc.type: Function
312     * @tc.level: Level 1
313     * @tc.require:
314     */
315    it('testGetRealTimeMs004', 0, async function (done) {
316        console.log("testGetRealTimeMs004 start");
317        systemTime.getRealTime(false, (err, data) => {
318            if (err) {
319                expect(false).assertTrue();
320            }
321            expect(typeof (data) === 'number' && (data / MILLI_TO_BASE) > 0).assertTrue();
322            done();
323        })
324        console.log('testGetRealTimeMs004 end');
325    })
326
327    /**
328     * @tc.name: TestGetRealTimeNs001
329     * @tc.desc: test getRealTime ns for promise when isNano is true.
330     * @tc.size: MediumTest
331     * @tc.type: Function
332     * @tc.level: Level 1
333     * @tc.require:
334     */
335    it('testGetRealTimeNs001', 0, async function (done) {
336        console.log("testGetRealTimeNs001 start");
337        const nanoTime = await systemTime.getRealTime(true);
338        console.log('Get real nano time is ' + nanoTime);
339        expect(nanoTime / NANO_TO_BASE > 0).assertTrue();
340        console.log('testGetRealTimeNs001 end');
341        done();
342    })
343
344    /**
345     * @tc.name: TestGetRealTimeNs002
346     * @tc.desc: test getRealTime ns for callback when isNano is true.
347     * @tc.size: MediumTest
348     * @tc.type: Function
349     * @tc.level: Level 1
350     * @tc.require:
351     */
352    it('testGetRealTimeNs002', 0, async function (done) {
353        console.log("testGetRealTimeNs002 start");
354        systemTime.getRealTime(true, (err, data) => {
355            if (err) {
356                expect(false).assertTrue();
357            }
358            expect((data / MILLI_TO_BASE) > 0).assertTrue();
359            done();
360        })
361        console.log('testGetRealTimeNs002 end');
362    })
363
364    /**
365     * @tc.name: TestGetDate001
366     * @tc.desc: test getDate for promise.
367     * @tc.size: MediumTest
368     * @tc.type: Function
369     * @tc.level: Level 1
370     * @tc.require:
371     */
372    it('testGetDate001', 0, async function (done) {
373        console.log("testGetDate001 start");
374        let date = new Date(2022, 1, 1);
375        await systemTime.setDate(date);
376        const currentDate = await systemTime.getDate();
377        expect(currentDate instanceof Date && currentDate.toDateString() === date.toDateString()).assertTrue();
378        done();
379        console.log('testGetDate001 end');
380    })
381
382    /**
383     * @tc.name: TestGetDate002
384     * @tc.desc: test getDate for callback.
385     * @tc.size: MediumTest
386     * @tc.type: Function
387     * @tc.level: Level 1
388     * @tc.require:
389     */
390    it('testGetDate002', 0, async function (done) {
391        console.log("testGetDate002 start");
392        let date = new Date(2022, 1, 1);
393        await systemTime.setDate(date);
394        systemTime.getDate((err, data) => {
395            if (err) {
396                expect(false).assertTrue();
397            }
398            expect(data instanceof Date && data.toDateString() === date.toDateString()).assertTrue();
399            done();
400        })
401        console.log('testGetDate002 end');
402    })
403
404    /**
405     * @tc.name: TestGetCurrentTimeInvalidParam001
406     * @tc.desc: test getCurrentTime for promise with invalid param.
407     * @tc.size: MediumTest
408     * @tc.type: Function
409     * @tc.level: Level 1
410     * @tc.require:
411     */
412    it('testGetCurrentTimeInvalidParam001', 0, async function (done) {
413        console.log("testGetCurrentTimeInvalidParam001 start");
414        try {
415            systemTime.getCurrentTime("true").then((time) => {
416                expect(true).assertTrue();
417                done();
418            });
419        } catch (err) {
420            expect(false).assertTrue();
421            done();
422        }
423        console.log('testGetCurrentTimeInvalidParam001 end');
424    })
425
426    /**
427     * @tc.name: TestGetCurrentTimeInvalidParam002
428     * @tc.desc: test getCurrentTime for callback with invalid param.
429     * @tc.size: MediumTest
430     * @tc.type: Function
431     * @tc.level: Level 1
432     * @tc.require:
433     */
434    it('testGetCurrentTimeInvalidParam002', 0, async function (done) {
435        console.log("testGetCurrentTimeInvalidParam002 start");
436        try {
437            systemTime.getCurrentTime("true", function (err) {
438                if (err) {
439                    expect(false).assertTrue();
440                }
441                expect(true).assertTrue();
442                done();
443            });
444        } catch (err) {
445            expect(false).assertTrue();
446            done();
447        }
448        console.log('testGetCurrentTimeInvalidParam002 end');
449    })
450
451    /**
452     * @tc.name: TestGetCurrentTimeInvalidParam002
453     * @tc.desc: test getRealActiveTime for callback with invalid param.
454     * @tc.size: MediumTest
455     * @tc.type: Function
456     * @tc.level: Level 1
457     * @tc.require:
458     */
459    it('testGetCurrentTimeInvalidParam002', 0, async function (done) {
460        console.log("testGetCurrentTimeInvalidParam002 start");
461        try {
462            systemTime.getRealActiveTime("true").then((time) => {
463                expect(true).assertTrue();
464                done();
465            });
466        } catch (err) {
467            expect(false).assertTrue();
468            done();
469        }
470        console.log('testGetCurrentTimeInvalidParam002 end');
471    })
472
473    /**
474     * @tc.name: TestGetRealActiveTimeInvalidParam001
475     * @tc.desc: test getRealActiveTime for promise with invalid param.
476     * @tc.size: MediumTest
477     * @tc.type: Function
478     * @tc.level: Level 1
479     * @tc.require:
480     */
481    it('testGetRealActiveTimeInvalidParam001', 0, async function (done) {
482        console.log("testGetRealActiveTimeInvalidParam001 start");
483        try {
484            systemTime.getRealActiveTime("true", function (err) {
485                if (err) {
486                    expect(false).assertTrue();
487                }
488                expect(true).assertTrue();
489                done();
490            });
491        } catch (err) {
492            expect(false).assertTrue();
493            done();
494        }
495        console.log('testGetRealActiveTimeInvalidParam001 end');
496    })
497
498    /**
499     * @tc.name: TestGetRealActiveTimeInvalidParam001
500     * @tc.desc: test getRealTime for promise with invalid param.
501     * @tc.size: MediumTest
502     * @tc.type: Function
503     * @tc.level: Level 1
504     * @tc.require:
505     */
506    it('testGetRealTimeInvalidParam001', 0, async function (done) {
507        console.log("testGetRealTimeInvalidParam001 start");
508        try {
509            systemTime.getRealTime("true").then((time) => {
510                expect(true).assertTrue();
511                done();
512            });
513        } catch (err) {
514            expect(false).assertTrue();
515            done();
516        }
517        console.log('testGetRealTimeInvalidParam001 end');
518    })
519
520    /**
521     * @tc.name: TestGetRealTimeInvalidParam002
522     * @tc.desc: test getRealTime for callback with invalid param.
523     * @tc.size: MediumTest
524     * @tc.type: Function
525     * @tc.level: Level 1
526     * @tc.require:
527     */
528    it('testGetRealTimeInvalidParam002', 0, async function (done) {
529        console.log("testGetRealTimeInvalidParam002 start");
530        try {
531            systemTime.getRealTime("true", function (err) {
532                if (err) {
533                    expect(false).assertTrue();
534                }
535                expect(true).assertTrue();
536                done();
537            });
538        } catch (err) {
539            expect(false).assertTrue();
540            done();
541        }
542        console.log('testGetRealTimeInvalidParam002 end');
543    })
544
545    /**
546     * @tc.name: TestGetTimezone001
547     * @tc.desc: test getTimezone for promise.
548     * @tc.size: MediumTest
549     * @tc.type: Function
550     * @tc.level: Level 1
551     * @tc.require:
552     */
553    it('testGetTimezone001', 0, async function (done) {
554        console.log("testGetTimezone001 start");
555        let timezone = "Pacific/Majuro";
556        await systemTime.setTimezone(timezone);
557        const currentTimezone = await systemTime.getTimezone();
558        expect(typeof (currentTimezone) == 'string' && timezone === currentTimezone).assertTrue();
559        await systemTime.setTimezone('Asia/Shanghai');
560        done();
561        console.log('testGetTimezone001 end');
562    })
563
564    /**
565     * @tc.name: TestGetTimezone002
566     * @tc.desc: test getTimezone for callback.
567     * @tc.size: MediumTest
568     * @tc.type: Function
569     * @tc.level: Level 1
570     * @tc.require:
571     */
572    it('testGetTimezone002', 0, async function (done) {
573        console.log("testGetTimezone002 start");
574        let timezone = "Pacific/Majuro";
575        await systemTime.setTimezone(timezone);
576        systemTime.getTimezone((err, data) => {
577            if (err) {
578                expect(false).assertTrue();
579                done();
580            }
581            expect(typeof(data) == 'string' && data === timezone).assertTrue();
582            done();
583            systemTime.setTimezone('Asia/Shanghai');
584        })
585        console.log('testGetTimezone002 end');
586    })
587})