clocktime.c revision 290001 
1#include "config.h"
2
3#include "ntp_calendar.h"
4#include "ntp_stdlib.h"
5
6#include "unity.h"
7#include "test-libntp.h"
8
9void setUp(void);
10void tearDown(void);
11void test_CurrentYear(void);
12void test_CurrentYearFuzz(void);
13void test_TimeZoneOffset(void);
14void test_WrongYearStart(void);
15void test_PreviousYear(void);
16void test_NextYear(void);
17void test_NoReasonableConversion(void);
18int isLE(u_int32 diff,u_int32 actual);
19void test_AlwaysInLimit(void);
20
21
22/* ---------------------------------------------------------------------
23 * test fixture
24 *
25 * The clocktimeTest uses the NTP calendar feature to use a mockup
26 * function for getting the current system time, so the tests are not
27 * dependent on the actual system time.
28 */
29
30void
31setUp()
32{
33    ntpcal_set_timefunc(timefunc);
34    settime(2000, 1, 1, 0, 0, 0);
35}
36
37void
38tearDown()
39{
40    ntpcal_set_timefunc(NULL);
41}
42
43/* ---------------------------------------------------------------------
44 * test cases
45 */
46
47void
48test_CurrentYear(void) {
49	/* Timestamp: 2010-06-24 12:50:00Z */
50	const u_int32 timestamp = 3486372600UL;
51	const u_int32 expected	= timestamp; /* exactly the same. */
52
53	const int yday=175, hour=12, minute=50, second=0, tzoff=0;
54
55	u_long yearstart=0;
56	u_int32 actual;
57
58	TEST_ASSERT_TRUE(clocktime(yday, hour, minute, second, tzoff, timestamp,
59						  &yearstart, &actual));
60	TEST_ASSERT_EQUAL(expected, actual);
61}
62
63void
64test_CurrentYearFuzz(void) {
65	/*
66	 * Timestamp (rec_ui) is: 2010-06-24 12:50:00
67	 * Time sent into function is 12:00:00.
68	 *
69	 * Since the fuzz is rather small, we should get a NTP
70	 * timestamp for the 12:00:00 time.
71	 */
72
73	const u_int32 timestamp = 3486372600UL; /* 2010-06-24 12:50:00Z */
74	const u_int32 expected	= 3486369600UL; /* 2010-06-24 12:00:00Z */
75
76	const int yday=175, hour=12, minute=0, second=0, tzoff=0;
77
78	u_long yearstart=0;
79	u_int32 actual;
80
81	TEST_ASSERT_TRUE(clocktime(yday, hour, minute, second, tzoff, timestamp,
82						  &yearstart, &actual));
83	TEST_ASSERT_EQUAL(expected, actual);
84}
85
86void
87test_TimeZoneOffset(void) {
88	/*
89	 * Timestamp (rec_ui) is: 2010-06-24 12:00:00 +0800
90	 * (which is 2010-06-24 04:00:00Z)
91	 *
92	 * Time sent into function is 04:00:00 +0800
93	 */
94	const u_int32 timestamp = 3486369600UL;
95	const u_int32 expected	= timestamp;
96
97	const int yday=175, hour=4, minute=0, second=0, tzoff=8;
98
99	u_long yearstart=0;
100	u_int32 actual;
101
102	TEST_ASSERT_TRUE(clocktime(yday, hour, minute, second, tzoff, timestamp,
103						  &yearstart, &actual));
104	TEST_ASSERT_EQUAL(expected, actual);
105}
106
107void
108test_WrongYearStart(void) {
109	/*
110	 * Timestamp (rec_ui) is: 2010-01-02 11:00:00Z
111	 * Time sent into function is 11:00:00.
112	 * Yearstart sent into function is the yearstart of 2009!
113	 */
114	const u_int32 timestamp = 3471418800UL;
115	const u_int32 expected	= timestamp;
116
117	const int yday=2, hour=11, minute=0, second=0, tzoff=0;
118
119	u_long yearstart = 302024100UL; /* Yearstart of 2009. */
120	u_int32 actual;
121
122	TEST_ASSERT_TRUE(clocktime(yday, hour, minute, second, tzoff, timestamp,
123						  &yearstart, &actual));
124	TEST_ASSERT_EQUAL(expected, actual);
125}
126
127void
128test_PreviousYear(void) {
129	/*
130	 * Timestamp is: 2010-01-01 01:00:00Z
131	 * Time sent into function is 23:00:00
132	 * (which is meant to be 2009-12-31 23:00:00Z)
133	 */
134	const u_int32 timestamp = 3471296400UL;
135	const u_int32 expected	= 3471289200UL;
136
137	const int yday=365, hour=23, minute=0, second=0, tzoff=0;
138
139	u_long yearstart = 0;
140	u_int32 actual;
141
142	TEST_ASSERT_TRUE(clocktime(yday, hour, minute, second, tzoff, timestamp,
143						  &yearstart, &actual));
144	TEST_ASSERT_EQUAL(expected, actual);
145}
146
147void
148test_NextYear(void) {
149	/*
150	 * Timestamp is: 2009-12-31 23:00:00Z
151	 * Time sent into function is 01:00:00
152	 * (which is meant to be 2010-01-01 01:00:00Z)
153	 */
154	const u_int32 timestamp = 3471289200UL;
155	const u_int32 expected	= 3471296400UL;
156
157	const int yday=1, hour=1, minute=0, second=0, tzoff=0;
158	u_long yearstart = 0;
159	u_int32 actual;
160
161	TEST_ASSERT_TRUE(clocktime(yday, hour, minute, second, tzoff, timestamp,
162						  &yearstart, &actual));
163	TEST_ASSERT_EQUAL(expected, actual);
164}
165
166void
167test_NoReasonableConversion(void) {
168	/* Timestamp is: 2010-01-02 11:00:00Z */
169	const u_int32 timestamp = 3471418800UL;
170
171	const int yday=100, hour=12, minute=0, second=0, tzoff=0;
172	u_long yearstart = 0;
173	u_int32 actual;
174
175	TEST_ASSERT_FALSE(clocktime(yday, hour, minute, second, tzoff, timestamp,
176						   &yearstart, &actual));
177}
178
179
180int/*BOOL*/
181isLE(u_int32 diff,u_int32 actual){
182	if(diff <= actual){
183		return TRUE;
184	}
185	else return FALSE;
186}
187
188
189void
190test_AlwaysInLimit(void) {
191	/* Timestamp is: 2010-01-02 11:00:00Z */
192	const u_int32 timestamp = 3471418800UL;
193	const u_short prime_incs[] = { 127, 151, 163, 179 };
194	int	cyc;
195	int	yday;
196	u_char	whichprime;
197	u_short	ydayinc;
198	int	hour;
199	int	minute;
200	u_long	yearstart;
201	u_int32	actual;
202	u_int32	diff;
203
204	yearstart = 0;
205	for (cyc = 0; cyc < 5; cyc++) {
206		settime(1900 + cyc * 65, 1, 1, 0, 0, 0);
207		for (yday = -26000; yday < 26000; yday += ydayinc) {
208			whichprime = abs(yday) % COUNTOF(prime_incs);
209			ydayinc = prime_incs[whichprime];
210			for (hour = -204; hour < 204; hour += 2) {
211				for (minute = -60; minute < 60; minute++) {
212					clocktime(yday, hour, minute, 30, 0,
213						  timestamp, &yearstart, &actual);
214					diff = actual - timestamp;
215					if (diff >= 0x80000000UL)
216						diff = ~diff + 1;
217					TEST_ASSERT_TRUE(isLE(diff, (183u * SECSPERDAY)));
218				}
219			}
220		}
221	}
222}
223