1 /* 2 * Copyright 2004 Dimitrie O. Paun 3 * 4 * This library is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU Lesser General Public 6 * License as published by the Free Software Foundation; either 7 * version 2.1 of the License, or (at your option) any later version. 8 * 9 * This library is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 * Lesser General Public License for more details. 13 * 14 * You should have received a copy of the GNU Lesser General Public 15 * License along with this library; if not, write to the Free Software 16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 * 18 * This file contains tests to ensure the consistency between symbols 19 * defined in the regular msvcrt headers, and the corresponding duplicated 20 * symbols defined in msvcrt.h (prefixed by MSVCRT_). 21 */ 22 23 #include "dos.h" 24 #include "math.h" 25 #include "stdlib.h" 26 #include "io.h" 27 #include "errno.h" 28 #include "fcntl.h" 29 #include "malloc.h" 30 #include "limits.h" 31 #include "mbctype.h" 32 #include "stdio.h" 33 #include "wchar.h" 34 #include "ctype.h" 35 #include "crtdbg.h" 36 #include "share.h" 37 #include "search.h" 38 #include "wctype.h" 39 #include "float.h" 40 #include "stddef.h" 41 #include "mbstring.h" 42 #include "sys/locking.h" 43 #include "sys/utime.h" 44 #include "sys/types.h" 45 #include "sys/stat.h" 46 #include "sys/timeb.h" 47 #include "direct.h" 48 #include "conio.h" 49 #include "process.h" 50 #include "string.h" 51 #include "signal.h" 52 #include "time.h" 53 #include "locale.h" 54 #include "setjmp.h" 55 #include "wine/test.h" 56 57 #ifdef __WINE_USE_MSVCRT 58 /* Wine-specific msvcrt headers */ 59 #define __WINE_MSVCRT_TEST 60 #include "eh.h" 61 #include "msvcrt.h" 62 63 #ifdef __GNUC__ 64 #define TYPEOF(type) typeof(type) 65 #else 66 #define TYPEOF(type) int 67 #endif 68 #define MSVCRT(x) MSVCRT_##x 69 #define CHECK_SIZE(e) ok(sizeof(e) == sizeof(MSVCRT(e)), "Element has different sizes\n") 70 #define CHECK_TYPE(t) { TYPEOF(t) a = 0; TYPEOF(MSVCRT(t)) b = a; a = b; CHECK_SIZE(t); } 71 #define CHECK_STRUCT(s) ok(sizeof(struct s) == sizeof(struct MSVCRT(s)), "Struct has different sizes\n") 72 #define CHECK_FIELD(s,e) ok(offsetof(struct s,e) == offsetof(struct MSVCRT(s),e), "Bad offset\n") 73 #define CHECK_DEF(d) ok(d == MSVCRT_##d, "Defines (MSVCRT_)" #d " are different: %d vs. %d\n", d, MSVCRT_##d) 74 75 /************* Checking types ***************/ 76 static void test_types(void) 77 { 78 CHECK_TYPE(wchar_t); 79 CHECK_TYPE(wint_t); 80 CHECK_TYPE(wctype_t); 81 CHECK_TYPE(_ino_t); 82 CHECK_TYPE(_fsize_t); 83 CHECK_TYPE(size_t); 84 CHECK_TYPE(intptr_t); 85 CHECK_TYPE(uintptr_t); 86 CHECK_TYPE(_dev_t); 87 CHECK_TYPE(_off_t); 88 CHECK_TYPE(clock_t); 89 CHECK_TYPE(__time32_t); 90 CHECK_TYPE(__time64_t); 91 CHECK_TYPE(fpos_t); 92 CHECK_SIZE(FILE); 93 CHECK_TYPE(terminate_handler); 94 CHECK_TYPE(terminate_function); 95 CHECK_TYPE(unexpected_handler); 96 CHECK_TYPE(unexpected_function); 97 CHECK_TYPE(_se_translator_function); 98 CHECK_TYPE(_beginthread_start_routine_t); 99 CHECK_TYPE(_onexit_t); 100 CHECK_TYPE(__sighandler_t); 101 } 102 103 /************* Checking structs ***************/ 104 static void test_structs(void) 105 { 106 CHECK_STRUCT(tm); 107 CHECK_FIELD(tm, tm_sec); 108 CHECK_FIELD(tm, tm_min); 109 CHECK_FIELD(tm, tm_hour); 110 CHECK_FIELD(tm, tm_mday); 111 CHECK_FIELD(tm, tm_mon); 112 CHECK_FIELD(tm, tm_year); 113 CHECK_FIELD(tm, tm_wday); 114 CHECK_FIELD(tm, tm_yday); 115 CHECK_FIELD(tm, tm_isdst); 116 CHECK_STRUCT(__timeb32); 117 CHECK_FIELD(__timeb32, time); 118 CHECK_FIELD(__timeb32, millitm); 119 CHECK_FIELD(__timeb32, timezone); 120 CHECK_FIELD(__timeb32, dstflag); 121 CHECK_STRUCT(__timeb64); 122 CHECK_FIELD(__timeb64, time); 123 CHECK_FIELD(__timeb64, millitm); 124 CHECK_FIELD(__timeb64, timezone); 125 CHECK_FIELD(__timeb64, dstflag); 126 CHECK_STRUCT(_iobuf); 127 CHECK_FIELD(_iobuf, _ptr); 128 CHECK_FIELD(_iobuf, _cnt); 129 CHECK_FIELD(_iobuf, _base); 130 CHECK_FIELD(_iobuf, _flag); 131 CHECK_FIELD(_iobuf, _file); 132 CHECK_FIELD(_iobuf, _charbuf); 133 CHECK_FIELD(_iobuf, _bufsiz); 134 CHECK_FIELD(_iobuf, _tmpfname); 135 CHECK_STRUCT(lconv); 136 CHECK_FIELD(lconv, decimal_point); 137 CHECK_FIELD(lconv, thousands_sep); 138 CHECK_FIELD(lconv, grouping); 139 CHECK_FIELD(lconv, int_curr_symbol); 140 CHECK_FIELD(lconv, currency_symbol); 141 CHECK_FIELD(lconv, mon_decimal_point); 142 CHECK_FIELD(lconv, mon_thousands_sep); 143 CHECK_FIELD(lconv, mon_grouping); 144 CHECK_FIELD(lconv, positive_sign); 145 CHECK_FIELD(lconv, negative_sign); 146 CHECK_FIELD(lconv, int_frac_digits); 147 CHECK_FIELD(lconv, frac_digits); 148 CHECK_FIELD(lconv, p_cs_precedes); 149 CHECK_FIELD(lconv, p_sep_by_space); 150 CHECK_FIELD(lconv, n_cs_precedes); 151 CHECK_FIELD(lconv, n_sep_by_space); 152 CHECK_FIELD(lconv, p_sign_posn); 153 CHECK_FIELD(lconv, n_sign_posn); 154 CHECK_STRUCT(_exception); 155 CHECK_FIELD(_exception, type); 156 CHECK_FIELD(_exception, name); 157 CHECK_FIELD(_exception, arg1); 158 CHECK_FIELD(_exception, arg2); 159 CHECK_FIELD(_exception, retval); 160 CHECK_STRUCT(_complex); 161 CHECK_FIELD(_complex, x); 162 CHECK_FIELD(_complex, y); 163 CHECK_STRUCT(_div_t); 164 CHECK_FIELD(_div_t, quot); 165 CHECK_FIELD(_div_t, rem); 166 CHECK_STRUCT(_ldiv_t); 167 CHECK_FIELD(_ldiv_t, quot); 168 CHECK_FIELD(_ldiv_t, rem); 169 CHECK_STRUCT(_heapinfo); 170 CHECK_FIELD(_heapinfo, _pentry); 171 CHECK_FIELD(_heapinfo, _size); 172 CHECK_FIELD(_heapinfo, _useflag); 173 #ifdef __i386__ 174 CHECK_STRUCT(__JUMP_BUFFER); 175 CHECK_FIELD(__JUMP_BUFFER, Ebp); 176 CHECK_FIELD(__JUMP_BUFFER, Ebx); 177 CHECK_FIELD(__JUMP_BUFFER, Edi); 178 CHECK_FIELD(__JUMP_BUFFER, Esi); 179 CHECK_FIELD(__JUMP_BUFFER, Esp); 180 CHECK_FIELD(__JUMP_BUFFER, Eip); 181 CHECK_FIELD(__JUMP_BUFFER, Registration); 182 CHECK_FIELD(__JUMP_BUFFER, TryLevel); 183 CHECK_FIELD(__JUMP_BUFFER, Cookie); 184 CHECK_FIELD(__JUMP_BUFFER, UnwindFunc); 185 CHECK_FIELD(__JUMP_BUFFER, UnwindData[6]); 186 #endif 187 CHECK_STRUCT(_diskfree_t); 188 CHECK_FIELD(_diskfree_t, total_clusters); 189 CHECK_FIELD(_diskfree_t, avail_clusters); 190 CHECK_FIELD(_diskfree_t, sectors_per_cluster); 191 CHECK_FIELD(_diskfree_t, bytes_per_sector); 192 CHECK_STRUCT(_finddata_t); 193 CHECK_FIELD(_finddata_t, attrib); 194 CHECK_FIELD(_finddata_t, time_create); 195 CHECK_FIELD(_finddata_t, time_access); 196 CHECK_FIELD(_finddata_t, time_write); 197 CHECK_FIELD(_finddata_t, size); 198 CHECK_FIELD(_finddata_t, name[260]); 199 CHECK_STRUCT(_finddatai64_t); 200 CHECK_FIELD(_finddatai64_t, attrib); 201 CHECK_FIELD(_finddatai64_t, time_create); 202 CHECK_FIELD(_finddatai64_t, time_access); 203 CHECK_FIELD(_finddatai64_t, time_write); 204 CHECK_FIELD(_finddatai64_t, size); 205 CHECK_FIELD(_finddatai64_t, name[260]); 206 CHECK_STRUCT(_wfinddata_t); 207 CHECK_FIELD(_wfinddata_t, attrib); 208 CHECK_FIELD(_wfinddata_t, time_create); 209 CHECK_FIELD(_wfinddata_t, time_access); 210 CHECK_FIELD(_wfinddata_t, time_write); 211 CHECK_FIELD(_wfinddata_t, size); 212 CHECK_FIELD(_wfinddata_t, name[260]); 213 CHECK_STRUCT(_wfinddatai64_t); 214 CHECK_FIELD(_wfinddatai64_t, attrib); 215 CHECK_FIELD(_wfinddatai64_t, time_create); 216 CHECK_FIELD(_wfinddatai64_t, time_access); 217 CHECK_FIELD(_wfinddatai64_t, time_write); 218 CHECK_FIELD(_wfinddatai64_t, size); 219 CHECK_FIELD(_wfinddatai64_t, name[260]); 220 CHECK_STRUCT(__utimbuf32); 221 CHECK_FIELD(__utimbuf32, actime); 222 CHECK_FIELD(__utimbuf32, modtime); 223 CHECK_STRUCT(__utimbuf64); 224 CHECK_FIELD(__utimbuf64, actime); 225 CHECK_FIELD(__utimbuf64, modtime); 226 CHECK_STRUCT(_stat); 227 CHECK_FIELD(_stat, st_dev); 228 CHECK_FIELD(_stat, st_ino); 229 CHECK_FIELD(_stat, st_mode); 230 CHECK_FIELD(_stat, st_nlink); 231 CHECK_FIELD(_stat, st_uid); 232 CHECK_FIELD(_stat, st_gid); 233 CHECK_FIELD(_stat, st_rdev); 234 CHECK_FIELD(_stat, st_size); 235 CHECK_FIELD(_stat, st_atime); 236 CHECK_FIELD(_stat, st_mtime); 237 CHECK_FIELD(_stat, st_ctime); 238 CHECK_STRUCT(_stati64); 239 CHECK_FIELD(_stati64, st_dev); 240 CHECK_FIELD(_stati64, st_ino); 241 CHECK_FIELD(_stati64, st_mode); 242 CHECK_FIELD(_stati64, st_nlink); 243 CHECK_FIELD(_stati64, st_uid); 244 CHECK_FIELD(_stati64, st_gid); 245 CHECK_FIELD(_stati64, st_rdev); 246 CHECK_FIELD(_stati64, st_size); 247 CHECK_FIELD(_stati64, st_atime); 248 CHECK_FIELD(_stati64, st_mtime); 249 CHECK_FIELD(_stati64, st_ctime); 250 CHECK_STRUCT(_stat64); 251 CHECK_FIELD(_stat64, st_dev); 252 CHECK_FIELD(_stat64, st_ino); 253 CHECK_FIELD(_stat64, st_mode); 254 CHECK_FIELD(_stat64, st_nlink); 255 CHECK_FIELD(_stat64, st_uid); 256 CHECK_FIELD(_stat64, st_gid); 257 CHECK_FIELD(_stat64, st_rdev); 258 CHECK_FIELD(_stat64, st_size); 259 CHECK_FIELD(_stat64, st_atime); 260 CHECK_FIELD(_stat64, st_mtime); 261 CHECK_FIELD(_stat64, st_ctime); 262 CHECK_SIZE(_CRT_FLOAT); 263 } 264 265 /************* Checking defines ***************/ 266 static void test_defines(void) 267 { 268 CHECK_DEF(WEOF); 269 CHECK_DEF(EOF); 270 CHECK_DEF(TMP_MAX); 271 CHECK_DEF(RAND_MAX); 272 CHECK_DEF(BUFSIZ); 273 CHECK_DEF(STDIN_FILENO); 274 CHECK_DEF(STDOUT_FILENO); 275 CHECK_DEF(STDERR_FILENO); 276 CHECK_DEF(_IOFBF); 277 CHECK_DEF(_IONBF); 278 CHECK_DEF(_IOLBF); 279 CHECK_DEF(FILENAME_MAX); 280 CHECK_DEF(_P_WAIT); 281 CHECK_DEF(_P_NOWAIT); 282 CHECK_DEF(_P_OVERLAY); 283 CHECK_DEF(_P_NOWAITO); 284 CHECK_DEF(_P_DETACH); 285 CHECK_DEF(EPERM); 286 CHECK_DEF(ENOENT); 287 CHECK_DEF(ESRCH); 288 CHECK_DEF(EINTR); 289 CHECK_DEF(EIO); 290 CHECK_DEF(ENXIO); 291 CHECK_DEF(E2BIG); 292 CHECK_DEF(ENOEXEC); 293 CHECK_DEF(EBADF); 294 CHECK_DEF(ECHILD); 295 CHECK_DEF(EAGAIN); 296 CHECK_DEF(ENOMEM); 297 CHECK_DEF(EACCES); 298 CHECK_DEF(EFAULT); 299 CHECK_DEF(EBUSY); 300 CHECK_DEF(EEXIST); 301 CHECK_DEF(EXDEV); 302 CHECK_DEF(ENODEV); 303 CHECK_DEF(ENOTDIR); 304 CHECK_DEF(EISDIR); 305 CHECK_DEF(EINVAL); 306 CHECK_DEF(ENFILE); 307 CHECK_DEF(EMFILE); 308 CHECK_DEF(ENOTTY); 309 CHECK_DEF(EFBIG); 310 CHECK_DEF(ENOSPC); 311 CHECK_DEF(ESPIPE); 312 CHECK_DEF(EROFS); 313 CHECK_DEF(EMLINK); 314 CHECK_DEF(EPIPE); 315 CHECK_DEF(EDOM); 316 CHECK_DEF(ERANGE); 317 CHECK_DEF(EDEADLK); 318 CHECK_DEF(EDEADLOCK); 319 CHECK_DEF(ENAMETOOLONG); 320 CHECK_DEF(ENOLCK); 321 CHECK_DEF(ENOSYS); 322 CHECK_DEF(ENOTEMPTY); 323 CHECK_DEF(EILSEQ); 324 CHECK_DEF(LC_ALL); 325 CHECK_DEF(LC_COLLATE); 326 CHECK_DEF(LC_CTYPE); 327 CHECK_DEF(LC_MONETARY); 328 CHECK_DEF(LC_NUMERIC); 329 CHECK_DEF(LC_TIME); 330 CHECK_DEF(LC_MIN); 331 CHECK_DEF(LC_MAX); 332 CHECK_DEF(CLOCKS_PER_SEC); 333 CHECK_DEF(_HEAPEMPTY); 334 CHECK_DEF(_HEAPOK); 335 CHECK_DEF(_HEAPBADBEGIN); 336 CHECK_DEF(_HEAPBADNODE); 337 CHECK_DEF(_HEAPEND); 338 CHECK_DEF(_HEAPBADPTR); 339 CHECK_DEF(_FREEENTRY); 340 CHECK_DEF(_USEDENTRY); 341 CHECK_DEF(_OUT_TO_DEFAULT); 342 CHECK_DEF(_OUT_TO_STDERR); 343 CHECK_DEF(_OUT_TO_MSGBOX); 344 CHECK_DEF(_REPORT_ERRMODE); 345 CHECK_DEF(_UPPER); 346 CHECK_DEF(_LOWER); 347 CHECK_DEF(_DIGIT); 348 CHECK_DEF(_SPACE); 349 CHECK_DEF(_PUNCT); 350 CHECK_DEF(_CONTROL); 351 CHECK_DEF(_BLANK); 352 CHECK_DEF(_HEX); 353 CHECK_DEF(_LEADBYTE); 354 CHECK_DEF(_ALPHA); 355 CHECK_DEF(_IOREAD); 356 CHECK_DEF(_IOWRT); 357 CHECK_DEF(_IOMYBUF); 358 CHECK_DEF(_IOEOF); 359 CHECK_DEF(_IOERR); 360 CHECK_DEF(_IOSTRG); 361 CHECK_DEF(_IORW); 362 CHECK_DEF(_S_IEXEC); 363 CHECK_DEF(_S_IWRITE); 364 CHECK_DEF(_S_IREAD); 365 CHECK_DEF(_S_IFIFO); 366 CHECK_DEF(_S_IFCHR); 367 CHECK_DEF(_S_IFDIR); 368 CHECK_DEF(_S_IFREG); 369 CHECK_DEF(_S_IFMT); 370 CHECK_DEF(_LK_UNLCK); 371 CHECK_DEF(_LK_LOCK); 372 CHECK_DEF(_LK_NBLCK); 373 CHECK_DEF(_LK_RLCK); 374 CHECK_DEF(_LK_NBRLCK); 375 CHECK_DEF(_O_RDONLY); 376 CHECK_DEF(_O_WRONLY); 377 CHECK_DEF(_O_RDWR); 378 CHECK_DEF(_O_ACCMODE); 379 CHECK_DEF(_O_APPEND); 380 CHECK_DEF(_O_RANDOM); 381 CHECK_DEF(_O_SEQUENTIAL); 382 CHECK_DEF(_O_TEMPORARY); 383 CHECK_DEF(_O_NOINHERIT); 384 CHECK_DEF(_O_CREAT); 385 CHECK_DEF(_O_TRUNC); 386 CHECK_DEF(_O_EXCL); 387 CHECK_DEF(_O_SHORT_LIVED); 388 CHECK_DEF(_O_TEXT); 389 CHECK_DEF(_O_BINARY); 390 CHECK_DEF(_O_RAW); 391 CHECK_DEF(_SW_INEXACT); 392 CHECK_DEF(_SW_UNDERFLOW); 393 CHECK_DEF(_SW_OVERFLOW); 394 CHECK_DEF(_SW_ZERODIVIDE); 395 CHECK_DEF(_SW_INVALID); 396 CHECK_DEF(_SW_UNEMULATED); 397 CHECK_DEF(_SW_SQRTNEG); 398 CHECK_DEF(_SW_STACKOVERFLOW); 399 CHECK_DEF(_SW_STACKUNDERFLOW); 400 CHECK_DEF(_SW_DENORMAL); 401 CHECK_DEF(_FPCLASS_SNAN); 402 CHECK_DEF(_FPCLASS_QNAN); 403 CHECK_DEF(_FPCLASS_NINF); 404 CHECK_DEF(_FPCLASS_NN); 405 CHECK_DEF(_FPCLASS_ND); 406 CHECK_DEF(_FPCLASS_NZ); 407 CHECK_DEF(_FPCLASS_PZ); 408 CHECK_DEF(_FPCLASS_PD); 409 CHECK_DEF(_FPCLASS_PN); 410 CHECK_DEF(_FPCLASS_PINF); 411 CHECK_DEF(SIGINT); 412 CHECK_DEF(SIGILL); 413 CHECK_DEF(SIGFPE); 414 CHECK_DEF(SIGSEGV); 415 CHECK_DEF(SIGTERM); 416 CHECK_DEF(SIGBREAK); 417 CHECK_DEF(SIGABRT); 418 CHECK_DEF(NSIG); 419 CHECK_DEF(_FPE_INVALID); 420 CHECK_DEF(_FPE_DENORMAL); 421 CHECK_DEF(_FPE_ZERODIVIDE); 422 CHECK_DEF(_FPE_OVERFLOW); 423 CHECK_DEF(_FPE_UNDERFLOW); 424 CHECK_DEF(_FPE_INEXACT); 425 CHECK_DEF(_FPE_UNEMULATED); 426 CHECK_DEF(_FPE_SQRTNEG); 427 CHECK_DEF(_FPE_STACKOVERFLOW); 428 CHECK_DEF(_FPE_STACKUNDERFLOW); 429 CHECK_DEF(_FPE_EXPLICITGEN); 430 CHECK_DEF(_MCW_EM); 431 CHECK_DEF(_MCW_IC); 432 CHECK_DEF(_MCW_RC); 433 CHECK_DEF(_MCW_PC); 434 CHECK_DEF(_MCW_DN); 435 CHECK_DEF(_EM_INVALID); 436 CHECK_DEF(_EM_DENORMAL); 437 CHECK_DEF(_EM_ZERODIVIDE); 438 CHECK_DEF(_EM_OVERFLOW); 439 CHECK_DEF(_EM_UNDERFLOW); 440 CHECK_DEF(_EM_INEXACT); 441 CHECK_DEF(_IC_AFFINE); 442 CHECK_DEF(_IC_PROJECTIVE); 443 CHECK_DEF(_RC_CHOP); 444 CHECK_DEF(_RC_UP); 445 CHECK_DEF(_RC_DOWN); 446 CHECK_DEF(_RC_NEAR); 447 CHECK_DEF(_PC_24); 448 CHECK_DEF(_PC_53); 449 CHECK_DEF(_PC_64); 450 CHECK_DEF(_DN_SAVE); 451 CHECK_DEF(_DN_FLUSH); 452 CHECK_DEF(_DN_FLUSH_OPERANDS_SAVE_RESULTS); 453 CHECK_DEF(_DN_SAVE_OPERANDS_FLUSH_RESULTS); 454 CHECK_DEF(_EM_AMBIGUOUS); 455 CHECK_DEF(_OVERFLOW); 456 CHECK_DEF(_UNDERFLOW); 457 CHECK_DEF(_WRITE_ABORT_MSG); 458 CHECK_DEF(_CALL_REPORTFAULT); 459 CHECK_DEF(_TWO_DIGIT_EXPONENT); 460 } 461 462 #endif /* __WINE_USE_MSVCRT */ 463 464 START_TEST(headers) 465 { 466 #ifdef __WINE_USE_MSVCRT 467 test_types(); 468 test_structs(); 469 test_defines(); 470 #endif 471 } 472