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., 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 OFFSET(T,F) ((unsigned int)((char *)&((struct T *)0L)->F - (char *)0L))
  70 #define CHECK_SIZE(e) ok(sizeof(e) == sizeof(MSVCRT(e)), "Element has different sizes\n")
  71 #define CHECK_TYPE(t) { TYPEOF(t) a = 0; TYPEOF(MSVCRT(t)) b = 0; a = b; CHECK_SIZE(t); }
  72 #define CHECK_STRUCT(s) ok(sizeof(struct s) == sizeof(struct MSVCRT(s)), "Struct has different sizes\n")
  73 #define CHECK_FIELD(s,e) ok(OFFSET(s,e) == OFFSET(MSVCRT(s),e), "Bad offset\n")
  74 #define CHECK_DEF(d) ok(d == MSVCRT_##d, "Defines (MSVCRT_)" #d " are different: %d vs. %d\n", d, MSVCRT_##d)
  75
  76 /************* Checking types ***************/
  77 static void test_types(void)
  78 {
  79     CHECK_TYPE(wchar_t);
  80     CHECK_TYPE(wint_t);
  81     CHECK_TYPE(wctype_t);
  82     CHECK_TYPE(_ino_t);
  83     CHECK_TYPE(_fsize_t);
  84     CHECK_TYPE(size_t);
  85     CHECK_TYPE(intptr_t);
  86     CHECK_TYPE(uintptr_t);
  87     CHECK_TYPE(_dev_t);
  88     CHECK_TYPE(_off_t);
  89     CHECK_TYPE(clock_t);
  90     CHECK_TYPE(time_t);
  91     CHECK_TYPE(__time32_t);
  92     CHECK_TYPE(__time64_t);
  93     CHECK_TYPE(fpos_t);
  94     CHECK_SIZE(FILE);
  95     CHECK_TYPE(terminate_handler);
  96     CHECK_TYPE(terminate_function);
  97     CHECK_TYPE(unexpected_handler);
  98     CHECK_TYPE(unexpected_function);
  99     CHECK_TYPE(_se_translator_function);
 100     CHECK_TYPE(_beginthread_start_routine_t);
 101     CHECK_TYPE(_onexit_t);
 102     CHECK_TYPE(__sighandler_t);
 103 }
 104
 105 /************* Checking structs ***************/
 106 static void test_structs(void)
 107 {
 108     CHECK_STRUCT(tm);
 109     CHECK_FIELD(tm, tm_sec);
 110     CHECK_FIELD(tm, tm_min);
 111     CHECK_FIELD(tm, tm_hour);
 112     CHECK_FIELD(tm, tm_mday);
 113     CHECK_FIELD(tm, tm_mon);
 114     CHECK_FIELD(tm, tm_year);
 115     CHECK_FIELD(tm, tm_wday);
 116     CHECK_FIELD(tm, tm_yday);
 117     CHECK_FIELD(tm, tm_isdst);
 118     CHECK_STRUCT(_timeb);
 119     CHECK_FIELD(_timeb, time);
 120     CHECK_FIELD(_timeb, millitm);
 121     CHECK_FIELD(_timeb, timezone);
 122     CHECK_FIELD(_timeb, dstflag);
 123     CHECK_STRUCT(_iobuf);
 124     CHECK_FIELD(_iobuf, _ptr);
 125     CHECK_FIELD(_iobuf, _cnt);
 126     CHECK_FIELD(_iobuf, _base);
 127     CHECK_FIELD(_iobuf, _flag);
 128     CHECK_FIELD(_iobuf, _file);
 129     CHECK_FIELD(_iobuf, _charbuf);
 130     CHECK_FIELD(_iobuf, _bufsiz);
 131     CHECK_FIELD(_iobuf, _tmpfname);
 132     CHECK_STRUCT(lconv);
 133     CHECK_FIELD(lconv, decimal_point);
 134     CHECK_FIELD(lconv, thousands_sep);
 135     CHECK_FIELD(lconv, grouping);
 136     CHECK_FIELD(lconv, int_curr_symbol);
 137     CHECK_FIELD(lconv, currency_symbol);
 138     CHECK_FIELD(lconv, mon_decimal_point);
 139     CHECK_FIELD(lconv, mon_thousands_sep);
 140     CHECK_FIELD(lconv, mon_grouping);
 141     CHECK_FIELD(lconv, positive_sign);
 142     CHECK_FIELD(lconv, negative_sign);
 143     CHECK_FIELD(lconv, int_frac_digits);
 144     CHECK_FIELD(lconv, frac_digits);
 145     CHECK_FIELD(lconv, p_cs_precedes);
 146     CHECK_FIELD(lconv, p_sep_by_space);
 147     CHECK_FIELD(lconv, n_cs_precedes);
 148     CHECK_FIELD(lconv, n_sep_by_space);
 149     CHECK_FIELD(lconv, p_sign_posn);
 150     CHECK_FIELD(lconv, n_sign_posn);
 151     CHECK_STRUCT(_exception);
 152     CHECK_FIELD(_exception, type);
 153     CHECK_FIELD(_exception, name);
 154     CHECK_FIELD(_exception, arg1);
 155     CHECK_FIELD(_exception, arg2);
 156     CHECK_FIELD(_exception, retval);
 157     CHECK_STRUCT(_complex);
 158     CHECK_FIELD(_complex, x);
 159     CHECK_FIELD(_complex, y);
 160     CHECK_STRUCT(_div_t);
 161     CHECK_FIELD(_div_t, quot);
 162     CHECK_FIELD(_div_t, rem);
 163     CHECK_STRUCT(_ldiv_t);
 164     CHECK_FIELD(_ldiv_t, quot);
 165     CHECK_FIELD(_ldiv_t, rem);
 166     CHECK_STRUCT(_heapinfo);
 167     CHECK_FIELD(_heapinfo, _pentry);
 168     CHECK_FIELD(_heapinfo, _size);
 169     CHECK_FIELD(_heapinfo, _useflag);
 170 #ifdef __i386__
 171     CHECK_STRUCT(__JUMP_BUFFER);
 172     CHECK_FIELD(__JUMP_BUFFER, Ebp);
 173     CHECK_FIELD(__JUMP_BUFFER, Ebx);
 174     CHECK_FIELD(__JUMP_BUFFER, Edi);
 175     CHECK_FIELD(__JUMP_BUFFER, Esi);
 176     CHECK_FIELD(__JUMP_BUFFER, Esp);
 177     CHECK_FIELD(__JUMP_BUFFER, Eip);
 178     CHECK_FIELD(__JUMP_BUFFER, Registration);
 179     CHECK_FIELD(__JUMP_BUFFER, TryLevel);
 180     CHECK_FIELD(__JUMP_BUFFER, Cookie);
 181     CHECK_FIELD(__JUMP_BUFFER, UnwindFunc);
 182     CHECK_FIELD(__JUMP_BUFFER, UnwindData[6]);
 183 #endif
 184     CHECK_STRUCT(_diskfree_t);
 185     CHECK_FIELD(_diskfree_t, total_clusters);
 186     CHECK_FIELD(_diskfree_t, avail_clusters);
 187     CHECK_FIELD(_diskfree_t, sectors_per_cluster);
 188     CHECK_FIELD(_diskfree_t, bytes_per_sector);
 189     CHECK_STRUCT(_finddata_t);
 190     CHECK_FIELD(_finddata_t, attrib);
 191     CHECK_FIELD(_finddata_t, time_create);
 192     CHECK_FIELD(_finddata_t, time_access);
 193     CHECK_FIELD(_finddata_t, time_write);
 194     CHECK_FIELD(_finddata_t, size);
 195     CHECK_FIELD(_finddata_t, name[260]);
 196     CHECK_STRUCT(_finddatai64_t);
 197     CHECK_FIELD(_finddatai64_t, attrib);
 198     CHECK_FIELD(_finddatai64_t, time_create);
 199     CHECK_FIELD(_finddatai64_t, time_access);
 200     CHECK_FIELD(_finddatai64_t, time_write);
 201     CHECK_FIELD(_finddatai64_t, size);
 202     CHECK_FIELD(_finddatai64_t, name[260]);
 203     CHECK_STRUCT(_wfinddata_t);
 204     CHECK_FIELD(_wfinddata_t, attrib);
 205     CHECK_FIELD(_wfinddata_t, time_create);
 206     CHECK_FIELD(_wfinddata_t, time_access);
 207     CHECK_FIELD(_wfinddata_t, time_write);
 208     CHECK_FIELD(_wfinddata_t, size);
 209     CHECK_FIELD(_wfinddata_t, name[260]);
 210     CHECK_STRUCT(_wfinddatai64_t);
 211     CHECK_FIELD(_wfinddatai64_t, attrib);
 212     CHECK_FIELD(_wfinddatai64_t, time_create);
 213     CHECK_FIELD(_wfinddatai64_t, time_access);
 214     CHECK_FIELD(_wfinddatai64_t, time_write);
 215     CHECK_FIELD(_wfinddatai64_t, size);
 216     CHECK_FIELD(_wfinddatai64_t, name[260]);
 217     CHECK_STRUCT(_utimbuf);
 218     CHECK_FIELD(_utimbuf, actime);
 219     CHECK_FIELD(_utimbuf, modtime);
 220     CHECK_STRUCT(_stat);
 221     CHECK_FIELD(_stat, st_dev);
 222     CHECK_FIELD(_stat, st_ino);
 223     CHECK_FIELD(_stat, st_mode);
 224     CHECK_FIELD(_stat, st_nlink);
 225     CHECK_FIELD(_stat, st_uid);
 226     CHECK_FIELD(_stat, st_gid);
 227     CHECK_FIELD(_stat, st_rdev);
 228     CHECK_FIELD(_stat, st_size);
 229     CHECK_FIELD(_stat, st_atime);
 230     CHECK_FIELD(_stat, st_mtime);
 231     CHECK_FIELD(_stat, st_ctime);
 232     CHECK_FIELD(_stat, st_dev);
 233     CHECK_FIELD(_stat, st_ino);
 234     CHECK_FIELD(_stat, st_mode);
 235     CHECK_FIELD(_stat, st_nlink);
 236     CHECK_FIELD(_stat, st_uid);
 237     CHECK_FIELD(_stat, st_gid);
 238     CHECK_FIELD(_stat, st_rdev);
 239     CHECK_FIELD(_stat, st_size);
 240     CHECK_FIELD(_stat, st_atime);
 241     CHECK_FIELD(_stat, st_mtime);
 242     CHECK_FIELD(_stat, st_ctime);
 243     CHECK_FIELD(_stat, st_dev);
 244     CHECK_FIELD(_stat, st_ino);
 245     CHECK_FIELD(_stat, st_mode);
 246     CHECK_FIELD(_stat, st_nlink);
 247     CHECK_FIELD(_stat, st_uid);
 248     CHECK_FIELD(_stat, st_gid);
 249     CHECK_FIELD(_stat, st_rdev);
 250     CHECK_FIELD(_stat, st_size);
 251     CHECK_FIELD(_stat, st_atime);
 252     CHECK_FIELD(_stat, st_mtime);
 253     CHECK_FIELD(_stat, st_ctime);
 254     CHECK_STRUCT(stat);
 255     CHECK_FIELD(stat, st_dev);
 256     CHECK_FIELD(stat, st_ino);
 257     CHECK_FIELD(stat, st_mode);
 258     CHECK_FIELD(stat, st_nlink);
 259     CHECK_FIELD(stat, st_uid);
 260     CHECK_FIELD(stat, st_gid);
 261     CHECK_FIELD(stat, st_rdev);
 262     CHECK_FIELD(stat, st_size);
 263     CHECK_FIELD(stat, st_atime);
 264     CHECK_FIELD(stat, st_mtime);
 265     CHECK_FIELD(stat, st_ctime);
 266     CHECK_FIELD(stat, st_dev);
 267     CHECK_FIELD(stat, st_ino);
 268     CHECK_FIELD(stat, st_mode);
 269     CHECK_FIELD(stat, st_nlink);
 270     CHECK_FIELD(stat, st_uid);
 271     CHECK_FIELD(stat, st_gid);
 272     CHECK_FIELD(stat, st_rdev);
 273     CHECK_FIELD(stat, st_size);
 274     CHECK_FIELD(stat, st_atime);
 275     CHECK_FIELD(stat, st_mtime);
 276     CHECK_FIELD(stat, st_ctime);
 277     CHECK_FIELD(stat, st_dev);
 278     CHECK_FIELD(stat, st_ino);
 279     CHECK_FIELD(stat, st_mode);
 280     CHECK_FIELD(stat, st_nlink);
 281     CHECK_FIELD(stat, st_uid);
 282     CHECK_FIELD(stat, st_gid);
 283     CHECK_FIELD(stat, st_rdev);
 284     CHECK_FIELD(stat, st_size);
 285     CHECK_FIELD(stat, st_atime);
 286     CHECK_FIELD(stat, st_mtime);
 287     CHECK_FIELD(stat, st_ctime);
 288     CHECK_STRUCT(_stati64);
 289     CHECK_FIELD(_stati64, st_dev);
 290     CHECK_FIELD(_stati64, st_ino);
 291     CHECK_FIELD(_stati64, st_mode);
 292     CHECK_FIELD(_stati64, st_nlink);
 293     CHECK_FIELD(_stati64, st_uid);
 294     CHECK_FIELD(_stati64, st_gid);
 295     CHECK_FIELD(_stati64, st_rdev);
 296     CHECK_FIELD(_stati64, st_size);
 297     CHECK_FIELD(_stati64, st_atime);
 298     CHECK_FIELD(_stati64, st_mtime);
 299     CHECK_FIELD(_stati64, st_ctime);
 300     CHECK_STRUCT(_stat64);
 301     CHECK_FIELD(_stat64, st_dev);
 302     CHECK_FIELD(_stat64, st_ino);
 303     CHECK_FIELD(_stat64, st_mode);
 304     CHECK_FIELD(_stat64, st_nlink);
 305     CHECK_FIELD(_stat64, st_uid);
 306     CHECK_FIELD(_stat64, st_gid);
 307     CHECK_FIELD(_stat64, st_rdev);
 308     CHECK_FIELD(_stat64, st_size);
 309     CHECK_FIELD(_stat64, st_atime);
 310     CHECK_FIELD(_stat64, st_mtime);
 311     CHECK_FIELD(_stat64, st_ctime);
 312 }
 313
 314 /************* Checking defines ***************/
 315 static void test_defines(void)
 316 {
 317     CHECK_DEF(WEOF);
 318     CHECK_DEF(EOF);
 319     CHECK_DEF(TMP_MAX);
 320     CHECK_DEF(RAND_MAX);
 321     CHECK_DEF(BUFSIZ);
 322     CHECK_DEF(STDIN_FILENO);
 323     CHECK_DEF(STDOUT_FILENO);
 324     CHECK_DEF(STDERR_FILENO);
 325     CHECK_DEF(_IOFBF);
 326     CHECK_DEF(_IONBF);
 327     CHECK_DEF(_IOLBF);
 328     CHECK_DEF(FILENAME_MAX);
 329     CHECK_DEF(_P_WAIT);
 330     CHECK_DEF(_P_NOWAIT);
 331     CHECK_DEF(_P_OVERLAY);
 332     CHECK_DEF(_P_NOWAITO);
 333     CHECK_DEF(_P_DETACH);
 334     CHECK_DEF(EPERM);
 335     CHECK_DEF(ENOENT);
 336     CHECK_DEF(ESRCH);
 337     CHECK_DEF(EINTR);
 338     CHECK_DEF(EIO);
 339     CHECK_DEF(ENXIO);
 340     CHECK_DEF(E2BIG);
 341     CHECK_DEF(ENOEXEC);
 342     CHECK_DEF(EBADF);
 343     CHECK_DEF(ECHILD);
 344     CHECK_DEF(EAGAIN);
 345     CHECK_DEF(ENOMEM);
 346     CHECK_DEF(EACCES);
 347     CHECK_DEF(EFAULT);
 348     CHECK_DEF(EBUSY);
 349     CHECK_DEF(EEXIST);
 350     CHECK_DEF(EXDEV);
 351     CHECK_DEF(ENODEV);
 352     CHECK_DEF(ENOTDIR);
 353     CHECK_DEF(EISDIR);
 354     CHECK_DEF(EINVAL);
 355     CHECK_DEF(ENFILE);
 356     CHECK_DEF(EMFILE);
 357     CHECK_DEF(ENOTTY);
 358     CHECK_DEF(EFBIG);
 359     CHECK_DEF(ENOSPC);
 360     CHECK_DEF(ESPIPE);
 361     CHECK_DEF(EROFS);
 362     CHECK_DEF(EMLINK);
 363     CHECK_DEF(EPIPE);
 364     CHECK_DEF(EDOM);
 365     CHECK_DEF(ERANGE);
 366     CHECK_DEF(EDEADLK);
 367     CHECK_DEF(EDEADLOCK);
 368     CHECK_DEF(ENAMETOOLONG);
 369     CHECK_DEF(ENOLCK);
 370     CHECK_DEF(ENOSYS);
 371     CHECK_DEF(ENOTEMPTY);
 372     CHECK_DEF(EILSEQ);
 373     CHECK_DEF(LC_ALL);
 374     CHECK_DEF(LC_COLLATE);
 375     CHECK_DEF(LC_CTYPE);
 376     CHECK_DEF(LC_MONETARY);
 377     CHECK_DEF(LC_NUMERIC);
 378     CHECK_DEF(LC_TIME);
 379     CHECK_DEF(LC_MIN);
 380     CHECK_DEF(LC_MAX);
 381     CHECK_DEF(CLOCKS_PER_SEC);
 382     CHECK_DEF(_HEAPEMPTY);
 383     CHECK_DEF(_HEAPOK);
 384     CHECK_DEF(_HEAPBADBEGIN);
 385     CHECK_DEF(_HEAPBADNODE);
 386     CHECK_DEF(_HEAPEND);
 387     CHECK_DEF(_HEAPBADPTR);
 388     CHECK_DEF(_FREEENTRY);
 389     CHECK_DEF(_USEDENTRY);
 390     CHECK_DEF(_OUT_TO_DEFAULT);
 391     CHECK_DEF(_REPORT_ERRMODE);
 392     CHECK_DEF(_UPPER);
 393     CHECK_DEF(_LOWER);
 394     CHECK_DEF(_DIGIT);
 395     CHECK_DEF(_SPACE);
 396     CHECK_DEF(_PUNCT);
 397     CHECK_DEF(_CONTROL);
 398     CHECK_DEF(_BLANK);
 399     CHECK_DEF(_HEX);
 400     CHECK_DEF(_LEADBYTE);
 401     CHECK_DEF(_ALPHA);
 402     CHECK_DEF(_IOREAD);
 403     CHECK_DEF(_IOWRT);
 404     CHECK_DEF(_IOMYBUF);
 405     CHECK_DEF(_IOEOF);
 406     CHECK_DEF(_IOERR);
 407     CHECK_DEF(_IOSTRG);
 408     CHECK_DEF(_IORW);
 409     CHECK_DEF(_S_IEXEC);
 410     CHECK_DEF(_S_IWRITE);
 411     CHECK_DEF(_S_IREAD);
 412     CHECK_DEF(_S_IFIFO);
 413     CHECK_DEF(_S_IFCHR);
 414     CHECK_DEF(_S_IFDIR);
 415     CHECK_DEF(_S_IFREG);
 416     CHECK_DEF(_S_IFMT);
 417     CHECK_DEF(_LK_UNLCK);
 418     CHECK_DEF(_LK_LOCK);
 419     CHECK_DEF(_LK_NBLCK);
 420     CHECK_DEF(_LK_RLCK);
 421     CHECK_DEF(_LK_NBRLCK);
 422     CHECK_DEF(_O_RDONLY);
 423     CHECK_DEF(_O_WRONLY);
 424     CHECK_DEF(_O_RDWR);
 425     CHECK_DEF(_O_ACCMODE);
 426     CHECK_DEF(_O_APPEND);
 427     CHECK_DEF(_O_RANDOM);
 428     CHECK_DEF(_O_SEQUENTIAL);
 429     CHECK_DEF(_O_TEMPORARY);
 430     CHECK_DEF(_O_NOINHERIT);
 431     CHECK_DEF(_O_CREAT);
 432     CHECK_DEF(_O_TRUNC);
 433     CHECK_DEF(_O_EXCL);
 434     CHECK_DEF(_O_SHORT_LIVED);
 435     CHECK_DEF(_O_TEXT);
 436     CHECK_DEF(_O_BINARY);
 437     CHECK_DEF(_O_RAW);
 438     CHECK_DEF(_SW_INEXACT);
 439     CHECK_DEF(_SW_UNDERFLOW);
 440     CHECK_DEF(_SW_OVERFLOW);
 441     CHECK_DEF(_SW_ZERODIVIDE);
 442     CHECK_DEF(_SW_INVALID);
 443     CHECK_DEF(_SW_UNEMULATED);
 444     CHECK_DEF(_SW_SQRTNEG);
 445     CHECK_DEF(_SW_STACKOVERFLOW);
 446     CHECK_DEF(_SW_STACKUNDERFLOW);
 447     CHECK_DEF(_SW_DENORMAL);
 448     CHECK_DEF(_FPCLASS_SNAN);
 449     CHECK_DEF(_FPCLASS_QNAN);
 450     CHECK_DEF(_FPCLASS_NINF);
 451     CHECK_DEF(_FPCLASS_NN);
 452     CHECK_DEF(_FPCLASS_ND);
 453     CHECK_DEF(_FPCLASS_NZ);
 454     CHECK_DEF(_FPCLASS_PZ);
 455     CHECK_DEF(_FPCLASS_PD);
 456     CHECK_DEF(_FPCLASS_PN);
 457     CHECK_DEF(_FPCLASS_PINF);
 458     CHECK_DEF(SIGINT);
 459     CHECK_DEF(SIGILL);
 460     CHECK_DEF(SIGFPE);
 461     CHECK_DEF(SIGSEGV);
 462     CHECK_DEF(SIGTERM);
 463     CHECK_DEF(SIGBREAK);
 464     CHECK_DEF(SIGABRT);
 465     CHECK_DEF(NSIG);
 466     CHECK_DEF(_FPE_INVALID);
 467     CHECK_DEF(_FPE_DENORMAL);
 468     CHECK_DEF(_FPE_ZERODIVIDE);
 469     CHECK_DEF(_FPE_OVERFLOW);
 470     CHECK_DEF(_FPE_UNDERFLOW);
 471     CHECK_DEF(_FPE_INEXACT);
 472     CHECK_DEF(_FPE_UNEMULATED);
 473     CHECK_DEF(_FPE_SQRTNEG);
 474     CHECK_DEF(_FPE_STACKOVERFLOW);
 475     CHECK_DEF(_FPE_STACKUNDERFLOW);
 476     CHECK_DEF(_FPE_EXPLICITGEN);
 477 #ifdef __i386__
 478     CHECK_DEF(_EM_INVALID);
 479     CHECK_DEF(_EM_DENORMAL);
 480     CHECK_DEF(_EM_ZERODIVIDE);
 481     CHECK_DEF(_EM_OVERFLOW);
 482     CHECK_DEF(_EM_UNDERFLOW);
 483     CHECK_DEF(_EM_INEXACT);
 484     CHECK_DEF(_IC_AFFINE);
 485     CHECK_DEF(_IC_PROJECTIVE);
 486     CHECK_DEF(_RC_CHOP);
 487     CHECK_DEF(_RC_UP);
 488     CHECK_DEF(_RC_DOWN);
 489     CHECK_DEF(_RC_NEAR);
 490     CHECK_DEF(_PC_24);
 491     CHECK_DEF(_PC_53);
 492     CHECK_DEF(_PC_64);
 493 #endif
 494 }
 495
 496 #endif /* __WINE_USE_MSVCRT */
 497
 498 START_TEST(headers)
 499 {
 500 #ifdef __WINE_USE_MSVCRT
 501     test_types();
 502     test_structs();
 503     test_defines();
 504 #endif
 505 }