git.oblomov.eu Git - wine/blob - dlls/msvcrt/tests/headers.c

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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  * symbol 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 "time.h"
  52 #include "locale.h"
  53 #include "setjmp.h"
  54 #include "wine/test.h"
  55
  56 #ifdef __WINE_USE_MSVCRT
  57 /* Wine-specific msvcrt headers */
  58 #define __WINE_MSVCRT_TEST
  59 #include "eh.h"
  60 #include "msvcrt.h"
  61
  62 #ifdef __GNUC__
  63 #define TYPEOF(type) typeof(type)
  64 #else
  65 #define TYPEOF(type) int
  66 #endif
  67 #define MSVCRT(x)    MSVCRT_##x
  68 #define OFFSET(T,F) ((unsigned int)((char *)&((struct T *)0L)->F - (char *)0L))
  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 = 0; 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(OFFSET(s,e) == OFFSET(MSVCRT(s),e), "Bad offset\n")
  73 #define CHECK_DEF(n,d1,d2) ok(d1 == d2, "Defines (MSVCRT_)%s are different: '%d' vs. '%d'\n", n, d1, d2)
  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(time_t);
  90     CHECK_TYPE(fpos_t);
  91     CHECK_SIZE(FILE);
  92     CHECK_TYPE(terminate_handler);
  93     CHECK_TYPE(terminate_function);
  94     CHECK_TYPE(unexpected_handler);
  95     CHECK_TYPE(unexpected_function);
  96     CHECK_TYPE(_se_translator_function);
  97     CHECK_TYPE(_beginthread_start_routine_t);
  98     CHECK_TYPE(_onexit_t);
  99 }
 100
 101 /************* Checking structs ***************/
 102 static void test_structs(void)
 103 {
 104     CHECK_STRUCT(tm);
 105     CHECK_FIELD(tm, tm_sec);
 106     CHECK_FIELD(tm, tm_min);
 107     CHECK_FIELD(tm, tm_hour);
 108     CHECK_FIELD(tm, tm_mday);
 109     CHECK_FIELD(tm, tm_mon);
 110     CHECK_FIELD(tm, tm_year);
 111     CHECK_FIELD(tm, tm_wday);
 112     CHECK_FIELD(tm, tm_yday);
 113     CHECK_FIELD(tm, tm_isdst);
 114     CHECK_STRUCT(_timeb);
 115     CHECK_FIELD(_timeb, time);
 116     CHECK_FIELD(_timeb, millitm);
 117     CHECK_FIELD(_timeb, timezone);
 118     CHECK_FIELD(_timeb, dstflag);
 119     CHECK_STRUCT(_iobuf);
 120     CHECK_FIELD(_iobuf, _ptr);
 121     CHECK_FIELD(_iobuf, _cnt);
 122     CHECK_FIELD(_iobuf, _base);
 123     CHECK_FIELD(_iobuf, _flag);
 124     CHECK_FIELD(_iobuf, _file);
 125     CHECK_FIELD(_iobuf, _charbuf);
 126     CHECK_FIELD(_iobuf, _bufsiz);
 127     CHECK_FIELD(_iobuf, _tmpfname);
 128     CHECK_STRUCT(lconv);
 129     CHECK_FIELD(lconv, decimal_point);
 130     CHECK_FIELD(lconv, thousands_sep);
 131     CHECK_FIELD(lconv, grouping);
 132     CHECK_FIELD(lconv, int_curr_symbol);
 133     CHECK_FIELD(lconv, currency_symbol);
 134     CHECK_FIELD(lconv, mon_decimal_point);
 135     CHECK_FIELD(lconv, mon_thousands_sep);
 136     CHECK_FIELD(lconv, mon_grouping);
 137     CHECK_FIELD(lconv, positive_sign);
 138     CHECK_FIELD(lconv, negative_sign);
 139     CHECK_FIELD(lconv, int_frac_digits);
 140     CHECK_FIELD(lconv, frac_digits);
 141     CHECK_FIELD(lconv, p_cs_precedes);
 142     CHECK_FIELD(lconv, p_sep_by_space);
 143     CHECK_FIELD(lconv, n_cs_precedes);
 144     CHECK_FIELD(lconv, n_sep_by_space);
 145     CHECK_FIELD(lconv, p_sign_posn);
 146     CHECK_FIELD(lconv, n_sign_posn);
 147     CHECK_STRUCT(_exception);
 148     CHECK_FIELD(_exception, type);
 149     CHECK_FIELD(_exception, name);
 150     CHECK_FIELD(_exception, arg1);
 151     CHECK_FIELD(_exception, arg2);
 152     CHECK_FIELD(_exception, retval);
 153     CHECK_STRUCT(_complex);
 154     CHECK_FIELD(_complex, x);
 155     CHECK_FIELD(_complex, y);
 156     CHECK_STRUCT(_div_t);
 157     CHECK_FIELD(_div_t, quot);
 158     CHECK_FIELD(_div_t, rem);
 159     CHECK_STRUCT(_ldiv_t);
 160     CHECK_FIELD(_ldiv_t, quot);
 161     CHECK_FIELD(_ldiv_t, rem);
 162     CHECK_STRUCT(_heapinfo);
 163     CHECK_FIELD(_heapinfo, _pentry);
 164     CHECK_FIELD(_heapinfo, _size);
 165     CHECK_FIELD(_heapinfo, _useflag);
 166 #ifdef __i386__
 167     CHECK_STRUCT(__JUMP_BUFFER);
 168     CHECK_FIELD(__JUMP_BUFFER, Ebp);
 169     CHECK_FIELD(__JUMP_BUFFER, Ebx);
 170     CHECK_FIELD(__JUMP_BUFFER, Edi);
 171     CHECK_FIELD(__JUMP_BUFFER, Esi);
 172     CHECK_FIELD(__JUMP_BUFFER, Esp);
 173     CHECK_FIELD(__JUMP_BUFFER, Eip);
 174     CHECK_FIELD(__JUMP_BUFFER, Registration);
 175     CHECK_FIELD(__JUMP_BUFFER, TryLevel);
 176     CHECK_FIELD(__JUMP_BUFFER, Cookie);
 177     CHECK_FIELD(__JUMP_BUFFER, UnwindFunc);
 178     CHECK_FIELD(__JUMP_BUFFER, UnwindData[6]);
 179 #endif
 180     CHECK_STRUCT(_diskfree_t);
 181     CHECK_FIELD(_diskfree_t, total_clusters);
 182     CHECK_FIELD(_diskfree_t, avail_clusters);
 183     CHECK_FIELD(_diskfree_t, sectors_per_cluster);
 184     CHECK_FIELD(_diskfree_t, bytes_per_sector);
 185     CHECK_STRUCT(_finddata_t);
 186     CHECK_FIELD(_finddata_t, attrib);
 187     CHECK_FIELD(_finddata_t, time_create);
 188     CHECK_FIELD(_finddata_t, time_access);
 189     CHECK_FIELD(_finddata_t, time_write);
 190     CHECK_FIELD(_finddata_t, size);
 191     CHECK_FIELD(_finddata_t, name[260]);
 192     CHECK_STRUCT(_finddatai64_t);
 193     CHECK_FIELD(_finddatai64_t, attrib);
 194     CHECK_FIELD(_finddatai64_t, time_create);
 195     CHECK_FIELD(_finddatai64_t, time_access);
 196     CHECK_FIELD(_finddatai64_t, time_write);
 197     CHECK_FIELD(_finddatai64_t, size);
 198     CHECK_FIELD(_finddatai64_t, name[260]);
 199     CHECK_STRUCT(_wfinddata_t);
 200     CHECK_FIELD(_wfinddata_t, attrib);
 201     CHECK_FIELD(_wfinddata_t, time_create);
 202     CHECK_FIELD(_wfinddata_t, time_access);
 203     CHECK_FIELD(_wfinddata_t, time_write);
 204     CHECK_FIELD(_wfinddata_t, size);
 205     CHECK_FIELD(_wfinddata_t, name[260]);
 206     CHECK_STRUCT(_wfinddatai64_t);
 207     CHECK_FIELD(_wfinddatai64_t, attrib);
 208     CHECK_FIELD(_wfinddatai64_t, time_create);
 209     CHECK_FIELD(_wfinddatai64_t, time_access);
 210     CHECK_FIELD(_wfinddatai64_t, time_write);
 211     CHECK_FIELD(_wfinddatai64_t, size);
 212     CHECK_FIELD(_wfinddatai64_t, name[260]);
 213     CHECK_STRUCT(_utimbuf);
 214     CHECK_FIELD(_utimbuf, actime);
 215     CHECK_FIELD(_utimbuf, modtime);
 216     CHECK_STRUCT(_stat);
 217     CHECK_FIELD(_stat, st_dev);
 218     CHECK_FIELD(_stat, st_ino);
 219     CHECK_FIELD(_stat, st_mode);
 220     CHECK_FIELD(_stat, st_nlink);
 221     CHECK_FIELD(_stat, st_uid);
 222     CHECK_FIELD(_stat, st_gid);
 223     CHECK_FIELD(_stat, st_rdev);
 224     CHECK_FIELD(_stat, st_size);
 225     CHECK_FIELD(_stat, st_atime);
 226     CHECK_FIELD(_stat, st_mtime);
 227     CHECK_FIELD(_stat, st_ctime);
 228     CHECK_FIELD(_stat, st_dev);
 229     CHECK_FIELD(_stat, st_ino);
 230     CHECK_FIELD(_stat, st_mode);
 231     CHECK_FIELD(_stat, st_nlink);
 232     CHECK_FIELD(_stat, st_uid);
 233     CHECK_FIELD(_stat, st_gid);
 234     CHECK_FIELD(_stat, st_rdev);
 235     CHECK_FIELD(_stat, st_size);
 236     CHECK_FIELD(_stat, st_atime);
 237     CHECK_FIELD(_stat, st_mtime);
 238     CHECK_FIELD(_stat, st_ctime);
 239     CHECK_FIELD(_stat, st_dev);
 240     CHECK_FIELD(_stat, st_ino);
 241     CHECK_FIELD(_stat, st_mode);
 242     CHECK_FIELD(_stat, st_nlink);
 243     CHECK_FIELD(_stat, st_uid);
 244     CHECK_FIELD(_stat, st_gid);
 245     CHECK_FIELD(_stat, st_rdev);
 246     CHECK_FIELD(_stat, st_size);
 247     CHECK_FIELD(_stat, st_atime);
 248     CHECK_FIELD(_stat, st_mtime);
 249     CHECK_FIELD(_stat, st_ctime);
 250     CHECK_STRUCT(stat);
 251     CHECK_FIELD(stat, st_dev);
 252     CHECK_FIELD(stat, st_ino);
 253     CHECK_FIELD(stat, st_mode);
 254     CHECK_FIELD(stat, st_nlink);
 255     CHECK_FIELD(stat, st_uid);
 256     CHECK_FIELD(stat, st_gid);
 257     CHECK_FIELD(stat, st_rdev);
 258     CHECK_FIELD(stat, st_size);
 259     CHECK_FIELD(stat, st_atime);
 260     CHECK_FIELD(stat, st_mtime);
 261     CHECK_FIELD(stat, st_ctime);
 262     CHECK_FIELD(stat, st_dev);
 263     CHECK_FIELD(stat, st_ino);
 264     CHECK_FIELD(stat, st_mode);
 265     CHECK_FIELD(stat, st_nlink);
 266     CHECK_FIELD(stat, st_uid);
 267     CHECK_FIELD(stat, st_gid);
 268     CHECK_FIELD(stat, st_rdev);
 269     CHECK_FIELD(stat, st_size);
 270     CHECK_FIELD(stat, st_atime);
 271     CHECK_FIELD(stat, st_mtime);
 272     CHECK_FIELD(stat, st_ctime);
 273     CHECK_FIELD(stat, st_dev);
 274     CHECK_FIELD(stat, st_ino);
 275     CHECK_FIELD(stat, st_mode);
 276     CHECK_FIELD(stat, st_nlink);
 277     CHECK_FIELD(stat, st_uid);
 278     CHECK_FIELD(stat, st_gid);
 279     CHECK_FIELD(stat, st_rdev);
 280     CHECK_FIELD(stat, st_size);
 281     CHECK_FIELD(stat, st_atime);
 282     CHECK_FIELD(stat, st_mtime);
 283     CHECK_FIELD(stat, st_ctime);
 284     CHECK_STRUCT(_stati64);
 285     CHECK_FIELD(_stati64, st_dev);
 286     CHECK_FIELD(_stati64, st_ino);
 287     CHECK_FIELD(_stati64, st_mode);
 288     CHECK_FIELD(_stati64, st_nlink);
 289     CHECK_FIELD(_stati64, st_uid);
 290     CHECK_FIELD(_stati64, st_gid);
 291     CHECK_FIELD(_stati64, st_rdev);
 292     CHECK_FIELD(_stati64, st_size);
 293     CHECK_FIELD(_stati64, st_atime);
 294     CHECK_FIELD(_stati64, st_mtime);
 295     CHECK_FIELD(_stati64, st_ctime);
 296 }
 297
 298 /************* Checking defines ***************/
 299 static void test_defines(void)
 300 {
 301     CHECK_DEF("WEOF", WEOF, MSVCRT_WEOF);
 302     CHECK_DEF("EOF", EOF, MSVCRT_EOF);
 303     CHECK_DEF("TMP_MAX", TMP_MAX, MSVCRT_TMP_MAX);
 304     CHECK_DEF("BUFSIZ", BUFSIZ, MSVCRT_BUFSIZ);
 305     CHECK_DEF("STDIN_FILENO", STDIN_FILENO, MSVCRT_STDIN_FILENO);
 306     CHECK_DEF("STDOUT_FILENO", STDOUT_FILENO, MSVCRT_STDOUT_FILENO);
 307     CHECK_DEF("STDERR_FILENO", STDERR_FILENO, MSVCRT_STDERR_FILENO);
 308     CHECK_DEF("_IOFBF", _IOFBF, MSVCRT__IOFBF);
 309     CHECK_DEF("_IONBF", _IONBF, MSVCRT__IONBF);
 310     CHECK_DEF("_IOLBF", _IOLBF, MSVCRT__IOLBF);
 311     CHECK_DEF("FILENAME_MAX", FILENAME_MAX, MSVCRT_FILENAME_MAX);
 312     CHECK_DEF("_P_WAIT", _P_WAIT, MSVCRT__P_WAIT);
 313     CHECK_DEF("_P_NOWAIT", _P_NOWAIT, MSVCRT__P_NOWAIT);
 314     CHECK_DEF("_P_OVERLAY", _P_OVERLAY, MSVCRT__P_OVERLAY);
 315     CHECK_DEF("_P_NOWAITO", _P_NOWAITO, MSVCRT__P_NOWAITO);
 316     CHECK_DEF("_P_DETACH", _P_DETACH, MSVCRT__P_DETACH);
 317     CHECK_DEF("EPERM", EPERM, MSVCRT_EPERM);
 318     CHECK_DEF("ENOENT", ENOENT, MSVCRT_ENOENT);
 319     CHECK_DEF("ESRCH", ESRCH, MSVCRT_ESRCH);
 320     CHECK_DEF("EINTR", EINTR, MSVCRT_EINTR);
 321     CHECK_DEF("EIO", EIO, MSVCRT_EIO);
 322     CHECK_DEF("ENXIO", ENXIO, MSVCRT_ENXIO);
 323     CHECK_DEF("E2BIG", E2BIG, MSVCRT_E2BIG);
 324     CHECK_DEF("ENOEXEC", ENOEXEC, MSVCRT_ENOEXEC);
 325     CHECK_DEF("EBADF", EBADF, MSVCRT_EBADF);
 326     CHECK_DEF("ECHILD", ECHILD, MSVCRT_ECHILD);
 327     CHECK_DEF("EAGAIN", EAGAIN, MSVCRT_EAGAIN);
 328     CHECK_DEF("ENOMEM", ENOMEM, MSVCRT_ENOMEM);
 329     CHECK_DEF("EACCES", EACCES, MSVCRT_EACCES);
 330     CHECK_DEF("EFAULT", EFAULT, MSVCRT_EFAULT);
 331     CHECK_DEF("EBUSY", EBUSY, MSVCRT_EBUSY);
 332     CHECK_DEF("EEXIST", EEXIST, MSVCRT_EEXIST);
 333     CHECK_DEF("EXDEV", EXDEV, MSVCRT_EXDEV);
 334     CHECK_DEF("ENODEV", ENODEV, MSVCRT_ENODEV);
 335     CHECK_DEF("ENOTDIR", ENOTDIR, MSVCRT_ENOTDIR);
 336     CHECK_DEF("EISDIR", EISDIR, MSVCRT_EISDIR);
 337     CHECK_DEF("EINVAL", EINVAL, MSVCRT_EINVAL);
 338     CHECK_DEF("ENFILE", ENFILE, MSVCRT_ENFILE);
 339     CHECK_DEF("EMFILE", EMFILE, MSVCRT_EMFILE);
 340     CHECK_DEF("ENOTTY", ENOTTY, MSVCRT_ENOTTY);
 341     CHECK_DEF("EFBIG", EFBIG, MSVCRT_EFBIG);
 342     CHECK_DEF("ENOSPC", ENOSPC, MSVCRT_ENOSPC);
 343     CHECK_DEF("ESPIPE", ESPIPE, MSVCRT_ESPIPE);
 344     CHECK_DEF("EROFS", EROFS, MSVCRT_EROFS);
 345     CHECK_DEF("EMLINK", EMLINK, MSVCRT_EMLINK);
 346     CHECK_DEF("EPIPE", EPIPE, MSVCRT_EPIPE);
 347     CHECK_DEF("EDOM", EDOM, MSVCRT_EDOM);
 348     CHECK_DEF("ERANGE", ERANGE, MSVCRT_ERANGE);
 349     CHECK_DEF("EDEADLK", EDEADLK, MSVCRT_EDEADLK);
 350     CHECK_DEF("EDEADLOCK", EDEADLOCK, MSVCRT_EDEADLOCK);
 351     CHECK_DEF("ENAMETOOLONG", ENAMETOOLONG, MSVCRT_ENAMETOOLONG);
 352     CHECK_DEF("ENOLCK", ENOLCK, MSVCRT_ENOLCK);
 353     CHECK_DEF("ENOSYS", ENOSYS, MSVCRT_ENOSYS);
 354     CHECK_DEF("ENOTEMPTY", ENOTEMPTY, MSVCRT_ENOTEMPTY);
 355     CHECK_DEF("LC_ALL", LC_ALL, MSVCRT_LC_ALL);
 356     CHECK_DEF("LC_COLLATE", LC_COLLATE, MSVCRT_LC_COLLATE);
 357     CHECK_DEF("LC_CTYPE", LC_CTYPE, MSVCRT_LC_CTYPE);
 358     CHECK_DEF("LC_MONETARY", LC_MONETARY, MSVCRT_LC_MONETARY);
 359     CHECK_DEF("LC_NUMERIC", LC_NUMERIC, MSVCRT_LC_NUMERIC);
 360     CHECK_DEF("LC_TIME", LC_TIME, MSVCRT_LC_TIME);
 361     CHECK_DEF("LC_MIN", LC_MIN, MSVCRT_LC_MIN);
 362     CHECK_DEF("LC_MAX", LC_MAX, MSVCRT_LC_MAX);
 363     CHECK_DEF("CLOCKS_PER_SEC", CLOCKS_PER_SEC, MSVCRT_CLOCKS_PER_SEC);
 364     CHECK_DEF("_HEAPEMPTY", _HEAPEMPTY, MSVCRT__HEAPEMPTY);
 365     CHECK_DEF("_HEAPOK", _HEAPOK, MSVCRT__HEAPOK);
 366     CHECK_DEF("_HEAPBADBEGIN", _HEAPBADBEGIN, MSVCRT__HEAPBADBEGIN);
 367     CHECK_DEF("_HEAPBADNODE", _HEAPBADNODE, MSVCRT__HEAPBADNODE);
 368     CHECK_DEF("_HEAPEND", _HEAPEND, MSVCRT__HEAPEND);
 369     CHECK_DEF("_HEAPBADPTR", _HEAPBADPTR, MSVCRT__HEAPBADPTR);
 370     CHECK_DEF("_FREEENTRY", _FREEENTRY, MSVCRT__FREEENTRY);
 371     CHECK_DEF("_USEDENTRY", _USEDENTRY, MSVCRT__USEDENTRY);
 372     CHECK_DEF("_OUT_TO_DEFAULT", _OUT_TO_DEFAULT, MSVCRT__OUT_TO_DEFAULT);
 373     CHECK_DEF("_REPORT_ERRMODE", _REPORT_ERRMODE, MSVCRT__REPORT_ERRMODE);
 374     CHECK_DEF("_UPPER", _UPPER, MSVCRT__UPPER);
 375     CHECK_DEF("_LOWER", _LOWER, MSVCRT__LOWER);
 376     CHECK_DEF("_DIGIT", _DIGIT, MSVCRT__DIGIT);
 377     CHECK_DEF("_SPACE", _SPACE, MSVCRT__SPACE);
 378     CHECK_DEF("_PUNCT", _PUNCT, MSVCRT__PUNCT);
 379     CHECK_DEF("_CONTROL", _CONTROL, MSVCRT__CONTROL);
 380     CHECK_DEF("_BLANK", _BLANK, MSVCRT__BLANK);
 381     CHECK_DEF("_HEX", _HEX, MSVCRT__HEX);
 382     CHECK_DEF("_LEADBYTE", _LEADBYTE, MSVCRT__LEADBYTE);
 383     CHECK_DEF("_ALPHA", _ALPHA, MSVCRT__ALPHA);
 384     CHECK_DEF("_IOREAD", _IOREAD, MSVCRT__IOREAD);
 385     CHECK_DEF("_IOWRT", _IOWRT, MSVCRT__IOWRT);
 386     CHECK_DEF("_IOMYBUF", _IOMYBUF, MSVCRT__IOMYBUF);
 387     CHECK_DEF("_IOEOF", _IOEOF, MSVCRT__IOEOF);
 388     CHECK_DEF("_IOERR", _IOERR, MSVCRT__IOERR);
 389     CHECK_DEF("_IOSTRG", _IOSTRG, MSVCRT__IOSTRG);
 390     CHECK_DEF("_IORW", _IORW, MSVCRT__IORW);
 391     CHECK_DEF("_S_IEXEC", _S_IEXEC, MSVCRT__S_IEXEC);
 392     CHECK_DEF("_S_IWRITE", _S_IWRITE, MSVCRT__S_IWRITE);
 393     CHECK_DEF("_S_IREAD", _S_IREAD, MSVCRT__S_IREAD);
 394     CHECK_DEF("_S_IFIFO", _S_IFIFO, MSVCRT__S_IFIFO);
 395     CHECK_DEF("_S_IFCHR", _S_IFCHR, MSVCRT__S_IFCHR);
 396     CHECK_DEF("_S_IFDIR", _S_IFDIR, MSVCRT__S_IFDIR);
 397     CHECK_DEF("_S_IFREG", _S_IFREG, MSVCRT__S_IFREG);
 398     CHECK_DEF("_S_IFMT", _S_IFMT, MSVCRT__S_IFMT);
 399     CHECK_DEF("_LK_UNLCK", _LK_UNLCK, MSVCRT__LK_UNLCK);
 400     CHECK_DEF("_LK_LOCK", _LK_LOCK, MSVCRT__LK_LOCK);
 401     CHECK_DEF("_LK_NBLCK", _LK_NBLCK, MSVCRT__LK_NBLCK);
 402     CHECK_DEF("_LK_RLCK", _LK_RLCK, MSVCRT__LK_RLCK);
 403     CHECK_DEF("_LK_NBRLCK", _LK_NBRLCK, MSVCRT__LK_NBRLCK);
 404     CHECK_DEF("_O_RDONLY", _O_RDONLY, MSVCRT__O_RDONLY);
 405     CHECK_DEF("_O_WRONLY", _O_WRONLY, MSVCRT__O_WRONLY);
 406     CHECK_DEF("_O_RDWR", _O_RDWR, MSVCRT__O_RDWR);
 407     CHECK_DEF("_O_ACCMODE", _O_ACCMODE, MSVCRT__O_ACCMODE);
 408     CHECK_DEF("_O_APPEND", _O_APPEND, MSVCRT__O_APPEND);
 409     CHECK_DEF("_O_RANDOM", _O_RANDOM, MSVCRT__O_RANDOM);
 410     CHECK_DEF("_O_SEQUENTIAL", _O_SEQUENTIAL, MSVCRT__O_SEQUENTIAL);
 411     CHECK_DEF("_O_TEMPORARY", _O_TEMPORARY, MSVCRT__O_TEMPORARY);
 412     CHECK_DEF("_O_NOINHERIT", _O_NOINHERIT, MSVCRT__O_NOINHERIT);
 413     CHECK_DEF("_O_CREAT", _O_CREAT, MSVCRT__O_CREAT);
 414     CHECK_DEF("_O_TRUNC", _O_TRUNC, MSVCRT__O_TRUNC);
 415     CHECK_DEF("_O_EXCL", _O_EXCL, MSVCRT__O_EXCL);
 416     CHECK_DEF("_O_SHORT_LIVED", _O_SHORT_LIVED, MSVCRT__O_SHORT_LIVED);
 417     CHECK_DEF("_O_TEXT", _O_TEXT, MSVCRT__O_TEXT);
 418     CHECK_DEF("_O_BINARY", _O_BINARY, MSVCRT__O_BINARY);
 419     CHECK_DEF("_O_RAW", _O_RAW, MSVCRT__O_RAW);
 420     CHECK_DEF("_SW_INEXACT", _SW_INEXACT, MSVCRT__SW_INEXACT);
 421     CHECK_DEF("_SW_UNDERFLOW", _SW_UNDERFLOW, MSVCRT__SW_UNDERFLOW);
 422     CHECK_DEF("_SW_OVERFLOW", _SW_OVERFLOW, MSVCRT__SW_OVERFLOW);
 423     CHECK_DEF("_SW_ZERODIVIDE", _SW_ZERODIVIDE, MSVCRT__SW_ZERODIVIDE);
 424     CHECK_DEF("_SW_INVALID", _SW_INVALID, MSVCRT__SW_INVALID);
 425     CHECK_DEF("_SW_UNEMULATED", _SW_UNEMULATED, MSVCRT__SW_UNEMULATED);
 426     CHECK_DEF("_SW_SQRTNEG", _SW_SQRTNEG, MSVCRT__SW_SQRTNEG);
 427     CHECK_DEF("_SW_STACKOVERFLOW", _SW_STACKOVERFLOW, MSVCRT__SW_STACKOVERFLOW);
 428     CHECK_DEF("_SW_STACKUNDERFLOW", _SW_STACKUNDERFLOW, MSVCRT__SW_STACKUNDERFLOW);
 429     CHECK_DEF("_SW_DENORMAL", _SW_DENORMAL, MSVCRT__SW_DENORMAL);
 430     CHECK_DEF("_FPCLASS_SNAN", _FPCLASS_SNAN, MSVCRT__FPCLASS_SNAN);
 431     CHECK_DEF("_FPCLASS_QNAN", _FPCLASS_QNAN, MSVCRT__FPCLASS_QNAN);
 432     CHECK_DEF("_FPCLASS_NINF", _FPCLASS_NINF, MSVCRT__FPCLASS_NINF);
 433     CHECK_DEF("_FPCLASS_NN", _FPCLASS_NN, MSVCRT__FPCLASS_NN);
 434     CHECK_DEF("_FPCLASS_ND", _FPCLASS_ND, MSVCRT__FPCLASS_ND);
 435     CHECK_DEF("_FPCLASS_NZ", _FPCLASS_NZ, MSVCRT__FPCLASS_NZ);
 436     CHECK_DEF("_FPCLASS_PZ", _FPCLASS_PZ, MSVCRT__FPCLASS_PZ);
 437     CHECK_DEF("_FPCLASS_PD", _FPCLASS_PD, MSVCRT__FPCLASS_PD);
 438     CHECK_DEF("_FPCLASS_PN", _FPCLASS_PN, MSVCRT__FPCLASS_PN);
 439     CHECK_DEF("_FPCLASS_PINF", _FPCLASS_PINF, MSVCRT__FPCLASS_PINF);
 440 #ifdef __i386__
 441     CHECK_DEF("_EM_INVALID", _EM_INVALID, MSVCRT__EM_INVALID);
 442     CHECK_DEF("_EM_DENORMAL", _EM_DENORMAL, MSVCRT__EM_DENORMAL);
 443     CHECK_DEF("_EM_ZERODIVIDE", _EM_ZERODIVIDE, MSVCRT__EM_ZERODIVIDE);
 444     CHECK_DEF("_EM_OVERFLOW", _EM_OVERFLOW, MSVCRT__EM_OVERFLOW);
 445     CHECK_DEF("_EM_UNDERFLOW", _EM_UNDERFLOW, MSVCRT__EM_UNDERFLOW);
 446     CHECK_DEF("_EM_INEXACT", _EM_INEXACT, MSVCRT__EM_INEXACT);
 447     CHECK_DEF("_IC_AFFINE", _IC_AFFINE, MSVCRT__IC_AFFINE);
 448     CHECK_DEF("_IC_PROJECTIVE", _IC_PROJECTIVE, MSVCRT__IC_PROJECTIVE);
 449     CHECK_DEF("_RC_CHOP", _RC_CHOP, MSVCRT__RC_CHOP);
 450     CHECK_DEF("_RC_UP", _RC_UP, MSVCRT__RC_UP);
 451     CHECK_DEF("_RC_DOWN", _RC_DOWN, MSVCRT__RC_DOWN);
 452     CHECK_DEF("_RC_NEAR", _RC_NEAR, MSVCRT__RC_NEAR);
 453     CHECK_DEF("_PC_24", _PC_24, MSVCRT__PC_24);
 454     CHECK_DEF("_PC_53", _PC_53, MSVCRT__PC_53);
 455     CHECK_DEF("_PC_64", _PC_64, MSVCRT__PC_64);
 456 #endif
 457 }
 458
 459 #endif /* __WINE_USE_MSVCRT */
 460
 461 START_TEST(headers)
 462 {
 463 #ifdef __WINE_USE_MSVCRT
 464     test_types();
 465     test_structs();
 466     test_defines();
 467 #endif
 468 }