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 #include <stdlib.h>
17 #include <time.h>
18 #include "asctime_data.h"
19 #include "functionalext.h"
20 #include "strftime_data.h"
21
22 static time_t gTime = 1659177614;
23 static int16_t gBufferSize = 256;
24
25 /**
26 * @tc.name : strftime_0100
27 * @tc.desc : according to different time zones, format date
28 * @tc.level : Level 0
29 */
strftime_0100(void)30 void strftime_0100(void)
31 {
32 for (int32_t i = 0; i < (int32_t)(sizeof(test_asctime_data) / sizeof(test_asctime_data[0])); i++) {
33 const char *handlerChar = test_handle_path(test_asctime_data[i].tz);
34 if (!handlerChar) {
35 t_error("strftime_0100 failed: handlerChar is NULL\n");
36 continue;
37 }
38
39 setenv("TZ", handlerChar, 1);
40 tzset();
41 char buffer[gBufferSize];
42 struct tm *timeptr = localtime(&gTime);
43 if (!timeptr) {
44 EXPECT_PTRNE("strftime_0100", timeptr, NULL);
45 return;
46 }
47 size_t count = strftime(buffer, sizeof(buffer) - 1, "%c", timeptr);
48 EXPECT_TRUE("strftime_0100", count > 0);
49 EXPECT_STREQ("strftime_0100", buffer, test_asctime_data[i].result);
50 }
51 }
52
53 /**
54 * @tc.name : strftime_0200
55 * @tc.desc : according to different time zones, format date
56 * @tc.level : Level 0
57 */
strftime_0200(void)58 void strftime_0200(void)
59 {
60 for (int32_t i = 0; i < (int32_t)(sizeof(test_strftime_data) / sizeof(test_strftime_data[0])); i++) {
61 const char *handlerChar = test_handle_path(test_strftime_data[i].tz);
62 if (!handlerChar) {
63 t_error("strftime_0200 failed: handlerChar is NULL\n");
64 continue;
65 }
66
67 setenv("TZ", handlerChar, 1);
68 tzset();
69 struct tm *timeptr = localtime(&gTime);
70 if (!timeptr) {
71 EXPECT_PTRNE("strftime_0200", timeptr, NULL);
72 return;
73 }
74 char buffer[gBufferSize];
75 size_t count = strftime(buffer, sizeof(buffer) - 1, "%c %Z%z", timeptr);
76 EXPECT_TRUE("strftime_0200", count > 0);
77 EXPECT_STREQ("strftime_0200", buffer, test_strftime_data[i].result);
78 }
79 }
80
81 /**
82 * @tc.name : strftime_0300
83 * @tc.desc : according to different time zones, format date
84 * @tc.level : Level 0
85 */
strftime_0300(void)86 void strftime_0300(void)
87 {
88 const char *handlerChar = test_handle_path("Pacific/Pitcairn");
89 if (!handlerChar) {
90 t_error("strftime_0300 failed: handlerChar is NULL\n");
91 return;
92 }
93
94 setenv("TZ", handlerChar, 1);
95 tzset();
96 struct tm *timeptr = localtime(&gTime);
97 if (!timeptr) {
98 EXPECT_PTRNE("strftime_0300", timeptr, NULL);
99 return;
100 }
101 char buffer[gBufferSize];
102 size_t count = strftime(buffer, sizeof(buffer) - 1, "%k", timeptr);
103 EXPECT_TRUE("strftime_0300", count > 0);
104 EXPECT_STREQ("strftime_0300", buffer, " 2");
105 }
106
107 /**
108 * @tc.name : strftime_0400
109 * @tc.desc : according to different time zones, format date
110 * @tc.level : Level 0
111 */
strftime_0400(void)112 void strftime_0400(void)
113 {
114 const char *handlerChar = test_handle_path("Asia/Shanghai");
115 if (!handlerChar) {
116 t_error("strftime_0400 failed: handlerChar is NULL\n");
117 return;
118 }
119
120 setenv("TZ", handlerChar, 1);
121 tzset();
122 struct tm *timeptr = localtime(&gTime);
123 if (!timeptr) {
124 EXPECT_PTRNE("strftime_0400", timeptr, NULL);
125 return;
126 }
127 char buffer[gBufferSize];
128 size_t count = strftime(buffer, sizeof(buffer) - 1, "%k", timeptr);
129 EXPECT_TRUE("strftime_0400", count > 0);
130 EXPECT_STREQ("strftime_0400", buffer, "18");
131 }
132
133 /**
134 * @tc.name : strftime_0500
135 * @tc.desc : according to different time zones, format date
136 * @tc.level : Level 0
137 */
strftime_0500(void)138 void strftime_0500(void)
139 {
140 const char *handlerChar = test_handle_path("Asia/Shanghai");
141 if (!handlerChar) {
142 t_error("strftime_0500 failed: handlerChar is NULL\n");
143 return;
144 }
145
146 setenv("TZ", handlerChar, 1);
147 tzset();
148 struct tm *timeptr = localtime(&gTime);
149 if (!timeptr) {
150 EXPECT_PTRNE("strftime_0500", timeptr, NULL);
151 return;
152 }
153 char buffer[gBufferSize];
154 size_t count = strftime(buffer, sizeof(buffer) - 1, "%I", timeptr);
155 EXPECT_TRUE("strftime_0500", count > 0);
156 EXPECT_STREQ("strftime_0500", buffer, "06");
157 }
158
159 /**
160 * @tc.name : strftime_0600
161 * @tc.desc : according to different time zones, format date
162 * @tc.level : Level 0
163 */
strftime_0600(void)164 void strftime_0600(void)
165 {
166 const char *handlerChar = test_handle_path("Asia/Shanghai");
167 if (!handlerChar) {
168 t_error("strftime_0600 failed: handlerChar is NULL\n");
169 return;
170 }
171
172 setenv("TZ", handlerChar, 1);
173 tzset();
174 struct tm *timeptr = localtime(&gTime);
175 if (!timeptr) {
176 EXPECT_PTRNE("strftime_0600", timeptr, NULL);
177 return;
178 }
179 char buffer[gBufferSize];
180 size_t count = strftime(buffer, sizeof(buffer) - 1, "%P", timeptr);
181 EXPECT_TRUE("strftime_0600", count > 0);
182 EXPECT_STREQ("strftime_0600", buffer, "pm");
183 }
184
185 /**
186 * @tc.name : strftime_0700
187 * @tc.desc : according to different time zones, format date
188 * @tc.level : Level 0
189 */
strftime_0700(void)190 void strftime_0700(void)
191 {
192 const char *handlerChar = test_handle_path("Asia/Shanghai");
193 if (!handlerChar) {
194 t_error("strftime_0700 failed: handlerChar is NULL\n");
195 return;
196 }
197
198 setenv("TZ", handlerChar, 1);
199 tzset();
200 struct tm *timeptr = localtime(&gTime);
201 if (!timeptr) {
202 EXPECT_PTRNE("strftime_0700", timeptr, NULL);
203 return;
204 }
205 char buffer[gBufferSize];
206 size_t count = strftime(buffer, sizeof(buffer) - 1, "%v", timeptr);
207 EXPECT_TRUE("strftime_0700", count > 0);
208 EXPECT_STREQ("strftime_0700", buffer, "30-Jul-2022");
209 }
210
211 /**
212 * @tc.name : strftime_0800
213 * @tc.desc : according to different time zones, format date
214 * @tc.level : Level 0
215 */
strftime_0800(void)216 void strftime_0800(void)
217 {
218 const char *handlerChar = test_handle_path("Asia/Shanghai");
219 if (!handlerChar) {
220 t_error("strftime_0800 failed: handlerChar is NULL\n");
221 return;
222 }
223
224 setenv("TZ", handlerChar, 1);
225 tzset();
226 struct tm *timeptr = localtime(&gTime);
227 if (!timeptr) {
228 EXPECT_PTRNE("strftime_0800", timeptr, NULL);
229 return;
230 }
231 char buffer[gBufferSize];
232 size_t count = strftime(buffer, sizeof(buffer) - 1, "%j", timeptr);
233 EXPECT_TRUE("strftime_0800", count > 0);
234 EXPECT_STREQ("strftime_0800", buffer, "211");
235 }
236
237 /**
238 * @tc.name : strftime_0900
239 * @tc.desc : according to different time zones, format date
240 * @tc.level : Level 0
241 */
strftime_0900(void)242 void strftime_0900(void)
243 {
244 const char *handlerChar = test_handle_path("Asia/Shanghai");
245 if (!handlerChar) {
246 t_error("strftime_0900 failed: handlerChar is NULL\n");
247 return;
248 }
249
250 setenv("TZ", handlerChar, 1);
251 tzset();
252 struct tm *timeptr = localtime(&gTime);
253 if (!timeptr) {
254 EXPECT_PTRNE("strftime_0900", timeptr, NULL);
255 return;
256 }
257 char buffer[gBufferSize];
258 size_t count = strftime(buffer, sizeof(buffer) - 1, "%l", timeptr);
259 EXPECT_TRUE("strftime_0900", count > 0);
260 EXPECT_STREQ("strftime_0900", buffer, " 6");
261 }
262
263 /**
264 * @tc.name : strftime_1000
265 * @tc.desc : according to different time zones, format date
266 * @tc.level : Level 0
267 */
strftime_1000(void)268 void strftime_1000(void)
269 {
270 const char *handlerChar = test_handle_path("Asia/Shanghai");
271 if (!handlerChar) {
272 t_error("strftime_1000 failed: handlerChar is NULL\n");
273 return;
274 }
275
276 setenv("TZ", handlerChar, 1);
277 tzset();
278 struct tm *timeptr = localtime(&gTime);
279 if (!timeptr) {
280 EXPECT_PTRNE("strftime_1000", timeptr, NULL);
281 return;
282 }
283 timeptr->tm_mday = 31;
284 timeptr->tm_mon = 11;
285 timeptr->tm_year = 124;
286 timeptr->tm_wday = 2;
287 timeptr->tm_yday = 365;
288
289 char buffer[gBufferSize];
290 size_t count = strftime(buffer, sizeof(buffer) - 1, "%V", timeptr);
291 EXPECT_TRUE("strftime_1000", count > 0);
292 EXPECT_STREQ("strftime_1000", buffer, "01");
293 }
294
295 /**
296 * @tc.name : strftime_1100
297 * @tc.desc : according to different time zones, format date
298 * @tc.level : Level 0
299 */
strftime_1100(void)300 void strftime_1100(void)
301 {
302 struct tm tm = {0};
303 char buffer[gBufferSize];
304 size_t count = strftime(buffer, sizeof(buffer) - 1, "%l", &tm);
305 EXPECT_TRUE("strftime_1100", count > 0);
306 EXPECT_STREQ("strftime_1100", buffer, "12");
307 }
308
309 /**
310 * @tc.name : strftime_1200
311 * @tc.desc : according to different time zones, format date
312 * @tc.level : Level 0
313 */
strftime_1200(void)314 void strftime_1200(void)
315 {
316 const char *handlerChar = test_handle_path("Asia/Shanghai");
317 if (!handlerChar) {
318 t_error("strftime_1200 failed: handlerChar is NULL\n");
319 return;
320 }
321
322 setenv("TZ", handlerChar, 1);
323 tzset();
324 struct tm *timeptr = localtime(&gTime);
325 if (!timeptr) {
326 EXPECT_PTRNE("strftime_1200", timeptr, NULL);
327 return;
328 }
329 timeptr->tm_mday = 28;
330 timeptr->tm_mon = 12;
331 timeptr->tm_year = 200;
332 timeptr->tm_wday = 1;
333 timeptr->tm_yday = 362;
334
335 char buffer[gBufferSize];
336 size_t count = strftime(buffer, sizeof(buffer) - 1, "%G", timeptr);
337 EXPECT_TRUE("strftime_1200", count > 0);
338 EXPECT_STREQ("strftime_1200", buffer, "2101");
339 }
340
341 /**
342 * @tc.name : strftime_1300
343 * @tc.desc : according to different time zones, format date
344 * @tc.level : Level 1
345 */
strftime_1300(void)346 void strftime_1300(void)
347 {
348 const char *handlerChar = test_handle_path("Asia/Shanghai");
349 if (!handlerChar) {
350 t_error("strftime_1300 failed: handlerChar is NULL\n");
351 return;
352 }
353
354 setenv("TZ", handlerChar, 1);
355 tzset();
356 struct tm *timeptr = localtime(&gTime);
357 if (!timeptr) {
358 EXPECT_PTRNE("strftime_1300", timeptr, NULL);
359 return;
360 }
361 timeptr->tm_mday = 28;
362 timeptr->tm_mon = 12;
363 timeptr->tm_year = 100;
364 timeptr->tm_wday = 1;
365 timeptr->tm_yday = 362;
366
367 char buffer[gBufferSize];
368 size_t count = strftime(buffer, sizeof(buffer) - 1, "%G", timeptr);
369 EXPECT_TRUE("strftime_1300", count > 0);
370 EXPECT_STREQ("strftime_1300", buffer, "2000");
371 }
372
373 /**
374 * @tc.name : strftime_1400
375 * @tc.desc : according to different time zones, format date
376 * @tc.level : Level 1
377 */
strftime_1400(void)378 void strftime_1400(void)
379 {
380 const char *handlerChar = test_handle_path("Asia/Shanghai");
381 if (!handlerChar) {
382 t_error("strftime_1400 failed: handlerChar is NULL\n");
383 return;
384 }
385
386 setenv("TZ", handlerChar, 1);
387 tzset();
388 struct tm *timeptr = localtime(&gTime);
389 if (!timeptr) {
390 EXPECT_PTRNE("strftime_1400", timeptr, NULL);
391 return;
392 }
393 timeptr->tm_mday = 28;
394 timeptr->tm_mon = 12;
395 timeptr->tm_year = 101;
396 timeptr->tm_wday = 1;
397 timeptr->tm_yday = 362;
398
399 char buffer[gBufferSize];
400 size_t count = strftime(buffer, sizeof(buffer) - 1, "%G", timeptr);
401 EXPECT_TRUE("strftime_1400", count > 0);
402 EXPECT_STREQ("strftime_1400", buffer, "2002");
403 }
404
405 /**
406 * @tc.name : strftime_1500
407 * @tc.desc : according to different time zones, format date
408 * @tc.level : Level 1
409 */
strftime_1500(void)410 void strftime_1500(void)
411 {
412 const char *handlerChar = test_handle_path("Asia/Shanghai");
413 if (!handlerChar) {
414 t_error("strftime_1500 failed: handlerChar is NULL\n");
415 return;
416 }
417
418 setenv("TZ", handlerChar, 1);
419 tzset();
420 struct tm *timeptr = localtime(&gTime);
421 if (!timeptr) {
422 EXPECT_PTRNE("strftime_1500", timeptr, NULL);
423 return;
424 }
425
426 char buffer[gBufferSize];
427 size_t count = strftime(buffer, sizeof(buffer) - 1, "%B", timeptr);
428 EXPECT_TRUE("strftime_1500", count > 0);
429 EXPECT_STREQ("strftime_1500", buffer, "July");
430 }
431
432 /**
433 * @tc.name : strftime_1600
434 * @tc.desc : according to different time zones, format date
435 * @tc.level : Level 1
436 */
strftime_1600(void)437 void strftime_1600(void)
438 {
439 const char *handlerChar = test_handle_path("Asia/Shanghai");
440 if (!handlerChar) {
441 t_error("strftime_1600 failed: handlerChar is NULL\n");
442 return;
443 }
444
445 setenv("TZ", handlerChar, 1);
446 tzset();
447 struct tm *timeptr = localtime(&gTime);
448 if (!timeptr) {
449 EXPECT_PTRNE("strftime_1600", timeptr, NULL);
450 return;
451 }
452 timeptr->tm_mon = 12;
453
454 char buffer[gBufferSize];
455 size_t count = strftime(buffer, sizeof(buffer) - 1, "%B", timeptr);
456 EXPECT_TRUE("strftime_1600", count > 0);
457 EXPECT_STREQ("strftime_1600", buffer, "-");
458 }
459
460 /**
461 * @tc.name : strftime_1700
462 * @tc.desc : according to different time zones, format date
463 * @tc.level : Level 1
464 */
strftime_1700(void)465 void strftime_1700(void)
466 {
467 struct tm tm = {0};
468 tm.tm_hour = 13;
469 char buffer[gBufferSize];
470 size_t count = strftime(buffer, sizeof(buffer) - 1, "%l", &tm);
471 EXPECT_TRUE("strftime_1700", count > 0);
472 EXPECT_STREQ("strftime_1700", buffer, " 1");
473 }
474
475 /**
476 * @tc.name : strftime_1800
477 * @tc.desc : according to different time zones, format date
478 * @tc.level : Level 1
479 */
strftime_1800(void)480 void strftime_1800(void)
481 {
482 struct tm tm = {0};
483 char buffer[gBufferSize];
484 size_t count = strftime(buffer, sizeof(buffer) - 1, "%u", &tm);
485 EXPECT_TRUE("strftime_1800", count > 0);
486 EXPECT_STREQ("strftime_1800", buffer, "7");
487 }
488
489 /**
490 * @tc.name : strftime_1900
491 * @tc.desc : according to different time zones, format date
492 * @tc.level : Level 1
493 */
strftime_1900(void)494 void strftime_1900(void)
495 {
496 struct tm tm = {0};
497 tm.tm_wday = 3;
498 char buffer[gBufferSize];
499 size_t count = strftime(buffer, sizeof(buffer) - 1, "%u", &tm);
500 EXPECT_TRUE("strftime_1900", count > 0);
501 EXPECT_STREQ("strftime_1900", buffer, "3");
502 }
503
504 /**
505 * @tc.name : strftime_2000
506 * @tc.desc : according to different time zones, format date
507 * @tc.level : Level 1
508 */
strftime_2000(void)509 void strftime_2000(void)
510 {
511 struct tm tm = {0};
512 tm.tm_year = -1999;
513 char buffer[gBufferSize];
514 size_t count = strftime(buffer, sizeof(buffer) - 1, "%-y", &tm);
515 EXPECT_TRUE("strftime_2000", count > 0);
516 EXPECT_STREQ("strftime_2000", buffer, "99");
517 }
518
519 /**
520 * @tc.name : strftime_2100
521 * @tc.desc : according to different time zones, format date
522 * @tc.level : Level 1
523 */
strftime_2100(void)524 void strftime_2100(void)
525 {
526 struct tm tm = {0};
527 tm.tm_isdst = -1;
528 char buffer[gBufferSize];
529 size_t count = strftime(buffer, sizeof(buffer) - 1, "%z", &tm);
530 EXPECT_TRUE("strftime_2100", count == 0);
531 EXPECT_STREQ("strftime_2100", buffer, "");
532 }
533
534 /**
535 * @tc.name : strftime_2200
536 * @tc.desc : according to different time zones, format date
537 * @tc.level : Level 1
538 */
strftime_2200(void)539 void strftime_2200(void)
540 {
541 struct tm tm = {0};
542 tm.tm_isdst = -1;
543 char buffer[gBufferSize];
544 size_t count = strftime(buffer, sizeof(buffer) - 1, "%Z", &tm);
545 EXPECT_TRUE("strftime_2200", count == 0);
546 EXPECT_STREQ("strftime_2200", buffer, "");
547 }
548
549 /**
550 * @tc.name : strftime_2300
551 * @tc.desc : according to different time zones, format date
552 * @tc.level : Level 1
553 */
strftime_2300(void)554 void strftime_2300(void)
555 {
556 struct tm tm = {0};
557 char buffer[gBufferSize];
558 size_t count = strftime(buffer, sizeof(buffer) - 1, "%E%", &tm);
559 EXPECT_TRUE("strftime_2300", count > 0);
560 EXPECT_STREQ("strftime_2300", buffer, "%");
561 }
562
563 /**
564 * @tc.name : strftime_2200
565 * @tc.desc : according to different time zones, format date
566 * @tc.level : Level 1
567 */
strftime_2400(void)568 void strftime_2400(void)
569 {
570 struct tm tm = {0};
571 char buffer[gBufferSize];
572 size_t count = strftime(buffer, sizeof(buffer) - 1, "%O%", &tm);
573 EXPECT_TRUE("strftime_2400", count > 0);
574 EXPECT_STREQ("strftime_2400", buffer, "%");
575 }
576
main(void)577 int main(void)
578 {
579 strftime_0100();
580 strftime_0200();
581 strftime_0300();
582 strftime_0400();
583 strftime_0500();
584 strftime_0600();
585 strftime_0700();
586 strftime_0800();
587 strftime_0900();
588 strftime_1000();
589 strftime_1100();
590 strftime_1200();
591 strftime_1300();
592 strftime_1400();
593 strftime_1500();
594 strftime_1600();
595 strftime_1700();
596 strftime_1800();
597 strftime_1900();
598 strftime_2000();
599 strftime_2100();
600 strftime_2200();
601 strftime_2300();
602 strftime_2400();
603 return t_status;
604 }