ReactOS  0.4.12-dev-685-gf36cbf7
time.c
Go to the documentation of this file.
1 /*
2  * Unit test suite for time functions
3  *
4  * Copyright 2004 Uwe Bonnes
5  * Copyright 2007 Dmitry Timoshkov
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21 
22 #include "wine/test.h"
23 #include "winbase.h"
24 #include "winnls.h"
25 #include "winternl.h"
26 
27 static BOOL (WINAPI *pTzSpecificLocalTimeToSystemTime)(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME);
28 static BOOL (WINAPI *pSystemTimeToTzSpecificLocalTime)(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME);
29 static BOOL (WINAPI *pGetSystemTimes)(LPFILETIME, LPFILETIME, LPFILETIME);
30 static int (WINAPI *pGetCalendarInfoA)(LCID,CALID,CALTYPE,LPSTR,int,LPDWORD);
31 static int (WINAPI *pGetCalendarInfoW)(LCID,CALID,CALTYPE,LPWSTR,int,LPDWORD);
32 static DWORD (WINAPI *pGetDynamicTimeZoneInformation)(DYNAMIC_TIME_ZONE_INFORMATION*);
33 static void (WINAPI *pGetSystemTimePreciseAsFileTime)(LPFILETIME);
34 static BOOL (WINAPI *pGetTimeZoneInformationForYear)(USHORT, PDYNAMIC_TIME_ZONE_INFORMATION, LPTIME_ZONE_INFORMATION);
35 
36 #define SECSPERMIN 60
37 #define SECSPERDAY 86400
38 /* 1601 to 1970 is 369 years plus 89 leap days */
39 #define SECS_1601_TO_1970 ((369 * 365 + 89) * (ULONGLONG)SECSPERDAY)
40 #define TICKSPERSEC 10000000
41 #define TICKSPERMSEC 10000
42 #define TICKS_1601_TO_1970 (SECS_1601_TO_1970 * TICKSPERSEC)
43 
44 
45 #define NEWYEAR_1980_HI 0x01a8e79f
46 #define NEWYEAR_1980_LO 0xe1d58000
47 
48 #define MAYDAY_2002_HI 0x01c1f107
49 #define MAYDAY_2002_LO 0xb82b6000
50 
51 #define ATIME_HI 0x1c2349b
52 #define ATIME_LOW 0x580716b0
53 
54 #define LOCAL_ATIME_HI 0x01c23471
55 #define LOCAL_ATIME_LOW 0x6f310eb0
56 
57 #define DOS_DATE(y,m,d) ( (((y)-1980)<<9) | ((m)<<5) | (d) )
58 #define DOS_TIME(h,m,s) ( ((h)<<11) | ((m)<<5) | ((s)>>1) )
59 
60 
61 #define SETUP_1980(st) \
62  (st).wYear = 1980; \
63  (st).wMonth = 1; \
64  (st).wDay = 1; \
65  (st).wHour = 0; \
66  (st).wMinute = 0; \
67  (st).wSecond = 0; \
68  (st).wMilliseconds = 0;
69 
70 #define SETUP_2002(st) \
71  (st).wYear = 2002; \
72  (st).wMonth = 5; \
73  (st).wDay = 1; \
74  (st).wHour = 12; \
75  (st).wMinute = 0; \
76  (st).wSecond = 0; \
77  (st).wMilliseconds = 0;
78 
79 #define SETUP_ATIME(st) \
80  (st).wYear = 2002; \
81  (st).wMonth = 7; \
82  (st).wDay = 26; \
83  (st).wHour = 11; \
84  (st).wMinute = 55; \
85  (st).wSecond = 32; \
86  (st).wMilliseconds = 123;
87 
88 #define SETUP_ZEROTIME(st) \
89  (st).wYear = 1601; \
90  (st).wMonth = 1; \
91  (st).wDay = 1; \
92  (st).wHour = 0; \
93  (st).wMinute = 0; \
94  (st).wSecond = 0; \
95  (st).wMilliseconds = 0;
96 
97 #define SETUP_EARLY(st) \
98  (st).wYear = 1600; \
99  (st).wMonth = 12; \
100  (st).wDay = 31; \
101  (st).wHour = 23; \
102  (st).wMinute = 59; \
103  (st).wSecond = 59; \
104  (st).wMilliseconds = 999;
105 
106 
107 static void test_conversions(void)
108 {
109  FILETIME ft;
110  SYSTEMTIME st;
111 
112  memset(&ft,0,sizeof ft);
113 
114  SetLastError(0xdeadbeef);
115  SETUP_EARLY(st)
116  ok (!SystemTimeToFileTime(&st, &ft), "Conversion succeeded EARLY\n");
118  GetLastError() == 0xdeadbeef, /* win9x */
119  "EARLY should be INVALID\n");
120 
121  SETUP_ZEROTIME(st)
122  ok (SystemTimeToFileTime(&st, &ft), "Conversion failed ZERO_TIME\n");
123  ok( (!((ft.dwHighDateTime != 0) || (ft.dwLowDateTime != 0))),
124  "Wrong time for ATIME: %08x %08x (correct %08x %08x)\n",
125  ft.dwLowDateTime, ft.dwHighDateTime, 0, 0);
126 
127 
128  SETUP_ATIME(st)
129  ok (SystemTimeToFileTime(&st,&ft), "Conversion Failed ATIME\n");
130  ok( (!((ft.dwHighDateTime != ATIME_HI) || (ft.dwLowDateTime!=ATIME_LOW))),
131  "Wrong time for ATIME: %08x %08x (correct %08x %08x)\n",
133 
134 
135  SETUP_2002(st)
136  ok (SystemTimeToFileTime(&st, &ft), "Conversion failed 2002\n");
137 
138  ok( (!((ft.dwHighDateTime != MAYDAY_2002_HI) ||
140  "Wrong time for 2002 %08x %08x (correct %08x %08x)\n", ft.dwLowDateTime,
142 
143 
144  SETUP_1980(st)
145  ok((SystemTimeToFileTime(&st, &ft)), "Conversion failed 1980\n");
146 
147  ok( (!((ft.dwHighDateTime!=NEWYEAR_1980_HI) ||
149  "Wrong time for 1980 %08x %08x (correct %08x %08x)\n", ft.dwLowDateTime,
151 
152  ok(DosDateTimeToFileTime(DOS_DATE(1980,1,1),DOS_TIME(0,0,0),&ft),
153  "DosDateTimeToFileTime() failed\n");
154 
155  ok( (!((ft.dwHighDateTime!=NEWYEAR_1980_HI) ||
157  "Wrong time DosDateTimeToFileTime %08x %08x (correct %08x %08x)\n",
159 
160 }
161 
162 static void test_invalid_arg(void)
163 {
164  FILETIME ft;
165  SYSTEMTIME st;
166 
167 
168  /* Invalid argument checks */
169 
170  memset(&ft,0,sizeof ft);
171  ok( DosDateTimeToFileTime(DOS_DATE(1980,1,1),DOS_TIME(0,0,0),&ft), /* this is 1 Jan 1980 00:00:00 */
172  "DosDateTimeToFileTime() failed\n");
173 
175  "filetime for 1/1/80 00:00:00 was %08x %08x\n", ft.dwHighDateTime, ft.dwLowDateTime);
176 
177  /* now check SystemTimeToFileTime */
178  memset(&ft,0,sizeof ft);
179 
180 
181  /* try with a bad month */
182  SETUP_1980(st)
183  st.wMonth = 0;
184 
185  ok( !SystemTimeToFileTime(&st, &ft), "bad month\n");
186 
187  /* with a bad hour */
188  SETUP_1980(st)
189  st.wHour = 24;
190 
191  ok( !SystemTimeToFileTime(&st, &ft), "bad hour\n");
192 
193  /* with a bad minute */
194  SETUP_1980(st)
195  st.wMinute = 60;
196 
197  ok( !SystemTimeToFileTime(&st, &ft), "bad minute\n");
198 }
199 
201 {
202  BOOL ret;
203  FILETIME ft;
204  LONGLONG minutes;
205 
206  SetLastError(0xdeadbeef);
207  ret = SystemTimeToFileTime(st, &ft);
208  ok(ret, "SystemTimeToFileTime error %u\n", GetLastError());
209 
210  minutes = ((LONGLONG)ft.dwHighDateTime << 32) + ft.dwLowDateTime;
211  minutes /= (LONGLONG)600000000; /* convert to minutes */
212  return minutes;
213 }
214 
215 static LONG get_tz_bias(const TIME_ZONE_INFORMATION *tzinfo, DWORD tz_id)
216 {
217  switch (tz_id)
218  {
220  if (memcmp(&tzinfo->StandardDate, &tzinfo->DaylightDate, sizeof(tzinfo->DaylightDate)) != 0)
221  return tzinfo->DaylightBias;
222  /* fall through */
223 
225  return tzinfo->StandardBias;
226 
227  default:
228  trace("unknown time zone id %d\n", tz_id);
229  /* fall through */
231  return 0;
232  }
233 }
234 
236 {
237  char std_name[32], dlt_name[32];
238  TIME_ZONE_INFORMATION tzinfo, tzinfo1;
239  BOOL res;
240  DWORD tz_id;
241  SYSTEMTIME st, current, utc, local;
242  FILETIME l_ft, s_ft;
243  LONGLONG l_time, s_time;
244  LONG diff;
245 
246  GetSystemTime(&st);
247  s_time = system_time_to_minutes(&st);
248 
249  SetLastError(0xdeadbeef);
250  res = SystemTimeToFileTime(&st, &s_ft);
251  ok(res, "SystemTimeToFileTime error %u\n", GetLastError());
252  SetLastError(0xdeadbeef);
253  res = FileTimeToLocalFileTime(&s_ft, &l_ft);
254  ok(res, "FileTimeToLocalFileTime error %u\n", GetLastError());
255  SetLastError(0xdeadbeef);
256  res = FileTimeToSystemTime(&l_ft, &local);
257  ok(res, "FileTimeToSystemTime error %u\n", GetLastError());
258  l_time = system_time_to_minutes(&local);
259 
260  tz_id = GetTimeZoneInformation(&tzinfo);
261  ok(tz_id != TIME_ZONE_ID_INVALID, "GetTimeZoneInformation failed\n");
262 
263  trace("tz_id %u (%s)\n", tz_id,
264  tz_id == TIME_ZONE_ID_DAYLIGHT ? "TIME_ZONE_ID_DAYLIGHT" :
265  (tz_id == TIME_ZONE_ID_STANDARD ? "TIME_ZONE_ID_STANDARD" :
266  (tz_id == TIME_ZONE_ID_UNKNOWN ? "TIME_ZONE_ID_UNKNOWN" :
267  "TIME_ZONE_ID_INVALID")));
268 
269  WideCharToMultiByte(CP_ACP, 0, tzinfo.StandardName, -1, std_name, sizeof(std_name), NULL, NULL);
270  WideCharToMultiByte(CP_ACP, 0, tzinfo.DaylightName, -1, dlt_name, sizeof(dlt_name), NULL, NULL);
271  trace("bias %d, %s - %s\n", tzinfo.Bias, std_name, dlt_name);
272  trace("standard (d/m/y): %u/%02u/%04u day of week %u %u:%02u:%02u.%03u bias %d\n",
273  tzinfo.StandardDate.wDay, tzinfo.StandardDate.wMonth,
274  tzinfo.StandardDate.wYear, tzinfo.StandardDate.wDayOfWeek,
275  tzinfo.StandardDate.wHour, tzinfo.StandardDate.wMinute,
277  tzinfo.StandardBias);
278  trace("daylight (d/m/y): %u/%02u/%04u day of week %u %u:%02u:%02u.%03u bias %d\n",
279  tzinfo.DaylightDate.wDay, tzinfo.DaylightDate.wMonth,
280  tzinfo.DaylightDate.wYear, tzinfo.DaylightDate.wDayOfWeek,
281  tzinfo.DaylightDate.wHour, tzinfo.DaylightDate.wMinute,
283  tzinfo.DaylightBias);
284 
285  diff = (LONG)(s_time - l_time);
286  ok(diff == tzinfo.Bias + get_tz_bias(&tzinfo, tz_id),
287  "system/local diff %d != tz bias %d\n",
288  diff, tzinfo.Bias + get_tz_bias(&tzinfo, tz_id));
289 
290  ok(SetEnvironmentVariableA("TZ","GMT0") != 0,
291  "SetEnvironmentVariableA failed\n");
292  res = GetTimeZoneInformation(&tzinfo1);
293  ok(res != TIME_ZONE_ID_INVALID, "GetTimeZoneInformation failed\n");
294 
295  ok(((tzinfo.Bias == tzinfo1.Bias) &&
296  (tzinfo.StandardBias == tzinfo1.StandardBias) &&
297  (tzinfo.DaylightBias == tzinfo1.DaylightBias)),
298  "Bias influenced by TZ variable\n");
299  ok(SetEnvironmentVariableA("TZ",NULL) != 0,
300  "SetEnvironmentVariableA failed\n");
301 
302  if (!pSystemTimeToTzSpecificLocalTime)
303  {
304  win_skip("SystemTimeToTzSpecificLocalTime not available\n");
305  return;
306  }
307 
308  diff = get_tz_bias(&tzinfo, tz_id);
309 
310  utc = st;
311  SetLastError(0xdeadbeef);
312  res = pSystemTimeToTzSpecificLocalTime(&tzinfo, &utc, &current);
314  {
315  win_skip("SystemTimeToTzSpecificLocalTime is not implemented\n");
316  return;
317  }
318 
319  ok(res, "SystemTimeToTzSpecificLocalTime error %u\n", GetLastError());
320  s_time = system_time_to_minutes(&current);
321 
322  tzinfo.StandardBias -= 123;
323  tzinfo.DaylightBias += 456;
324 
325  res = pSystemTimeToTzSpecificLocalTime(&tzinfo, &utc, &local);
326  ok(res, "SystemTimeToTzSpecificLocalTime error %u\n", GetLastError());
327  l_time = system_time_to_minutes(&local);
328  ok(l_time - s_time == diff - get_tz_bias(&tzinfo, tz_id), "got %d, expected %d\n",
329  (LONG)(l_time - s_time), diff - get_tz_bias(&tzinfo, tz_id));
330 
331  /* pretend that there is no transition dates */
332  tzinfo.DaylightDate.wDay = 0;
333  tzinfo.DaylightDate.wMonth = 0;
334  tzinfo.DaylightDate.wYear = 0;
335  tzinfo.StandardDate.wDay = 0;
336  tzinfo.StandardDate.wMonth = 0;
337  tzinfo.StandardDate.wYear = 0;
338 
339  res = pSystemTimeToTzSpecificLocalTime(&tzinfo, &utc, &local);
340  ok(res, "SystemTimeToTzSpecificLocalTime error %u\n", GetLastError());
341  l_time = system_time_to_minutes(&local);
342  ok(l_time - s_time == diff, "got %d, expected %d\n",
343  (LONG)(l_time - s_time), diff);
344 
345  /* test 23:01, 31st of December date */
346  memset(&tzinfo, 0, sizeof(tzinfo));
347  tzinfo.StandardDate.wMonth = 10;
348  tzinfo.StandardDate.wDay = 5;
349  tzinfo.StandardDate.wHour = 2;
350  tzinfo.StandardDate.wMinute = 0;
351  tzinfo.DaylightDate.wMonth = 4;
352  tzinfo.DaylightDate.wDay = 1;
353  tzinfo.DaylightDate.wHour = 2;
354  tzinfo.Bias = 0;
355  tzinfo.StandardBias = 0;
356  tzinfo.DaylightBias = -60;
357  utc.wYear = 2012;
358  utc.wMonth = 12;
359  utc.wDay = 31;
360  utc.wHour = 23;
361  utc.wMinute = 1;
362  res = pSystemTimeToTzSpecificLocalTime(&tzinfo, &utc, &local);
363  ok(res, "SystemTimeToTzSpecificLocalTime error %u\n", GetLastError());
364  ok(local.wYear==2012 && local.wMonth==12 && local.wDay==31 && local.wHour==23 && local.wMinute==1,
365  "got (%d-%d-%d %02d:%02d), expected (2012-12-31 23:01)\n",
366  local.wYear, local.wMonth, local.wDay, local.wHour, local.wMinute);
367 }
368 
369 static void test_FileTimeToSystemTime(void)
370 {
371  FILETIME ft;
372  SYSTEMTIME st;
374  BOOL ret;
375 
376  ft.dwHighDateTime = 0;
377  ft.dwLowDateTime = 0;
378  ret = FileTimeToSystemTime(&ft, &st);
379  ok( ret,
380  "FileTimeToSystemTime() failed with Error %d\n",GetLastError());
381  ok(((st.wYear == 1601) && (st.wMonth == 1) && (st.wDay == 1) &&
382  (st.wHour == 0) && (st.wMinute == 0) && (st.wSecond == 0) &&
383  (st.wMilliseconds == 0)),
384  "Got Year %4d Month %2d Day %2d\n", st.wYear, st.wMonth, st.wDay);
385 
386  ft.dwHighDateTime = (UINT)(time >> 32);
387  ft.dwLowDateTime = (UINT)time;
388  ret = FileTimeToSystemTime(&ft, &st);
389  ok( ret,
390  "FileTimeToSystemTime() failed with Error %d\n",GetLastError());
391  ok(((st.wYear == 1970) && (st.wMonth == 1) && (st.wDay == 1) &&
392  (st.wHour == 0) && (st.wMinute == 0) && (st.wSecond == 1) &&
393  (st.wMilliseconds == 0)),
394  "Got Year %4d Month %2d Day %2d Hour %2d Min %2d Sec %2d mSec %3d\n",
395  st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond,
396  st.wMilliseconds);
397 }
398 
400 {
401  FILETIME ft, lft;
402  SYSTEMTIME st;
403  TIME_ZONE_INFORMATION tzinfo;
404  DWORD res = GetTimeZoneInformation(&tzinfo);
406  (LONGLONG)(tzinfo.Bias +
407  ( res == TIME_ZONE_ID_STANDARD ? tzinfo.StandardBias :
408  ( res == TIME_ZONE_ID_DAYLIGHT ? tzinfo.DaylightBias : 0 ))) *
410  BOOL ret;
411 
412  ok( res != TIME_ZONE_ID_INVALID , "GetTimeZoneInformation failed\n");
413  ft.dwHighDateTime = (UINT)(time >> 32);
414  ft.dwLowDateTime = (UINT)time;
415  ret = FileTimeToLocalFileTime(&ft, &lft);
416  ok( ret,
417  "FileTimeToLocalFileTime() failed with Error %d\n",GetLastError());
418  FileTimeToSystemTime(&lft, &st);
419  ok(((st.wYear == 1970) && (st.wMonth == 1) && (st.wDay == 1) &&
420  (st.wHour == 0) && (st.wMinute == 0) && (st.wSecond == 1) &&
421  (st.wMilliseconds == 0)),
422  "Got Year %4d Month %2d Day %2d Hour %2d Min %2d Sec %2d mSec %3d\n",
423  st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond,
424  st.wMilliseconds);
425 
426  ok(SetEnvironmentVariableA("TZ","GMT") != 0,
427  "SetEnvironmentVariableA failed\n");
428  ok(res != TIME_ZONE_ID_INVALID, "GetTimeZoneInformation failed\n");
429  ret = FileTimeToLocalFileTime(&ft, &lft);
430  ok( ret,
431  "FileTimeToLocalFileTime() failed with Error %d\n",GetLastError());
432  FileTimeToSystemTime(&lft, &st);
433  ok(((st.wYear == 1970) && (st.wMonth == 1) && (st.wDay == 1) &&
434  (st.wHour == 0) && (st.wMinute == 0) && (st.wSecond == 1) &&
435  (st.wMilliseconds == 0)),
436  "Got Year %4d Month %2d Day %2d Hour %2d Min %2d Sec %2d mSec %3d\n",
437  st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond,
438  st.wMilliseconds);
439  ok(SetEnvironmentVariableA("TZ",NULL) != 0,
440  "SetEnvironmentVariableA failed\n");
441 }
442 
443 typedef struct {
444  int nr; /* test case number for easier lookup */
445  TIME_ZONE_INFORMATION *ptz; /* ptr to timezone */
446  SYSTEMTIME slt; /* system/local time to convert */
447  WORD ehour; /* expected hour */
448 } TZLT2ST_case;
449 
451 {
452  TIME_ZONE_INFORMATION tzE, tzW, tzS;
454  int i, j, year;
455 
456  if (!pTzSpecificLocalTimeToSystemTime || !pSystemTimeToTzSpecificLocalTime)
457  {
458  win_skip("TzSpecificLocalTimeToSystemTime or SystemTimeToTzSpecificLocalTime not available\n");
459  return;
460  }
461 
462  ZeroMemory( &tzE, sizeof(tzE));
463  ZeroMemory( &tzW, sizeof(tzW));
464  ZeroMemory( &tzS, sizeof(tzS));
465  /* timezone Eastern hemisphere */
466  tzE.Bias=-600;
467  tzE.StandardBias=0;
468  tzE.DaylightBias=-60;
469  tzE.StandardDate.wMonth=10;
470  tzE.StandardDate.wDayOfWeek=0; /* Sunday */
471  tzE.StandardDate.wDay=5; /* last (Sunday) of the month */
472  tzE.StandardDate.wHour=3;
473  tzE.DaylightDate.wMonth=3;
474  tzE.DaylightDate.wDay=5;
475  tzE.DaylightDate.wHour=2;
476  /* timezone Western hemisphere */
477  tzW.Bias=240;
478  tzW.StandardBias=0;
479  tzW.DaylightBias=-60;
480  tzW.StandardDate.wMonth=10;
481  tzW.StandardDate.wDayOfWeek=0; /* Sunday */
482  tzW.StandardDate.wDay=4; /* 4th (Sunday) of the month */
483  tzW.StandardDate.wHour=2;
484  tzW.DaylightDate.wMonth=4;
485  tzW.DaylightDate.wDay=1;
486  tzW.DaylightDate.wHour=2;
487  /* timezone Southern hemisphere */
488  tzS.Bias=240;
489  tzS.StandardBias=0;
490  tzS.DaylightBias=-60;
491  tzS.StandardDate.wMonth=4;
492  tzS.StandardDate.wDayOfWeek=0; /*Sunday */
493  tzS.StandardDate.wDay=1; /* 1st (Sunday) of the month */
494  tzS.StandardDate.wHour=2;
495  tzS.DaylightDate.wMonth=10;
496  tzS.DaylightDate.wDay=4;
497  tzS.DaylightDate.wHour=2;
498  /*tests*/
499  /* TzSpecificLocalTimeToSystemTime */
500  { TZLT2ST_case cases[] = {
501  /* standard->daylight transition */
502  { 1, &tzE, {2004,3,-1,28,1,0,0,0}, 15 },
503  { 2, &tzE, {2004,3,-1,28,1,59,59,999}, 15},
504  { 3, &tzE, {2004,3,-1,28,2,0,0,0}, 15},
505  /* daylight->standard transition */
506  { 4, &tzE, {2004,10,-1,31,2,0,0,0} , 15 },
507  { 5, &tzE, {2004,10,-1,31,2,59,59,999}, 15 },
508  { 6, &tzE, {2004,10,-1,31,3,0,0,0}, 17 },
509  /* West and with fixed weekday of the month */
510  { 7, &tzW, {2004,4,-1,4,1,0,0,0}, 5},
511  { 8, &tzW, {2004,4,-1,4,1,59,59,999}, 5},
512  { 9, &tzW, {2004,4,-1,4,2,0,0,0}, 5},
513  { 10, &tzW, {2004,10,-1,24,1,0,0,0}, 4},
514  { 11, &tzW, {2004,10,-1,24,1,59,59,999}, 4},
515  { 12, &tzW, {2004,10,-1,24,2,0,0,0 }, 6},
516  /* and now South */
517  { 13, &tzS, {2004,4,-1,4,1,0,0,0}, 4},
518  { 14, &tzS, {2004,4,-1,4,1,59,59,999}, 4},
519  { 15, &tzS, {2004,4,-1,4,2,0,0,0}, 6},
520  { 16, &tzS, {2004,10,-1,24,1,0,0,0}, 5},
521  { 17, &tzS, {2004,10,-1,24,1,59,59,999}, 5},
522  { 18, &tzS, {2004,10,-1,24,2,0,0,0}, 5},
523  {0}
524  };
525  /* days of transitions to put into the cases array */
526  int yeardays[][6]=
527  {
528  {28,31,4,24,4,24} /* 1999 */
529  , {26,29,2,22,2,22} /* 2000 */
530  , {25,28,1,28,1,28} /* 2001 */
531  , {31,27,7,27,7,27} /* 2002 */
532  , {30,26,6,26,6,26} /* 2003 */
533  , {28,31,4,24,4,24} /* 2004 */
534  , {27,30,3,23,3,23} /* 2005 */
535  , {26,29,2,22,2,22} /* 2006 */
536  , {25,28,1,28,1,28} /* 2007 */
537  , {30,26,6,26,6,26} /* 2008 */
538  , {29,25,5,25,5,25} /* 2009 */
539  , {28,31,4,24,4,24} /* 2010 */
540  , {27,30,3,23,3,23} /* 2011 */
541  , {25,28,1,28,1,28} /* 2012 */
542  , {31,27,7,27,7,27} /* 2013 */
543  , {30,26,6,26,6,26} /* 2014 */
544  , {29,25,5,25,5,25} /* 2015 */
545  , {27,30,3,23,3,23} /* 2016 */
546  , {26,29,2,22,2,22} /* 2017 */
547  , {25,28,1,28,1,28} /* 2018 */
548  , {31,27,7,27,7,27} /* 2019 */
549  ,{0}
550  };
551  for( j=0 , year = 1999; yeardays[j][0] ; j++, year++) {
552  for (i=0; cases[i].nr; i++) {
553  if(i) cases[i].nr += 18;
554  cases[i].slt.wYear = year;
555  cases[i].slt.wDay = yeardays[j][i/3];
556  pTzSpecificLocalTimeToSystemTime( cases[i].ptz, &(cases[i].slt), &result);
557  ok( result.wHour == cases[i].ehour,
558  "Test TzSpecificLocalTimeToSystemTime #%d. Got %4d-%02d-%02d %02d:%02d. Expect hour = %02d\n",
559  cases[i].nr, result.wYear, result.wMonth, result.wDay,
560  result.wHour, result.wMinute, cases[i].ehour);
561  }
562  }
563  }
564  /* SystemTimeToTzSpecificLocalTime */
565  { TZLT2ST_case cases[] = {
566  /* standard->daylight transition */
567  { 1, &tzE, {2004,3,-1,27,15,0,0,0}, 1 },
568  { 2, &tzE, {2004,3,-1,27,15,59,59,999}, 1},
569  { 3, &tzE, {2004,3,-1,27,16,0,0,0}, 3},
570  /* daylight->standard transition */
571  { 4, &tzE, {2004,10,-1,30,15,0,0,0}, 2 },
572  { 5, &tzE, {2004,10,-1,30,15,59,59,999}, 2 },
573  { 6, &tzE, {2004,10,-1,30,16,0,0,0}, 2 },
574  /* West and with fixed weekday of the month */
575  { 7, &tzW, {2004,4,-1,4,5,0,0,0}, 1},
576  { 8, &tzW, {2004,4,-1,4,5,59,59,999}, 1},
577  { 9, &tzW, {2004,4,-1,4,6,0,0,0}, 3},
578  { 10, &tzW, {2004,10,-1,24,4,0,0,0}, 1},
579  { 11, &tzW, {2004,10,-1,24,4,59,59,999}, 1},
580  { 12, &tzW, {2004,10,-1,24,5,0,0,0 }, 1},
581  /* and now South */
582  { 13, &tzS, {2004,4,-1,4,4,0,0,0}, 1},
583  { 14, &tzS, {2004,4,-1,4,4,59,59,999}, 1},
584  { 15, &tzS, {2004,4,-1,4,5,0,0,0}, 1},
585  { 16, &tzS, {2004,10,-1,24,5,0,0,0}, 1},
586  { 17, &tzS, {2004,10,-1,24,5,59,59,999}, 1},
587  { 18, &tzS, {2004,10,-1,24,6,0,0,0}, 3},
588 
589  {0}
590  };
591  /* days of transitions to put into the cases array */
592  int yeardays[][6]=
593  {
594  {27,30,4,24,4,24} /* 1999 */
595  , {25,28,2,22,2,22} /* 2000 */
596  , {24,27,1,28,1,28} /* 2001 */
597  , {30,26,7,27,7,27} /* 2002 */
598  , {29,25,6,26,6,26} /* 2003 */
599  , {27,30,4,24,4,24} /* 2004 */
600  , {26,29,3,23,3,23} /* 2005 */
601  , {25,28,2,22,2,22} /* 2006 */
602  , {24,27,1,28,1,28} /* 2007 */
603  , {29,25,6,26,6,26} /* 2008 */
604  , {28,24,5,25,5,25} /* 2009 */
605  , {27,30,4,24,4,24} /* 2010 */
606  , {26,29,3,23,3,23} /* 2011 */
607  , {24,27,1,28,1,28} /* 2012 */
608  , {30,26,7,27,7,27} /* 2013 */
609  , {29,25,6,26,6,26} /* 2014 */
610  , {28,24,5,25,5,25} /* 2015 */
611  , {26,29,3,23,3,23} /* 2016 */
612  , {25,28,2,22,2,22} /* 2017 */
613  , {24,27,1,28,1,28} /* 2018 */
614  , {30,26,7,27,7,27} /* 2019 */
615  , {0}
616  };
617  for( j=0 , year = 1999; yeardays[j][0] ; j++, year++) {
618  for (i=0; cases[i].nr; i++) {
619  if(i) cases[i].nr += 18;
620  cases[i].slt.wYear = year;
621  cases[i].slt.wDay = yeardays[j][i/3];
622  pSystemTimeToTzSpecificLocalTime( cases[i].ptz, &(cases[i].slt), &result);
623  ok( result.wHour == cases[i].ehour,
624  "Test SystemTimeToTzSpecificLocalTime #%d. Got %4d-%02d-%02d %02d:%02d. Expect hour = %02d\n",
625  cases[i].nr, result.wYear, result.wMonth, result.wDay,
626  result.wHour, result.wMinute, cases[i].ehour);
627  }
628  }
629 
630  }
631 }
632 
633 static void test_FileTimeToDosDateTime(void)
634 {
635  FILETIME ft = { 0 };
636  WORD fatdate, fattime;
637  BOOL ret;
638 
639  if (0)
640  {
641  /* Crashes */
643  }
644  /* Parameter checking */
645  SetLastError(0xdeadbeef);
647  ok(!ret, "expected failure\n");
649  "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
650 
651  SetLastError(0xdeadbeef);
652  ret = FileTimeToDosDateTime(&ft, &fatdate, NULL);
653  ok(!ret, "expected failure\n");
655  "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
656 
657  SetLastError(0xdeadbeef);
658  ret = FileTimeToDosDateTime(&ft, NULL, &fattime);
659  ok(!ret, "expected failure\n");
661  "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
662 
663  SetLastError(0xdeadbeef);
664  ret = FileTimeToDosDateTime(&ft, &fatdate, &fattime);
665  ok(!ret, "expected failure\n");
667  "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
668 }
669 
670 static void test_GetCalendarInfo(void)
671 {
672  char bufferA[20];
673  WCHAR bufferW[20];
674  DWORD val1, val2;
675  int ret, ret2;
676 
677  if (!pGetCalendarInfoA || !pGetCalendarInfoW)
678  {
679  trace( "GetCalendarInfo missing\n" );
680  return;
681  }
682 
683  ret = pGetCalendarInfoA( 0x0409, CAL_GREGORIAN, CAL_ITWODIGITYEARMAX | CAL_RETURN_NUMBER,
684  NULL, 0, &val1 );
685  ok( ret, "GetCalendarInfoA failed err %u\n", GetLastError() );
686  ok( ret == sizeof(val1), "wrong size %u\n", ret );
687  ok( val1 >= 2000 && val1 < 2100, "wrong value %u\n", val1 );
688 
689  ret = pGetCalendarInfoW( 0x0409, CAL_GREGORIAN, CAL_ITWODIGITYEARMAX | CAL_RETURN_NUMBER,
690  NULL, 0, &val2 );
691  ok( ret, "GetCalendarInfoW failed err %u\n", GetLastError() );
692  ok( ret == sizeof(val2)/sizeof(WCHAR), "wrong size %u\n", ret );
693  ok( val1 == val2, "A/W mismatch %u/%u\n", val1, val2 );
694 
695  ret = pGetCalendarInfoA( 0x0409, CAL_GREGORIAN, CAL_ITWODIGITYEARMAX, bufferA, sizeof(bufferA), NULL );
696  ok( ret, "GetCalendarInfoA failed err %u\n", GetLastError() );
697  ok( ret == 5, "wrong size %u\n", ret );
698  ok( atoi( bufferA ) == val1, "wrong value %s/%u\n", bufferA, val1 );
699 
700  ret = pGetCalendarInfoW( 0x0409, CAL_GREGORIAN, CAL_ITWODIGITYEARMAX, bufferW, sizeof(bufferW), NULL );
701  ok( ret, "GetCalendarInfoW failed err %u\n", GetLastError() );
702  ok( ret == 5, "wrong size %u\n", ret );
703  memset( bufferA, 0x55, sizeof(bufferA) );
704  WideCharToMultiByte( CP_ACP, 0, bufferW, -1, bufferA, sizeof(bufferA), NULL, NULL );
705  ok( atoi( bufferA ) == val1, "wrong value %s/%u\n", bufferA, val1 );
706 
707  ret = pGetCalendarInfoA( 0x0409, CAL_GREGORIAN, CAL_ITWODIGITYEARMAX | CAL_RETURN_NUMBER,
708  NULL, 0, NULL );
709  ok( !ret, "GetCalendarInfoA succeeded\n" );
710  ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
711 
712  ret = pGetCalendarInfoA( 0x0409, CAL_GREGORIAN, CAL_ITWODIGITYEARMAX, NULL, 0, NULL );
713  ok( ret, "GetCalendarInfoA failed err %u\n", GetLastError() );
714  ok( ret == 5, "wrong size %u\n", ret );
715 
716  ret = pGetCalendarInfoW( 0x0409, CAL_GREGORIAN, CAL_ITWODIGITYEARMAX | CAL_RETURN_NUMBER,
717  NULL, 0, NULL );
718  ok( !ret, "GetCalendarInfoW succeeded\n" );
719  ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
720 
721  ret = pGetCalendarInfoW( 0x0409, CAL_GREGORIAN, CAL_ITWODIGITYEARMAX, NULL, 0, NULL );
722  ok( ret, "GetCalendarInfoW failed err %u\n", GetLastError() );
723  ok( ret == 5, "wrong size %u\n", ret );
724 
725  ret = pGetCalendarInfoA( LANG_SYSTEM_DEFAULT, CAL_GREGORIAN, CAL_SDAYNAME1,
726  bufferA, sizeof(bufferA), NULL);
727  ok( ret, "GetCalendarInfoA failed err %u\n", GetLastError() );
728  ret2 = pGetCalendarInfoA( LANG_SYSTEM_DEFAULT, CAL_GREGORIAN, CAL_SDAYNAME1,
729  bufferA, 0, NULL);
730  ok( ret2, "GetCalendarInfoA failed err %u\n", GetLastError() );
731  ok( ret == ret2, "got %d, expected %d\n", ret2, ret );
732 
733  ret2 = pGetCalendarInfoW( LANG_SYSTEM_DEFAULT, CAL_GREGORIAN, CAL_SDAYNAME1,
734  bufferW, sizeof(bufferW), NULL);
735  ok( ret2, "GetCalendarInfoW failed err %u\n", GetLastError() );
736  ret2 = WideCharToMultiByte( CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL );
737  ok( ret == ret2, "got %d, expected %d\n", ret, ret2 );
738 }
739 
741 {
743  TIME_ZONE_INFORMATION tzinfo;
744  DWORD ret, ret2;
745 
746  if (!pGetDynamicTimeZoneInformation)
747  {
748  win_skip("GetDynamicTimeZoneInformation() is not supported.\n");
749  return;
750  }
751 
752  ret = pGetDynamicTimeZoneInformation(&dyninfo);
753  ret2 = GetTimeZoneInformation(&tzinfo);
754  ok(ret == ret2, "got %d, %d\n", ret, ret2);
755 
756  ok(dyninfo.Bias == tzinfo.Bias, "got %d, %d\n", dyninfo.Bias, tzinfo.Bias);
757  ok(!lstrcmpW(dyninfo.StandardName, tzinfo.StandardName), "got std name %s, %s\n",
759  ok(!memcmp(&dyninfo.StandardDate, &tzinfo.StandardDate, sizeof(dyninfo.StandardDate)), "got different StandardDate\n");
760  ok(dyninfo.StandardBias == tzinfo.StandardBias, "got %d, %d\n", dyninfo.StandardBias, tzinfo.StandardBias);
761  ok(!lstrcmpW(dyninfo.DaylightName, tzinfo.DaylightName), "got daylight name %s, %s\n",
763  ok(!memcmp(&dyninfo.DaylightDate, &tzinfo.DaylightDate, sizeof(dyninfo.DaylightDate)), "got different DaylightDate\n");
764  ok(dyninfo.TimeZoneKeyName[0] != 0, "got empty tz keyname\n");
765  trace("Dyn TimeZoneKeyName %s\n", wine_dbgstr_w(dyninfo.TimeZoneKeyName));
766 }
767 
769 {
770  ULARGE_INTEGER uli;
771  uli.u.LowPart = time->dwLowDateTime;
772  uli.u.HighPart = time->dwHighDateTime;
773  return uli.QuadPart;
774 }
775 
777 {
778  FILETIME ft;
779  ULONGLONG time1, time2;
780  LONGLONG diff;
781 
782  if (!pGetSystemTimePreciseAsFileTime)
783  {
784  win_skip("GetSystemTimePreciseAsFileTime() is not supported.\n");
785  return;
786  }
787 
789  time1 = get_longlong_time(&ft);
790  pGetSystemTimePreciseAsFileTime(&ft);
791  time2 = get_longlong_time(&ft);
792  diff = time2 - time1;
793  if (diff < 0)
794  diff = -diff;
795  ok(diff < 1000000, "Difference between GetSystemTimeAsFileTime and GetSystemTimePreciseAsFileTime more than 100 ms\n");
796 
797  pGetSystemTimePreciseAsFileTime(&ft);
798  time1 = get_longlong_time(&ft);
799  do {
800  pGetSystemTimePreciseAsFileTime(&ft);
801  time2 = get_longlong_time(&ft);
802  } while (time2 == time1);
803  diff = time2 - time1;
804  ok(diff < 10000 && diff > 0, "GetSystemTimePreciseAsFileTime incremented by more than 1 ms\n");
805 }
806 
807 static void test_GetSystemTimes(void)
808 {
809 
810  FILETIME idletime, kerneltime, usertime;
811  int i;
812  ULARGE_INTEGER ul1, ul2, ul3;
816  ULARGE_INTEGER total_usertime, total_kerneltime, total_idletime;
817 
818  if (!pGetSystemTimes)
819  {
820  win_skip("GetSystemTimes not available\n");
821  return;
822  }
823 
824  ok( pGetSystemTimes(NULL, NULL, NULL), "GetSystemTimes failed unexpectedly\n" );
825 
826  total_usertime.QuadPart = 0;
827  total_kerneltime.QuadPart = 0;
828  total_idletime.QuadPart = 0;
829  memset( &idletime, 0x11, sizeof(idletime) );
830  memset( &kerneltime, 0x11, sizeof(kerneltime) );
831  memset( &usertime, 0x11, sizeof(usertime) );
832  ok( pGetSystemTimes(&idletime, &kerneltime , &usertime),
833  "GetSystemTimes failed unexpectedly\n" );
834 
835  ul1.LowPart = idletime.dwLowDateTime;
836  ul1.HighPart = idletime.dwHighDateTime;
837  ul2.LowPart = kerneltime.dwLowDateTime;
838  ul2.HighPart = kerneltime.dwHighDateTime;
839  ul3.LowPart = usertime.dwLowDateTime;
840  ul3.HighPart = usertime.dwHighDateTime;
841 
843  "NtQuerySystemInformation failed\n" );
844  ok( sizeof(sbi) == ReturnLength, "Inconsistent length %d\n", ReturnLength );
845 
846  /* Check if we have some return values */
847  trace( "Number of Processors : %d\n", sbi.NumberOfProcessors );
848  ok( sbi.NumberOfProcessors > 0, "Expected more than 0 processors, got %d\n",
849  sbi.NumberOfProcessors );
850 
851  sppi = HeapAlloc( GetProcessHeap(), 0,
853 
856  &ReturnLength),
857  "NtQuerySystemInformation failed\n" );
858 
859  for (i = 0; i < sbi.NumberOfProcessors; i++)
860  {
861  total_usertime.QuadPart += sppi[i].UserTime.QuadPart;
862  total_kerneltime.QuadPart += sppi[i].KernelTime.QuadPart;
863  total_idletime.QuadPart += sppi[i].IdleTime.QuadPart;
864  }
865 
866  ok( total_idletime.QuadPart - ul1.QuadPart < 10000000, "test idletime failed\n" );
867  ok( total_kerneltime.QuadPart - ul2.QuadPart < 10000000, "test kerneltime failed\n" );
868  ok( total_usertime.QuadPart - ul3.QuadPart < 10000000, "test usertime failed\n" );
869 
870  HeapFree(GetProcessHeap(), 0, sppi);
871 }
872 
874 {
875  SYSTEMTIME first_of_month = {0};
877  WORD result;
878 
879  if (systemtime->wYear != 0)
880  return systemtime->wDay;
881 
882  first_of_month.wYear = year;
883  first_of_month.wMonth = systemtime->wMonth;
884  first_of_month.wDay = 1;
885 
886  /* round-trip conversion sets day of week field */
887  SystemTimeToFileTime(&first_of_month, &filetime);
888  FileTimeToSystemTime(&filetime, &first_of_month);
889 
890  result = 1 + ((systemtime->wDayOfWeek - first_of_month.wDayOfWeek + 7) % 7) +
891  (7 * (systemtime->wDay - 1));
892 
893  if (systemtime->wDay == 5)
894  {
895  /* make sure this isn't in the next month */
896  SYSTEMTIME result_date;
897 
898  result_date = first_of_month;
899  result_date.wDay = result;
900 
901  SystemTimeToFileTime(&result_date, &filetime);
902  FileTimeToSystemTime(&filetime, &result_date);
903 
904  if (result_date.wDay != result)
905  result = 1 + ((systemtime->wDayOfWeek - first_of_month.wDayOfWeek + 7) % 7) +
906  (7 * (4 - 1));
907  }
908 
909  return result;
910 }
911 
913 {
914  BOOL ret;
916  TIME_ZONE_INFORMATION local_tzinfo, tzinfo, tzinfo2;
918  static const WCHAR std_tzname[] = {'G','r','e','e','n','l','a','n','d',' ','S','t','a','n','d','a','r','d',' ','T','i','m','e',0};
919  static const WCHAR dlt_tzname[] = {'G','r','e','e','n','l','a','n','d',' ','D','a','y','l','i','g','h','t',' ','T','i','m','e',0};
920  WORD std_day, dlt_day;
921 
922  if (!pGetTimeZoneInformationForYear || !pGetDynamicTimeZoneInformation)
923  {
924  win_skip("GetTimeZoneInformationForYear not available\n");
925  return;
926  }
927 
929 
930  GetTimeZoneInformation(&local_tzinfo);
931 
932  ret = pGetTimeZoneInformationForYear(systemtime.wYear, NULL, &tzinfo);
933  ok(ret == TRUE, "GetTimeZoneInformationForYear failed, err %u\n", GetLastError());
934  ok(tzinfo.Bias == local_tzinfo.Bias, "Expected Bias %d, got %d\n", local_tzinfo.Bias, tzinfo.Bias);
935  ok(!lstrcmpW(tzinfo.StandardName, local_tzinfo.StandardName),
936  "Expected StandardName %s, got %s\n", wine_dbgstr_w(local_tzinfo.StandardName), wine_dbgstr_w(tzinfo.StandardName));
937  ok(!memcmp(&tzinfo.StandardDate, &local_tzinfo.StandardDate, sizeof(SYSTEMTIME)), "StandardDate does not match\n");
938  ok(tzinfo.StandardBias == local_tzinfo.StandardBias, "Expected StandardBias %d, got %d\n", local_tzinfo.StandardBias, tzinfo.StandardBias);
939  ok(!lstrcmpW(tzinfo.DaylightName, local_tzinfo.DaylightName),
940  "Expected DaylightName %s, got %s\n", wine_dbgstr_w(local_tzinfo.DaylightName), wine_dbgstr_w(tzinfo.DaylightName));
941  ok(!memcmp(&tzinfo.DaylightDate, &local_tzinfo.DaylightDate, sizeof(SYSTEMTIME)), "DaylightDate does not match\n");
942  ok(tzinfo.DaylightBias == local_tzinfo.DaylightBias, "Expected DaylightBias %d, got %d\n", local_tzinfo.DaylightBias, tzinfo.DaylightBias);
943 
944  pGetDynamicTimeZoneInformation(&dyn_tzinfo);
945 
946  ret = pGetTimeZoneInformationForYear(systemtime.wYear, &dyn_tzinfo, &tzinfo);
947  ok(ret == TRUE, "GetTimeZoneInformationForYear failed, err %u\n", GetLastError());
948  ok(tzinfo.Bias == local_tzinfo.Bias, "Expected Bias %d, got %d\n", local_tzinfo.Bias, tzinfo.Bias);
949  ok(!lstrcmpW(tzinfo.StandardName, local_tzinfo.StandardName),
950  "Expected StandardName %s, got %s\n", wine_dbgstr_w(local_tzinfo.StandardName), wine_dbgstr_w(tzinfo.StandardName));
951  ok(!memcmp(&tzinfo.StandardDate, &local_tzinfo.StandardDate, sizeof(SYSTEMTIME)), "StandardDate does not match\n");
952  ok(tzinfo.StandardBias == local_tzinfo.StandardBias, "Expected StandardBias %d, got %d\n", local_tzinfo.StandardBias, tzinfo.StandardBias);
953  ok(!lstrcmpW(tzinfo.DaylightName, local_tzinfo.DaylightName),
954  "Expected DaylightName %s, got %s\n", wine_dbgstr_w(local_tzinfo.DaylightName), wine_dbgstr_w(tzinfo.DaylightName));
955  ok(!memcmp(&tzinfo.DaylightDate, &local_tzinfo.DaylightDate, sizeof(SYSTEMTIME)), "DaylightDate does not match\n");
956  ok(tzinfo.DaylightBias == local_tzinfo.DaylightBias, "Expected DaylightBias %d, got %d\n", local_tzinfo.DaylightBias, tzinfo.DaylightBias);
957 
958  memset(&dyn_tzinfo, 0xaa, sizeof(dyn_tzinfo));
959  lstrcpyW(dyn_tzinfo.TimeZoneKeyName, std_tzname);
960  dyn_tzinfo.DynamicDaylightTimeDisabled = FALSE;
961 
962  ret = pGetTimeZoneInformationForYear(2015, &dyn_tzinfo, &tzinfo);
963  ok(ret == TRUE, "GetTimeZoneInformationForYear failed, err %u\n", GetLastError());
964  ok(tzinfo.Bias == 180, "Expected Bias 180, got %d\n", tzinfo.Bias);
965  ok(tzinfo.StandardDate.wMonth == 10, "Expected standard month 10, got %d\n", tzinfo.StandardDate.wMonth);
966  std_day = day_of_month(&tzinfo.StandardDate, 2015);
967  ok(std_day == 24, "Expected standard day 24, got %d\n", std_day);
968  ok(tzinfo.StandardBias == 0, "Expected StandardBias 0, got %d\n", tzinfo.StandardBias);
969  ok(tzinfo.DaylightDate.wMonth == 3, "Expected daylight month 3, got %d\n", tzinfo.DaylightDate.wMonth);
970  dlt_day = day_of_month(&tzinfo.DaylightDate, 2015);
971  ok(dlt_day == 28, "Expected daylight day 28, got %d\n", dlt_day);
972  ok(tzinfo.DaylightBias == -60, "Expected DaylightBias -60, got %d\n", tzinfo.DaylightBias);
973 
974  ret = pGetTimeZoneInformationForYear(2016, &dyn_tzinfo, &tzinfo2);
975  ok(ret == TRUE, "GetTimeZoneInformationForYear failed, err %u\n", GetLastError());
976  ok(!lstrcmpW(tzinfo.StandardName, tzinfo2.StandardName),
977  "Got differing StandardName values %s and %s\n",
979  ok(!lstrcmpW(tzinfo.DaylightName, tzinfo2.DaylightName),
980  "Got differing DaylightName values %s and %s\n",
982 
983  memset(&dyn_tzinfo, 0xaa, sizeof(dyn_tzinfo));
984  lstrcpyW(dyn_tzinfo.TimeZoneKeyName, dlt_tzname);
985 
986  SetLastError(0xdeadbeef);
987  ret = pGetTimeZoneInformationForYear(2015, &dyn_tzinfo, &tzinfo);
989  broken(ret == TRUE) /* vista,7 */,
990  "GetTimeZoneInformationForYear err %u\n", GetLastError());
991 }
992 
994 {
995  HMODULE hKernel = GetModuleHandleA("kernel32");
996  pTzSpecificLocalTimeToSystemTime = (void *)GetProcAddress(hKernel, "TzSpecificLocalTimeToSystemTime");
997  pSystemTimeToTzSpecificLocalTime = (void *)GetProcAddress( hKernel, "SystemTimeToTzSpecificLocalTime");
998  pGetSystemTimes = (void *)GetProcAddress( hKernel, "GetSystemTimes");
999  pGetCalendarInfoA = (void *)GetProcAddress(hKernel, "GetCalendarInfoA");
1000  pGetCalendarInfoW = (void *)GetProcAddress(hKernel, "GetCalendarInfoW");
1001  pGetDynamicTimeZoneInformation = (void *)GetProcAddress(hKernel, "GetDynamicTimeZoneInformation");
1002  pGetSystemTimePreciseAsFileTime = (void *)GetProcAddress(hKernel, "GetSystemTimePreciseAsFileTime");
1003  pGetTimeZoneInformationForYear = (void *)GetProcAddress(hKernel, "GetTimeZoneInformationForYear");
1004 
1005  test_conversions();
1006  test_invalid_arg();
1017 }
static void test_GetCalendarInfo(void)
Definition: time.c:670
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
static LPSYSTEMTIME
Definition: time.c:27
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
DWORD WINAPI GetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformation)
Definition: timezone.c:262
#define trace(...)
Definition: kmt_test.h:217
VOID WINAPI GetSystemTimeAsFileTime(OUT PFILETIME lpFileTime)
Definition: time.c:128
static LPFILETIME
Definition: time.c:29
#define TRUE
Definition: types.h:120
NTSYSAPI NTSTATUS NTAPI NtQuerySystemInformation(IN SYSTEM_INFORMATION_CLASS SystemInfoClass, OUT PVOID SystemInfoBuffer, IN ULONG SystemInfoBufferSize, OUT PULONG BytesReturned OPTIONAL)
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define WideCharToMultiByte
Definition: compat.h:101
#define DOS_DATE(y, m, d)
Definition: time.c:57
WORD wMonth
Definition: winbase.h:871
static BOOL(WINAPI *pTzSpecificLocalTimeToSystemTime)(LPTIME_ZONE_INFORMATION
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define TIME_ZONE_ID_UNKNOWN
Definition: rtltypes.h:250
#define CP_ACP
Definition: compat.h:99
static LONGLONG system_time_to_minutes(const SYSTEMTIME *st)
Definition: time.c:200
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
WORD wDayOfWeek
Definition: winbase.h:872
int nr
Definition: time.c:444
static void test_GetDynamicTimeZoneInformation(void)
Definition: time.c:740
#define TICKSPERSEC
Definition: time.c:40
#define TIME_ZONE_ID_INVALID
Definition: winbase.h:283
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define ZeroMemory
Definition: winbase.h:1635
$ULONG LowPart
Definition: ntbasedef.h:576
DWORD LCID
Definition: nls.h:13
#define SETUP_ATIME(st)
Definition: time.c:79
__u16 time
Definition: mkdosfs.c:366
#define ATIME_HI
Definition: time.c:51
SYSTEMTIME slt
Definition: time.c:446
BOOL WINAPI FileTimeToLocalFileTime(IN CONST FILETIME *lpFileTime, OUT LPFILETIME lpLocalFileTime)
Definition: time.c:211
static CALTYPE
Definition: time.c:30
static void test_GetSystemTimes(void)
Definition: time.c:807
#define SETUP_ZEROTIME(st)
Definition: time.c:88
START_TEST(time)
Definition: time.c:43
DWORD dwHighDateTime
Definition: mapidefs.h:66
WORD wYear
Definition: winbase.h:870
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
long LONG
Definition: pedump.c:60
struct _ULARGE_INTEGER::@3734 u
#define MAYDAY_2002_HI
Definition: time.c:48
static void test_GetTimeZoneInformationForYear(void)
Definition: time.c:912
static void test_invalid_arg(void)
Definition: time.c:162
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: CString.cpp:62
static ULONGLONG get_longlong_time(FILETIME *time)
Definition: time.c:768
WORD wMinute
Definition: winbase.h:875
smooth NULL
Definition: ftsmooth.c:416
static FILETIME systemtime
Definition: automation.c:58
TIME_ZONE_INFORMATION * ptz
Definition: time.c:445
#define NEWYEAR_1980_LO
Definition: time.c:46
VOID WINAPI GetLocalTime(OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:276
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
static LPTIME_ZONE_INFORMATION
Definition: time.c:34
#define ok(value,...)
Definition: CComObject.cpp:34
int64_t LONGLONG
Definition: typedefs.h:66
VOID WINAPI GetSystemTime(OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:317
#define TIME_ZONE_ID_STANDARD
Definition: rtltypes.h:251
$ULONG HighPart
Definition: ntbasedef.h:577
BOOL WINAPI FileTimeToSystemTime(IN CONST FILETIME *lpFileTime, OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:178
unsigned int BOOL
Definition: ntddk_ex.h:94
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
BOOL WINAPI DosDateTimeToFileTime(IN WORD wFatDate, IN WORD wFatTime, OUT LPFILETIME lpFileTime)
Definition: time.c:75
#define SECSPERMIN
Definition: time.c:36
uint64_t ULONGLONG
Definition: typedefs.h:65
static void test_GetTimeZoneInformation(void)
Definition: time.c:235
BOOL WINAPI DECLSPEC_HOTPATCH SetEnvironmentVariableA(IN LPCSTR lpName, IN LPCSTR lpValue)
Definition: environ.c:218
static LPWSTR
Definition: time.c:31
#define CAL_GREGORIAN
Definition: winnls.h:440
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:409
static DWORD(WINAPI *pGetDynamicTimeZoneInformation)(DYNAMIC_TIME_ZONE_INFORMATION *)
#define LONG
Definition: msvc.h:36
WORD wSecond
Definition: winbase.h:876
#define MAYDAY_2002_LO
Definition: time.c:49
WORD wMilliseconds
Definition: winbase.h:877
int ret
static PDYNAMIC_TIME_ZONE_INFORMATION
Definition: time.c:34
static LONG get_tz_bias(const TIME_ZONE_INFORMATION *tzinfo, DWORD tz_id)
Definition: time.c:215
#define SETUP_1980(st)
Definition: time.c:61
#define TICKS_1601_TO_1970
Definition: time.c:42
static WORD day_of_month(const SYSTEMTIME *systemtime, WORD year)
Definition: time.c:873
SYSTEMTIME StandardDate
Definition: winbase.h:1161
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:819
#define LANG_SYSTEM_DEFAULT
#define WINAPI
Definition: msvc.h:20
#define broken(x)
Definition: _sntprintf.h:21
static CALID
Definition: time.c:30
#define local
Definition: zutil.h:30
WORD wDay
Definition: winbase.h:873
BOOL WINAPI FileTimeToDosDateTime(IN CONST FILETIME *lpFileTime, OUT LPWORD lpFatDate, OUT LPWORD lpFatTime)
Definition: time.c:37
BOOL WINAPI SystemTimeToFileTime(IN CONST SYSTEMTIME *lpSystemTime, OUT LPFILETIME lpFileTime)
Definition: time.c:148
WCHAR DaylightName[32]
Definition: winbase.h:1163
static DOUBLE utc(DOUBLE time, DateInstance *date)
Definition: date.c:355
#define lstrcpyW
Definition: compat.h:406
unsigned short USHORT
Definition: pedump.c:61
static void test_FileTimeToDosDateTime(void)
Definition: time.c:633
#define DOS_TIME(h, m, s)
Definition: time.c:58
static void(WINAPI *pGetSystemTimePreciseAsFileTime)(LPFILETIME)
WORD wHour
Definition: winbase.h:874
#define SystemBasicInformation
Definition: xboxvmp.h:35
#define CAL_SDAYNAME1
Definition: winnls.h:400
WORD ehour
Definition: time.c:447
#define SETUP_EARLY(st)
Definition: time.c:97
_Check_return_ int __cdecl atoi(_In_z_ const char *_Str)
static LPDWORD
Definition: time.c:30
GLuint res
Definition: glext.h:9613
unsigned int ULONG
Definition: retypes.h:1
static void test_FileTimeToLocalFileTime(void)
Definition: time.c:399
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:92
static void test_FileTimeToSystemTime(void)
Definition: time.c:369
#define GetProcAddress(x, y)
Definition: compat.h:410
#define NEWYEAR_1980_HI
Definition: time.c:45
static void test_GetSystemTimePreciseAsFileTime(void)
Definition: time.c:776
static void test_conversions(void)
Definition: time.c:107
#define UINT
Definition: msvc.h:27
GLuint64EXT * result
Definition: glext.h:11304
#define memset(x, y, z)
Definition: compat.h:39
#define TIME_ZONE_ID_DAYLIGHT
Definition: rtltypes.h:252
#define win_skip
Definition: test.h:141
static LPSTR
Definition: time.c:30
#define HeapFree(x, y, z)
Definition: compat.h:394
WCHAR StandardName[32]
Definition: winbase.h:1160
static void test_TzSpecificLocalTimeToSystemTime(void)
Definition: time.c:450
DWORD dwLowDateTime
Definition: mapidefs.h:65
SYSTEMTIME DaylightDate
Definition: winbase.h:1164
struct task_struct * current
Definition: linux.c:32
#define ATIME_LOW
Definition: time.c:52
LONGLONG QuadPart
Definition: typedefs.h:112
static int
Definition: time.c:30
#define SETUP_2002(st)
Definition: time.c:70