1 #include "config.h"
2
3 #include "ntp_stdlib.h" /* test fail without this include, for some reason */
4 #include "ntp_calendar.h"
5 #include "unity.h"
6
7 #include <string.h>
8
9 static int leapdays(int year);
10
11 void setUp(void);
12 int isGT(int first, int second);
13 int leapdays(int year);
14 char * CalendarFromCalToString(const struct calendar *cal);
15 char * CalendarFromIsoToString(const struct isodate *iso);
16 int IsEqualCal(const struct calendar *expected, const struct calendar *actual);
17 int IsEqualIso(const struct isodate *expected, const struct isodate *actual);
18 char * DateFromCalToString(const struct calendar *cal);
19 char * DateFromIsoToString(const struct isodate *iso);
20 int IsEqualDateCal(const struct calendar *expected, const struct calendar *actual);
21 int IsEqualDateIso(const struct isodate *expected, const struct isodate *actual);
22 void test_DaySplitMerge(void);
23 void test_SplitYearDays1(void);
24 void test_SplitYearDays2(void);
25 void test_RataDie1(void);
26 void test_LeapYears1(void);
27 void test_LeapYears2(void);
28 void test_RoundTripDate(void);
29 void test_RoundTripYearStart(void);
30 void test_RoundTripMonthStart(void);
31 void test_RoundTripWeekStart(void);
32 void test_RoundTripDayStart(void);
33 void test_IsoCalYearsToWeeks(void);
34 void test_IsoCalWeeksToYearStart(void);
35 void test_IsoCalWeeksToYearEnd(void);
36 void test_DaySecToDate(void);
37
38
39 void
setUp(void)40 setUp(void)
41 {
42 init_lib();
43
44 return;
45 }
46
47
48 /*
49 * ---------------------------------------------------------------------
50 * test support stuff
51 * ---------------------------------------------------------------------
52 */
53 int
isGT(int first,int second)54 isGT(int first, int second)
55 {
56 if(first > second) {
57 return TRUE;
58 } else {
59 return FALSE;
60 }
61 }
62
63 int
leapdays(int year)64 leapdays(int year)
65 {
66 if (year % 400 == 0)
67 return 1;
68 if (year % 100 == 0)
69 return 0;
70 if (year % 4 == 0)
71 return 1;
72 return 0;
73 }
74
75 char *
CalendarFromCalToString(const struct calendar * cal)76 CalendarFromCalToString(
77 const struct calendar *cal)
78 {
79 char * str = malloc(sizeof (char) * 100);
80 snprintf(str, 100, "%u-%02u-%02u (%u) %02u:%02u:%02u",
81 cal->year, (u_int)cal->month, (u_int)cal->monthday,
82 cal->yearday,
83 (u_int)cal->hour, (u_int)cal->minute, (u_int)cal->second);
84 str[99] = '\0'; /* paranoia rulez! */
85 return str;
86 }
87
88 char *
CalendarFromIsoToString(const struct isodate * iso)89 CalendarFromIsoToString(
90 const struct isodate *iso)
91 {
92 char * str = emalloc (sizeof (char) * 100);
93 snprintf(str, 100, "%u-W%02u-%02u %02u:%02u:%02u",
94 iso->year, (u_int)iso->week, (u_int)iso->weekday,
95 (u_int)iso->hour, (u_int)iso->minute, (u_int)iso->second);
96 str[99] = '\0'; /* paranoia rulez! */
97 return str;
98 }
99
100 int
IsEqualCal(const struct calendar * expected,const struct calendar * actual)101 IsEqualCal(
102 const struct calendar *expected,
103 const struct calendar *actual)
104 {
105 if (expected->year == actual->year &&
106 (!expected->yearday || expected->yearday == actual->yearday) &&
107 expected->month == actual->month &&
108 expected->monthday == actual->monthday &&
109 expected->hour == actual->hour &&
110 expected->minute == actual->minute &&
111 expected->second == actual->second) {
112 return TRUE;
113 } else {
114 char *p_exp = CalendarFromCalToString(expected);
115 char *p_act = CalendarFromCalToString(actual);
116
117 printf("expected: %s but was %s", p_exp, p_act);
118
119 free(p_exp);
120 free(p_act);
121
122 return FALSE;
123 }
124 }
125
126 int
IsEqualIso(const struct isodate * expected,const struct isodate * actual)127 IsEqualIso(
128 const struct isodate *expected,
129 const struct isodate *actual)
130 {
131 if (expected->year == actual->year &&
132 expected->week == actual->week &&
133 expected->weekday == actual->weekday &&
134 expected->hour == actual->hour &&
135 expected->minute == actual->minute &&
136 expected->second == actual->second) {
137 return TRUE;
138 } else {
139 printf("expected: %s but was %s",
140 CalendarFromIsoToString(expected),
141 CalendarFromIsoToString(actual));
142 return FALSE;
143 }
144 }
145
146 char *
DateFromCalToString(const struct calendar * cal)147 DateFromCalToString(
148 const struct calendar *cal)
149 {
150
151 char * str = emalloc (sizeof (char) * 100);
152 snprintf(str, 100, "%u-%02u-%02u (%u)",
153 cal->year, (u_int)cal->month, (u_int)cal->monthday,
154 cal->yearday);
155 str[99] = '\0'; /* paranoia rulez! */
156 return str;
157 }
158
159 char *
DateFromIsoToString(const struct isodate * iso)160 DateFromIsoToString(
161 const struct isodate *iso)
162 {
163
164 char * str = emalloc (sizeof (char) * 100);
165 snprintf(str, 100, "%u-W%02u-%02u",
166 iso->year, (u_int)iso->week, (u_int)iso->weekday);
167 str[99] = '\0'; /* paranoia rulez! */
168 return str;
169 }
170
171 int/*BOOL*/
IsEqualDateCal(const struct calendar * expected,const struct calendar * actual)172 IsEqualDateCal(
173 const struct calendar *expected,
174 const struct calendar *actual)
175 {
176 if (expected->year == actual->year &&
177 (!expected->yearday || expected->yearday == actual->yearday) &&
178 expected->month == actual->month &&
179 expected->monthday == actual->monthday) {
180 return TRUE;
181 } else {
182 printf("expected: %s but was %s",
183 DateFromCalToString(expected),
184 DateFromCalToString(actual));
185 return FALSE;
186 }
187 }
188
189 int/*BOOL*/
IsEqualDateIso(const struct isodate * expected,const struct isodate * actual)190 IsEqualDateIso(
191 const struct isodate *expected,
192 const struct isodate *actual)
193 {
194 if (expected->year == actual->year &&
195 expected->week == actual->week &&
196 expected->weekday == actual->weekday) {
197 return TRUE;
198 } else {
199 printf("expected: %s but was %s",
200 DateFromIsoToString(expected),
201 DateFromIsoToString(actual));
202 return FALSE;
203 }
204 }
205
206
207 /*
208 * ---------------------------------------------------------------------
209 * test cases
210 * ---------------------------------------------------------------------
211 */
212
213 /* days before month, with a full-year pad at the upper end */
214 static const u_short real_month_table[2][13] = {
215 /* -*- table for regular years -*- */
216 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
217 /* -*- table for leap years -*- */
218 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
219 };
220
221 /* days in month, with one month wrap-around at both ends */
222 static const u_short real_month_days[2][14] = {
223 /* -*- table for regular years -*- */
224 { 31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31 },
225 /* -*- table for leap years -*- */
226 { 31, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31 }
227 };
228
229 /* test the day/sec join & split ops, making sure that 32bit
230 * intermediate results would definitely overflow and the hi DWORD of
231 * the 'vint64' is definitely needed.
232 */
233 void
test_DaySplitMerge(void)234 test_DaySplitMerge(void)
235 {
236 int32 day,sec;
237
238 for (day = -1000000; day <= 1000000; day += 100) {
239 for (sec = -100000; sec <= 186400; sec += 10000) {
240 vint64 merge;
241 ntpcal_split split;
242 int32 eday;
243 int32 esec;
244
245 merge = ntpcal_dayjoin(day, sec);
246 split = ntpcal_daysplit(&merge);
247 eday = day;
248 esec = sec;
249
250 while (esec >= 86400) {
251 eday += 1;
252 esec -= 86400;
253 }
254 while (esec < 0) {
255 eday -= 1;
256 esec += 86400;
257 }
258
259 TEST_ASSERT_EQUAL(eday, split.hi);
260 TEST_ASSERT_EQUAL(esec, split.lo);
261 }
262 }
263
264 return;
265 }
266
267 void
test_SplitYearDays1(void)268 test_SplitYearDays1(void)
269 {
270 int32 eyd;
271
272 for (eyd = -1; eyd <= 365; eyd++) {
273 ntpcal_split split = ntpcal_split_yeardays(eyd, 0);
274 if (split.lo >= 0 && split.hi >= 0) {
275 TEST_ASSERT_TRUE(isGT(12,split.hi));
276 TEST_ASSERT_TRUE(isGT(real_month_days[0][split.hi+1], split.lo));
277 int32 tyd = real_month_table[0][split.hi] + split.lo;
278 TEST_ASSERT_EQUAL(eyd, tyd);
279 } else
280 TEST_ASSERT_TRUE(eyd < 0 || eyd > 364);
281 }
282
283 return;
284 }
285
286 void
test_SplitYearDays2(void)287 test_SplitYearDays2(void)
288 {
289 int32 eyd;
290
291 for (eyd = -1; eyd <= 366; eyd++) {
292 ntpcal_split split = ntpcal_split_yeardays(eyd, 1);
293 if (split.lo >= 0 && split.hi >= 0) {
294 /* basic checks do not work on compunds :( */
295 /* would like: TEST_ASSERT_TRUE(12 > split.hi); */
296 TEST_ASSERT_TRUE(isGT(12,split.hi));
297 TEST_ASSERT_TRUE(isGT(real_month_days[1][split.hi+1], split.lo));
298 int32 tyd = real_month_table[1][split.hi] + split.lo;
299 TEST_ASSERT_EQUAL(eyd, tyd);
300 } else
301 TEST_ASSERT_TRUE(eyd < 0 || eyd > 365);
302 }
303
304 return;
305 }
306
307 void
test_RataDie1(void)308 test_RataDie1(void)
309 {
310 int32 testDate = 1; /* 0001-01-01 (proleptic date) */
311 struct calendar expected = { 1, 1, 1, 1 };
312 struct calendar actual;
313
314 ntpcal_rd_to_date(&actual, testDate);
315 TEST_ASSERT_TRUE(IsEqualDateCal(&expected, &actual));
316
317 return;
318 }
319
320 /* check last day of february for first 10000 years */
321 void
test_LeapYears1(void)322 test_LeapYears1(void)
323 {
324 struct calendar dateIn, dateOut;
325
326 for (dateIn.year = 1; dateIn.year < 10000; ++dateIn.year) {
327 dateIn.month = 2;
328 dateIn.monthday = 28 + leapdays(dateIn.year);
329 dateIn.yearday = 31 + dateIn.monthday;
330
331 ntpcal_rd_to_date(&dateOut, ntpcal_date_to_rd(&dateIn));
332
333 TEST_ASSERT_TRUE(IsEqualDateCal(&dateIn, &dateOut));
334 }
335
336 return;
337 }
338
339 /* check first day of march for first 10000 years */
340 void
test_LeapYears2(void)341 test_LeapYears2(void)
342 {
343 struct calendar dateIn, dateOut;
344
345 for (dateIn.year = 1; dateIn.year < 10000; ++dateIn.year) {
346 dateIn.month = 3;
347 dateIn.monthday = 1;
348 dateIn.yearday = 60 + leapdays(dateIn.year);
349
350 ntpcal_rd_to_date(&dateOut, ntpcal_date_to_rd(&dateIn));
351 TEST_ASSERT_TRUE(IsEqualDateCal(&dateIn, &dateOut));
352 }
353
354 return;
355 }
356
357 /* Full roundtrip from 1601-01-01 to 2400-12-31
358 * checks sequence of rata die numbers and validates date output
359 * (since the input is all nominal days of the calendar in that range
360 * and the result of the inverse calculation must match the input no
361 * invalid output can occur.)
362 */
363 void
test_RoundTripDate(void)364 test_RoundTripDate(void)
365 {
366 struct calendar truDate, expDate = { 1600, 0, 12, 31 };;
367 int leaps;
368 int32 truRdn, expRdn = ntpcal_date_to_rd(&expDate);
369
370 while (expDate.year < 2400) {
371 expDate.year++;
372 expDate.month = 0;
373 expDate.yearday = 0;
374 leaps = leapdays(expDate.year);
375 while (expDate.month < 12) {
376 expDate.month++;
377 expDate.monthday = 0;
378 while (expDate.monthday < real_month_days[leaps][expDate.month]) {
379 expDate.monthday++;
380 expDate.yearday++;
381 expRdn++;
382
383 truRdn = ntpcal_date_to_rd(&expDate);
384 TEST_ASSERT_EQUAL(expRdn, truRdn);
385
386 ntpcal_rd_to_date(&truDate, truRdn);
387 TEST_ASSERT_TRUE(IsEqualDateCal(&expDate, &truDate));
388 }
389 }
390 }
391
392 return;
393 }
394
395 /* Roundtrip testing on calyearstart */
396 void
test_RoundTripYearStart(void)397 test_RoundTripYearStart(void)
398 {
399 static const time_t pivot = 0;
400 u_int32 ntp, expys, truys;
401 struct calendar date;
402
403 for (ntp = 0; ntp < 0xFFFFFFFFu - 30000000u; ntp += 30000000u) {
404 truys = calyearstart(ntp, &pivot);
405 ntpcal_ntp_to_date(&date, ntp, &pivot);
406 date.month = date.monthday = 1;
407 date.hour = date.minute = date.second = 0;
408 expys = ntpcal_date_to_ntp(&date);
409 TEST_ASSERT_EQUAL(expys, truys);
410 }
411
412 return;
413 }
414
415 /* Roundtrip testing on calmonthstart */
416 void
test_RoundTripMonthStart(void)417 test_RoundTripMonthStart(void)
418 {
419 static const time_t pivot = 0;
420 u_int32 ntp, expms, trums;
421 struct calendar date;
422
423 for (ntp = 0; ntp < 0xFFFFFFFFu - 2000000u; ntp += 2000000u) {
424 trums = calmonthstart(ntp, &pivot);
425 ntpcal_ntp_to_date(&date, ntp, &pivot);
426 date.monthday = 1;
427 date.hour = date.minute = date.second = 0;
428 expms = ntpcal_date_to_ntp(&date);
429 TEST_ASSERT_EQUAL(expms, trums);
430 }
431
432 return;
433 }
434
435 /* Roundtrip testing on calweekstart */
436 void
test_RoundTripWeekStart(void)437 test_RoundTripWeekStart(void)
438 {
439 static const time_t pivot = 0;
440 u_int32 ntp, expws, truws;
441 struct isodate date;
442
443 for (ntp = 0; ntp < 0xFFFFFFFFu - 600000u; ntp += 600000u) {
444 truws = calweekstart(ntp, &pivot);
445 isocal_ntp_to_date(&date, ntp, &pivot);
446 date.hour = date.minute = date.second = 0;
447 date.weekday = 1;
448 expws = isocal_date_to_ntp(&date);
449 TEST_ASSERT_EQUAL(expws, truws);
450 }
451
452 return;
453 }
454
455 /* Roundtrip testing on caldaystart */
456 void
test_RoundTripDayStart(void)457 test_RoundTripDayStart(void)
458 {
459 static const time_t pivot = 0;
460 u_int32 ntp, expds, truds;
461 struct calendar date;
462
463 for (ntp = 0; ntp < 0xFFFFFFFFu - 80000u; ntp += 80000u) {
464 truds = caldaystart(ntp, &pivot);
465 ntpcal_ntp_to_date(&date, ntp, &pivot);
466 date.hour = date.minute = date.second = 0;
467 expds = ntpcal_date_to_ntp(&date);
468 TEST_ASSERT_EQUAL(expds, truds);
469 }
470
471 return;
472 }
473
474 /* ---------------------------------------------------------------------
475 * ISO8601 week calendar internals
476 *
477 * The ISO8601 week calendar implementation is simple in the terms of
478 * the math involved, but the implementation of the calculations must
479 * take care of a few things like overflow, floor division, and sign
480 * corrections.
481 *
482 * Most of the functions are straight forward, but converting from years
483 * to weeks and from weeks to years warrants some extra tests. These use
484 * an independent reference implementation of the conversion from years
485 * to weeks.
486 * ---------------------------------------------------------------------
487 */
488
489 /* helper / reference implementation for the first week of year in the
490 * ISO8601 week calendar. This is based on the reference definition of
491 * the ISO week calendar start: The Monday closest to January,1st of the
492 * corresponding year in the Gregorian calendar.
493 */
494 static int32_t
refimpl_WeeksInIsoYears(int32_t years)495 refimpl_WeeksInIsoYears(
496 int32_t years)
497 {
498 int32_t days, weeks;
499
500 days = ntpcal_weekday_close(
501 ntpcal_days_in_years(years) + 1,
502 CAL_MONDAY) - 1;
503 /* the weekday functions operate on RDN, while we want elapsed
504 * units here -- we have to add / sub 1 in the midlle / at the
505 * end of the operation that gets us the first day of the ISO
506 * week calendar day.
507 */
508 weeks = days / 7;
509 days = days % 7;
510 TEST_ASSERT_EQUAL(0, days); /* paranoia check... */
511
512 return weeks;
513 }
514
515 /* The next tests loop over 5000yrs, but should still be very fast. If
516 * they are not, the calendar needs a better implementation...
517 */
518 void
test_IsoCalYearsToWeeks(void)519 test_IsoCalYearsToWeeks(void)
520 {
521 int32_t years;
522 int32_t wref, wcal;
523
524 for (years = -1000; years < 4000; ++years) {
525 /* get number of weeks before years (reference) */
526 wref = refimpl_WeeksInIsoYears(years);
527 /* get number of weeks before years (object-under-test) */
528 wcal = isocal_weeks_in_years(years);
529 TEST_ASSERT_EQUAL(wref, wcal);
530 }
531
532 return;
533 }
534
535 void
test_IsoCalWeeksToYearStart(void)536 test_IsoCalWeeksToYearStart(void)
537 {
538 int32_t years;
539 int32_t wref;
540 ntpcal_split ysplit;
541
542 for (years = -1000; years < 4000; ++years) {
543 /* get number of weeks before years (reference) */
544 wref = refimpl_WeeksInIsoYears(years);
545 /* reverse split */
546 ysplit = isocal_split_eraweeks(wref);
547 /* check invariants: same year, week 0 */
548 TEST_ASSERT_EQUAL(years, ysplit.hi);
549 TEST_ASSERT_EQUAL(0, ysplit.lo);
550 }
551
552 return;
553 }
554
555 void
test_IsoCalWeeksToYearEnd(void)556 test_IsoCalWeeksToYearEnd(void)
557 {
558 int32_t years;
559 int32_t wref;
560 ntpcal_split ysplit;
561
562 for (years = -1000; years < 4000; ++years) {
563 /* get last week of previous year */
564 wref = refimpl_WeeksInIsoYears(years) - 1;
565 /* reverse split */
566 ysplit = isocal_split_eraweeks(wref);
567 /* check invariants: previous year, week 51 or 52 */
568 TEST_ASSERT_EQUAL(years-1, ysplit.hi);
569 TEST_ASSERT(ysplit.lo == 51 || ysplit.lo == 52);
570 }
571
572 return;
573 }
574
575 void
test_DaySecToDate(void)576 test_DaySecToDate(void)
577 {
578 struct calendar cal;
579 int32_t days;
580
581 days = ntpcal_daysec_to_date(&cal, -86400);
582 TEST_ASSERT_MESSAGE((days==-1 && cal.hour==0 && cal.minute==0 && cal.second==0),
583 "failed for -86400");
584
585 days = ntpcal_daysec_to_date(&cal, -86399);
586 TEST_ASSERT_MESSAGE((days==-1 && cal.hour==0 && cal.minute==0 && cal.second==1),
587 "failed for -86399");
588
589 days = ntpcal_daysec_to_date(&cal, -1);
590 TEST_ASSERT_MESSAGE((days==-1 && cal.hour==23 && cal.minute==59 && cal.second==59),
591 "failed for -1");
592
593 days = ntpcal_daysec_to_date(&cal, 0);
594 TEST_ASSERT_MESSAGE((days==0 && cal.hour==0 && cal.minute==0 && cal.second==0),
595 "failed for 0");
596
597 days = ntpcal_daysec_to_date(&cal, 1);
598 TEST_ASSERT_MESSAGE((days==0 && cal.hour==0 && cal.minute==0 && cal.second==1),
599 "failed for 1");
600
601 days = ntpcal_daysec_to_date(&cal, 86399);
602 TEST_ASSERT_MESSAGE((days==0 && cal.hour==23 && cal.minute==59 && cal.second==59),
603 "failed for 86399");
604
605 days = ntpcal_daysec_to_date(&cal, 86400);
606 TEST_ASSERT_MESSAGE((days==1 && cal.hour==0 && cal.minute==0 && cal.second==0),
607 "failed for 86400");
608
609 return;
610 }
611