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
20let timezone = ["Antarctica/McMurdo", "America/Argentina/Buenos_Aires", "Australia/Sydney", "America/Noronha",
21    "America/St_Johns", "Africa/Kinshasa", "America/Santiago", "Europe/Lisbon", "Asia/Nicosia", "Europe/Berlin",
22    "America/Guayaquil", "Europe/Madrid", "Pacific/Pohnpei", "Asia/Jakarta", "Pacific/Tarawa", "Asia/Almaty",
23    "Pacific/Majuro", "Asia/Ulaanbaatar", "America/Mexico_City", "Asia/Kuala_Lumpur", "Pacific/Auckland",
24    "Pacific/Tahiti", "Pacific/Port_Moresby", "Asia/Gaza", "Europe/Moscow", "Europe/Kiev", "Pacific/Wake", "America/New_York",
25    "Asia/Tashkent", "Asia/Shanghai"
26]
27
28describe("SystemTimeSetTest", function () {
29
30    /**
31     * @tc.name: TestSetTime001
32     * @tc.desc: Test setTime for promise.
33     * @tc.type: Function
34     * @tc.require:
35     */
36    it("testSetTime001", 0,function (done) {
37        console.log("testSetTime001 start");
38        systemTime.setTime(123235423411).then(() => {
39            expect(true).assertTrue();
40            done();
41        }).catch((err) => {
42            expect(false).assertTrue();
43            done();
44        })
45        console.log("testSetTime001 end");
46    });
47
48    /**
49     * @tc.name: TestSetTime002
50     * @tc.desc: Test setTime for callback.
51     * @tc.type: Function
52     * @tc.require:
53     */
54    it("testSetTime002", 0, async function (done) {
55        console.log("testSetTime002 start");
56        let time = 123235423411;
57        systemTime.setTime(time, (err) => {
58            if (err) {
59                expect(false).assertTrue();
60            }
61            expect(true).assertTrue();
62            done();
63        })
64        console.log("testSetTime002 end");
65    });
66
67    /**
68     * @tc.name: TestSetTimeInvalidValue003
69     * @tc.desc: Test setTime for promise with invalid value.
70     * @tc.type: Function
71     * @tc.require:
72     */
73    it("testSetTimeInvalidValue003", 0, async function (done) {
74        console.log("testSetTimeInvalidValue003 start");
75        let time = 10451042204000;
76        systemTime.setTime(time).then(() => {
77            expect(false).assertTrue();
78            done();
79        }).catch((err) => {
80            expect(true).assertTrue();
81            done();
82        })
83        console.log("testSetTimeInvalidValue003 end");
84    });
85
86    /**
87     * @tc.name: TestSetTimeInvalidValue004
88     * @tc.desc: Test setTime for callback with invalid value.
89     * @tc.type: Function
90     * @tc.require:
91     */
92    it("testSetTimeInvalidValue004", 0, async function (done) {
93        console.log("testSetTimeInvalidValue004 start");
94        let time = 10451042204000;
95        systemTime.setTime(time, (err) => {
96            if (err) {
97                expect(true).assertTrue();
98                done();
99            } else {
100                expect(false).assertTrue();
101                done();
102            }
103        })
104        console.log("testSetTimeInvalidValue004 end");
105    });
106
107    /**
108     * @tc.name: TestSetTimeInvalidParam005
109     * @tc.desc: Test setTime for promise with invalid param.
110     * @tc.type: Function
111     * @tc.require:
112     */
113    it("testSetTimeInvalidParam005", 0, async function (done) {
114        console.log("testSetTimeInvalidParam005 start");
115        try {
116            systemTime.setTime("time").then(() => {
117                expect(false).assertTrue();
118                done();
119            }).catch((err) => {
120                expect(err.code).assertEqual(-1);
121                done();
122            })
123        } catch (err) {
124            expect(err.code).assertEqual(-1);
125            done();
126        }
127        console.log("testSetTimeInvalidParam005 end");
128    });
129
130    /**
131     * @tc.name: TestSetTimeInvalidParam006
132     * @tc.desc: Test setTime for callback with invalid param.
133     * @tc.type: Function
134     * @tc.require:
135     */
136    it("testSetTimeInvalidParam006", 0, async function (done) {
137        console.log("testSetTimeInvalidParam006 start");
138        try {
139            systemTime.setTime("time", (err) => {
140                if (err) {
141                    expect(err.code).assertEqual(-1);
142                    done();
143                } else {
144                    expect(false).assertTrue();
145                    done();
146                }
147            })
148        } catch (err) {
149            expect(err.code).assertEqual(-1);
150            done();
151        }
152        console.log("testSetTimeInvalidParam006 end");
153    });
154
155    /**
156     * @tc.name: TestSetTimeInvalidValue007
157     * @tc.desc: Test setTime for callback with invalid value.
158     * @tc.type: Function
159     * @tc.require:
160     */
161    it("testSetTimeInvalidValue007", 0, async function (done) {
162        console.log("testSetTimeInvalidValue007 start");
163        try {
164            systemTime.setTime(-1).then(() => {
165                expect(false).assertTrue();
166                done();
167            }).catch((err) => {
168                expect(err.code).assertEqual(-1);
169                done();
170            })
171        } catch (err) {
172            expect(err.code).assertEqual(-1);
173            done();
174        }
175        console.log("testSetTimeInvalidValue007 end");
176    });
177
178    /**
179     * @tc.name: TestSetTimeInvalidValue008
180     * @tc.desc: Test setTime for callback with invalid value.
181     * @tc.type: Function
182     * @tc.require:
183     */
184    it("testSetTimeInvalidValue008", 0, async function (done) {
185        console.log("testSetTimeInvalidValue008 start");
186        try {
187            systemTime.setTime(-1, (err) => {
188                if (err) {
189                    expect(err.code).assertEqual(-1);
190                    done();
191                } else {
192                    expect(false).assertTrue();
193                    done();
194                }
195            })
196        } catch (err) {
197            expect(err.code).assertEqual(-1);
198            done();
199        }
200        console.log("testSetTimeInvalidValue008 end");
201    });
202
203    /**
204     * @tc.name: TestSetDate001
205     * @tc.desc: Test setDate for promise.
206     * @tc.type: Function
207     * @tc.require:
208     */
209    it("testSetDate001", 0, async function (done) {
210        let date = new Date();
211        systemTime.setDate(date).then(() => {
212            systemTime.getDate().then((data) => {
213                expect(date.toDateString() === data.toDateString()).assertTrue();
214                done();
215            }).catch((err) => {
216                expect(false).assertTrue();
217                done();
218            });
219        }).catch((err) => {
220            expect(false).assertTrue();
221            done();
222        })
223    });
224
225    /**
226     * @tc.name: TestSetDate002
227     * @tc.desc: Test setDate for callback.
228     * @tc.type: Function
229     * @tc.require:
230     */
231    it("testSetDate002", 0, async function (done) {
232        let date = new Date();
233        systemTime.setDate(date, (err) => {
234            if (err) {
235                expect(false).assertTrue();
236                done();
237            }
238            systemTime.getDate().then((data) => {
239                expect(date.toDateString() === data.toDateString()).assertTrue();
240                done();
241            }).catch((err) => {
242                expect(false).assertTrue();
243                done();
244            });
245        });
246    });
247
248    /**
249     * @tc.name: TestSetDateNull001
250     * @tc.desc: Test setDate for promise with null.
251     * @tc.type: Function
252     * @tc.require:
253     */
254    it("testSetDateNull001", 0, async function (done) {
255        try {
256            systemTime.setDate(null).then(() => {
257                expect(false).assertTrue();
258                done();
259            }).catch((err) => {
260                expect(err.code).assertEqual(-1);
261                done();
262            })
263        } catch (err) {
264            expect(err.code).assertEqual(-1);
265            done();
266        }
267    });
268
269    /**
270     * @tc.name: TestSetDateNull002
271     * @tc.desc: Test setDate for callback with null.
272     * @tc.type: Function
273     * @tc.require:
274     */
275    it("testSetDateNull002", 0, async function (done) {
276        try {
277            systemTime.setDate(null, (err) => {
278                if (err) {
279                    expect(true).assertTrue();
280                    done()
281                } else {
282                    expect(false).assertTrue();
283                    done();
284                }
285            })
286        } catch (err) {
287            expect(true).assertTrue();
288            done();
289        }
290    });
291
292    /**
293     * @tc.name: TestSetTimezone001
294     * @tc.desc: Test setDate for promise.
295     * @tc.type: Function
296     * @tc.require:
297     */
298    it("testSetTimezone001", 0, async function (done) {
299        function calLoop(index) {
300            if (index >= timezone.length - 1) {
301                expect(true).assertTrue();
302                done();
303            }
304        }
305        for (let i = 0; i < timezone.length; i++) {
306            systemTime.setTimezone(timezone[i]).then(() => {
307                calLoop(i)
308            }).catch((err) => {
309                expect(false).assertTrue();
310                done();
311            });
312        }
313
314    });
315
316    /**
317     * @tc.name: TestSetTimezone002
318     * @tc.desc: Test setDate for callback.
319     * @tc.type: Function
320     * @tc.require:
321     */
322    it("testSetTimezone002", 0, async function (done) {
323        for (let i = 0; i < timezone.length; i++) {
324            systemTime.setTimezone(timezone[i], (err) => {
325                if (err) {
326                    expect(false).assertTrue();
327                }
328            })
329        }
330        expect(true).assertTrue();
331        done();
332    });
333
334    /**
335     * @tc.name: TestSetTimezoneNull003
336     * @tc.desc: Test setDate for promise with null.
337     * @tc.type: Function
338     * @tc.require:
339     */
340    it("systemTime_setTimezone_test5", 0, async function (done) {
341        try {
342            systemTime.setTimezone(null).then(() => {
343                expect(false).assertTrue();
344                done();
345            }).catch((err) => {
346                expect(err.code).assertEqual(-1);
347                done();
348            })
349        } catch (err) {
350            expect(err.code).assertEqual(-1);
351            done();
352        }
353    });
354
355    /**
356     * @tc.name: TestSetTimezoneNull004
357     * @tc.desc: Test setDate for callback with null.
358     * @tc.type: Function
359     * @tc.require:
360     */
361    it("testSetTimezoneNull004", 0, async function (done) {
362        try {
363            systemTime.setTimezone(null, (err) => {
364                if (err) {
365                    expect(err.code).assertEqual(-1);
366                } else {
367                    expect(false).assertTrue();
368                }
369                done();
370            });
371        } catch (err) {
372            expect(err.code).assertEqual(-1);
373            done();
374        }
375    });
376})