clocktime.c revision 293896 
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	return;
37}
38
39void
40tearDown()
41{
42	ntpcal_set_timefunc(NULL);
43
44	return;
45}
46
47/* ---------------------------------------------------------------------
48 * test cases
49 */
50
51void
52test_CurrentYear(void)
53{
54	/* Timestamp: 2010-06-24 12:50:00Z */
55	const u_int32 timestamp = 3486372600UL;
56	const u_int32 expected	= timestamp; /* exactly the same. */
57
58	const int yday=175, hour=12, minute=50, second=0, tzoff=0;
59
60	u_long yearstart = 0;
61	u_int32 actual;
62
63	TEST_ASSERT_TRUE(clocktime(yday, hour, minute, second, tzoff,
64				   timestamp, &yearstart, &actual));
65	TEST_ASSERT_EQUAL(expected, actual);
66
67	return;
68}
69
70void
71test_CurrentYearFuzz(void)
72{
73	/*
74	 * Timestamp (rec_ui) is: 2010-06-24 12:50:00
75	 * Time sent into function is 12:00:00.
76	 *
77	 * Since the fuzz is rather small, we should get a NTP
78	 * timestamp for the 12:00:00 time.
79	 */
80
81	const u_int32 timestamp = 3486372600UL; /* 2010-06-24 12:50:00Z */
82	const u_int32 expected	= 3486369600UL; /* 2010-06-24 12:00:00Z */
83
84	const int yday=175, hour=12, minute=0, second=0, tzoff=0;
85
86	u_long yearstart=0;
87	u_int32 actual;
88
89	TEST_ASSERT_TRUE(clocktime(yday, hour, minute, second, tzoff,
90				   timestamp, &yearstart, &actual));
91	TEST_ASSERT_EQUAL(expected, actual);
92
93	return;
94}
95
96void
97test_TimeZoneOffset(void)
98{
99	/*
100	 * Timestamp (rec_ui) is: 2010-06-24 12:00:00 +0800
101	 * (which is 2010-06-24 04:00:00Z)
102	 *
103	 * Time sent into function is 04:00:00 +0800
104	 */
105	const u_int32 timestamp = 3486369600UL;
106	const u_int32 expected	= timestamp;
107
108	const int yday=175, hour=4, minute=0, second=0, tzoff=8;
109
110	u_long yearstart=0;
111	u_int32 actual;
112
113	TEST_ASSERT_TRUE(clocktime(yday, hour, minute, second, tzoff, timestamp,
114						  &yearstart, &actual));
115	TEST_ASSERT_EQUAL(expected, actual);
116}
117
118void
119test_WrongYearStart(void)
120{
121	/*
122	 * Timestamp (rec_ui) is: 2010-01-02 11:00:00Z
123	 * Time sent into function is 11:00:00.
124	 * Yearstart sent into function is the yearstart of 2009!
125	 */
126	const u_int32 timestamp = 3471418800UL;
127	const u_int32 expected	= timestamp;
128
129	const int yday=2, hour=11, minute=0, second=0, tzoff=0;
130
131	u_long yearstart = 302024100UL; /* Yearstart of 2009. */
132	u_int32 actual;
133
134	TEST_ASSERT_TRUE(clocktime(yday, hour, minute, second, tzoff, timestamp,
135						  &yearstart, &actual));
136	TEST_ASSERT_EQUAL(expected, actual);
137}
138
139void
140test_PreviousYear(void)
141{
142	/*
143	 * Timestamp is: 2010-01-01 01:00:00Z
144	 * Time sent into function is 23:00:00
145	 * (which is meant to be 2009-12-31 23:00:00Z)
146	 */
147	const u_int32 timestamp = 3471296400UL;
148	const u_int32 expected	= 3471289200UL;
149
150	const int yday=365, hour=23, minute=0, second=0, tzoff=0;
151
152	u_long yearstart = 0;
153	u_int32 actual;
154
155	TEST_ASSERT_TRUE(clocktime(yday, hour, minute, second, tzoff, timestamp,
156						  &yearstart, &actual));
157	TEST_ASSERT_EQUAL(expected, actual);
158}
159
160void
161test_NextYear(void)
162{
163	/*
164	 * Timestamp is: 2009-12-31 23:00:00Z
165	 * Time sent into function is 01:00:00
166	 * (which is meant to be 2010-01-01 01:00:00Z)
167	 */
168	const u_int32 timestamp = 3471289200UL;
169	const u_int32 expected	= 3471296400UL;
170
171	const int yday=1, hour=1, minute=0, second=0, tzoff=0;
172	u_long yearstart = 0;
173	u_int32 actual;
174
175	TEST_ASSERT_TRUE(clocktime(yday, hour, minute, second, tzoff,
176				   timestamp, &yearstart, &actual));
177	TEST_ASSERT_EQUAL(expected, actual);
178
179	return;
180}
181
182void
183test_NoReasonableConversion(void)
184{
185	/* Timestamp is: 2010-01-02 11:00:00Z */
186	const u_int32 timestamp = 3471418800UL;
187
188	const int yday=100, hour=12, minute=0, second=0, tzoff=0;
189	u_long yearstart = 0;
190	u_int32 actual;
191
192	TEST_ASSERT_FALSE(clocktime(yday, hour, minute, second, tzoff,
193				    timestamp, &yearstart, &actual));
194
195	return;
196}
197
198
199int/*BOOL*/
200isLE(u_int32 diff,u_int32 actual)
201{
202
203	if (diff <= actual) {
204		return TRUE;
205	}
206	else return FALSE;
207}
208
209
210void
211test_AlwaysInLimit(void)
212{
213	/* Timestamp is: 2010-01-02 11:00:00Z */
214	const u_int32 timestamp = 3471418800UL;
215	const u_short prime_incs[] = { 127, 151, 163, 179 };
216	int	cyc;
217	int	yday;
218	u_char	whichprime;
219	u_short	ydayinc;
220	int	hour;
221	int	minute;
222	u_long	yearstart;
223	u_int32	actual;
224	u_int32	diff;
225
226	yearstart = 0;
227	for (cyc = 0; cyc < 5; cyc++) {
228		settime(1900 + cyc * 65, 1, 1, 0, 0, 0);
229		for (yday = -26000; yday < 26000; yday += ydayinc) {
230			whichprime = abs(yday) % COUNTOF(prime_incs);
231			ydayinc = prime_incs[whichprime];
232			for (hour = -204; hour < 204; hour += 2) {
233				for (minute = -60; minute < 60; minute++) {
234					clocktime(yday, hour, minute, 30, 0,
235						  timestamp, &yearstart,
236						  &actual);
237					diff = actual - timestamp;
238					if (diff >= 0x80000000UL)
239						diff = ~diff + 1;
240					TEST_ASSERT_TRUE(isLE(diff, (183u * SECSPERDAY)));
241				}
242			}
243		}
244	}
245	return;
246}
247