rostests/apitests/msvcrt/ieee.c

   1 /*
   2  * PROJECT:         ReactOS api tests
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * PURPOSE:         Tests for IEEE floatting-point functions
   5  * PROGRAMMER:      Pierre Schweitzer (pierre@reactos.org)
   6  */
   7
   8 #include <wine/test.h>
   9 #include <float.h>
  10
  11 typedef union
  12 {
  13     double d;
  14     long long l;
  15 } ieee_double;
  16
  17 void test_finite(void)
  18 {
  19     ieee_double tested;
  20
  21     tested.l = 0xFFFFFFFFFFFFFFFFLL;
  22     ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
  23     tested.l = 0xFFF8000000000001LL;
  24     ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
  25     tested.l = 0xFFF8000000000000LL;
  26     ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
  27     tested.l = 0xFFF7FFFFFFFFFFFFLL;
  28     ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
  29     tested.l = 0xFFF0000000000001LL;
  30     ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
  31     tested.l = 0xFFF0000000000000LL;
  32     ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
  33     tested.l = 0xFFEFFFFFFFFFFFFFLL;
  34     ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
  35     tested.l = 0x8010000000000000LL;
  36     ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
  37     tested.l = 0x800FFFFFFFFFFFFFLL;
  38     ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
  39     tested.l = 0x8000000000000001LL;
  40     ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
  41     tested.l = 0x8000000000000000LL;
  42     ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
  43     tested.l = 0x0000000000000000LL;
  44     ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
  45     tested.l = 0x0000000000000001LL;
  46     ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
  47     tested.l = 0x000FFFFFFFFFFFFFLL;
  48     ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
  49     tested.l = 0x0010000000000000LL;
  50     ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
  51     tested.l = 0x7FEFFFFFFFFFFFFFLL;
  52     ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
  53     tested.l = 0x7FF0000000000000LL;
  54     ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
  55     tested.l = 0x7FF0000000000001LL;
  56     ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
  57     tested.l = 0x7FF7FFFFFFFFFFFFLL;
  58     ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
  59     tested.l = 0x7FF8000000000000LL;
  60     ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
  61     tested.l = 0x7FFFFFFFFFFFFFFFLL;
  62     ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
  63 }
  64
  65 void test_fpclass(void)
  66 {
  67     int class;
  68     ieee_double tested;
  69
  70     tested.l = 0xFFFFFFFFFFFFFFFFLL;
  71     class = _fpclass(tested.d);
  72     ok(class == _FPCLASS_QNAN, "class = %d\n", class);
  73     tested.l = 0xFFF8000000000001LL;
  74     class = _fpclass(tested.d);
  75     ok(class == _FPCLASS_QNAN, "class = %d\n", class);
  76     tested.l = 0xFFF8000000000000LL;
  77     class = _fpclass(tested.d);
  78     /* Normally it has no class, but w2k3 defines it
  79      * like that
  80      */
  81     ok(class == _FPCLASS_QNAN, "class = %d\n", class);
  82     tested.l = 0xFFF7FFFFFFFFFFFFLL;
  83     class = _fpclass(tested.d);
  84     /* According to IEEE, it should be Signaling NaN, but
  85      * on w2k3, it's Quiet NAN
  86      * ok(class == _FPCLASS_SNAN, "class = %d\n", class);
  87      */
  88     ok(class == _FPCLASS_QNAN, "class = %d\n", class);
  89     tested.l = 0xFFF0000000000001LL;
  90     class = _fpclass(tested.d);
  91     /* According to IEEE, it should be Signaling NaN, but
  92      * on w2k3, it's Quiet NAN
  93      * ok(class == _FPCLASS_SNAN, "class = %d\n", class);
  94      */
  95     ok(class == _FPCLASS_QNAN, "class = %d\n", class);
  96     tested.l = 0xFFF0000000000000LL;
  97     class = _fpclass(tested.d);
  98     ok(class == _FPCLASS_NINF, "class = %d\n", class);
  99     tested.l = 0xFFEFFFFFFFFFFFFFLL;
 100     class = _fpclass(tested.d);
 101     ok(class == _FPCLASS_NN, "class = %d\n", class);
 102     tested.l = 0x8010000000000000LL;
 103     class = _fpclass(tested.d);
 104     ok(class == _FPCLASS_NN, "class = %d\n", class);
 105     tested.l = 0x800FFFFFFFFFFFFFLL;
 106     class = _fpclass(tested.d);
 107     ok(class == _FPCLASS_ND, "class = %d\n", class);
 108     tested.l = 0x8000000000000001LL;
 109     class = _fpclass(tested.d);
 110     ok(class == _FPCLASS_ND, "class = %d\n", class);
 111     tested.l = 0x8000000000000000LL;
 112     class = _fpclass(tested.d);
 113     ok(class == _FPCLASS_NZ, "class = %d\n", class);
 114     tested.l = 0x0000000000000000LL;
 115     class = _fpclass(tested.d);
 116     ok(class == _FPCLASS_PZ, "class = %d\n", class);
 117     tested.l = 0x0000000000000001LL;
 118     class = _fpclass(tested.d);
 119     ok(class == _FPCLASS_PD, "class = %d\n", class);
 120     tested.l = 0x000FFFFFFFFFFFFFLL;
 121     class = _fpclass(tested.d);
 122     ok(class == _FPCLASS_PD, "class = %d\n", class);
 123     tested.l = 0x0010000000000000LL;
 124     class = _fpclass(tested.d);
 125     ok(class == _FPCLASS_PN, "class = %d\n", class);
 126     tested.l = 0x7FEFFFFFFFFFFFFFLL;
 127     class = _fpclass(tested.d);
 128     ok(class == _FPCLASS_PN, "class = %d\n", class);
 129     tested.l = 0x7FF0000000000000LL;
 130     class = _fpclass(tested.d);
 131     ok(class == _FPCLASS_PINF, "class = %d\n", class);
 132     tested.l = 0x7FF0000000000001LL;
 133     class = _fpclass(tested.d);
 134     /* According to IEEE, it should be Signaling NaN, but
 135      * on w2k3, it's Quiet NAN
 136      * ok(class == _FPCLASS_SNAN, "class = %d\n", class);
 137      */
 138     ok(class == _FPCLASS_QNAN, "class = %d\n", class);
 139     tested.l = 0x7FF7FFFFFFFFFFFFLL;
 140     class = _fpclass(tested.d);
 141     /* According to IEEE, it should be Signaling NaN, but
 142      * on w2k3, it's Quiet NAN
 143      * ok(class == _FPCLASS_SNAN, "class = %d\n", class);
 144      */
 145     ok(class == _FPCLASS_QNAN, "class = %d\n", class);
 146     tested.l = 0x7FF8000000000000LL;
 147     class = _fpclass(tested.d);
 148     ok(class == _FPCLASS_QNAN, "class = %d\n", class);
 149     tested.l = 0x7FFFFFFFFFFFFFFFLL;
 150     class = _fpclass(tested.d);
 151     ok(class == _FPCLASS_QNAN, "class = %d\n", class);
 152 }
 153
 154 void test_isnan(void)
 155 {
 156     ieee_double tested;
 157
 158     tested.l = 0xFFFFFFFFFFFFFFFFLL;
 159     ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
 160     tested.l = 0xFFF8000000000001LL;
 161     ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
 162     tested.l = 0xFFF8000000000000LL;
 163     ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
 164     tested.l = 0xFFF7FFFFFFFFFFFFLL;
 165     ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
 166     tested.l = 0xFFF0000000000001LL;
 167     ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
 168     tested.l = 0xFFF0000000000000LL;
 169     ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
 170     tested.l = 0xFFEFFFFFFFFFFFFFLL;
 171     ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
 172     tested.l = 0x8010000000000000LL;
 173     ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
 174     tested.l = 0x800FFFFFFFFFFFFFLL;
 175     ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
 176     tested.l = 0x8000000000000001LL;
 177     ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
 178     tested.l = 0x8000000000000000LL;
 179     ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
 180     tested.l = 0x0000000000000000LL;
 181     ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
 182     tested.l = 0x0000000000000001LL;
 183     ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
 184     tested.l = 0x000FFFFFFFFFFFFFLL;
 185     ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
 186     tested.l = 0x0010000000000000LL;
 187     ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
 188     tested.l = 0x7FEFFFFFFFFFFFFFLL;
 189     ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
 190     tested.l = 0x7FF0000000000000LL;
 191     ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
 192     tested.l = 0x7FF0000000000001LL;
 193     ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
 194     tested.l = 0x7FF7FFFFFFFFFFFFLL;
 195     ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
 196     tested.l = 0x7FF8000000000000LL;
 197     ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
 198     tested.l = 0x7FFFFFFFFFFFFFFFLL;
 199     ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
 200 }
 201
 202 void test_scalb(void)
 203 {
 204     ieee_double tested;
 205     ieee_double expected;
 206     ieee_double result;
 207
 208     expected.l = 0;
 209
 210     errno = 0xDEADBEEF;
 211     tested.l = 0xFFFFFFFFFFFFFFFFLL;
 212     expected.l = 0xFFFFFFFFFFFFFFFFLL;
 213     result.d =  _scalb(tested.d, 3);
 214     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 215     ok(errno == EDOM, "errno: %d\n", errno);
 216     errno = 0xDEADBEEF;
 217     tested.l = 0xFFF8000000000001LL;
 218     expected.l = 0xFFF8000000000001LL;
 219     result.d =  _scalb(tested.d, 3);
 220     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 221     ok(errno == EDOM, "errno: %d\n", errno);
 222     errno = 0xDEADBEEF;
 223     tested.l = 0xFFF8000000000000LL;
 224     expected.l = 0xFFF8000000000000LL;
 225     result.d =  _scalb(tested.d, 3);
 226     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 227     ok(errno == EDOM, "errno: %d\n", errno);
 228     errno = 0xDEADBEEF;
 229     tested.l = 0xFFF7FFFFFFFFFFFFLL;
 230     expected.l = 0xFFFFFFFFFFFFFFFFLL;
 231     result.d =  _scalb(tested.d, 3);
 232     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 233     ok(errno == EDOM, "errno: %d\n", errno);
 234     errno = 0xDEADBEEF;
 235     tested.l = 0xFFF0000000000001LL;
 236     expected.l = 0xFFF8000000000001LL;
 237     result.d =  _scalb(tested.d, 3);
 238     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 239     ok(errno == EDOM, "errno: %d\n", errno);
 240     errno = 0xDEADBEEF;
 241     tested.l = 0xFFF0000000000000LL;
 242     expected.l = 0xFFF0000000000000LL;
 243     result.d =  _scalb(tested.d, 3);
 244     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 245     ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
 246     errno = 0xDEADBEEF;
 247     tested.l = 0xFFEFFFFFFFFFFFFFLL;
 248     expected.l = 0xFFF0000000000000LL;
 249     result.d =  _scalb(tested.d, 3);
 250     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 251     ok(errno == ERANGE, "errno: %d\n", errno);
 252     errno = 0xDEADBEEF;
 253     tested.l = 0x8010000000000000LL;
 254     expected.l = 0x8040000000000000LL;
 255     result.d =  _scalb(tested.d, 3);
 256     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 257     ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
 258     errno = 0xDEADBEEF;
 259     tested.l = 0x800FFFFFFFFFFFFFLL;
 260     expected.l = 0x803FFFFFFFFFFFFELL;
 261     result.d =  _scalb(tested.d, 3);
 262     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 263     ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
 264     errno = 0xDEADBEEF;
 265     tested.l = 0x8000000000000001LL;
 266     expected.l = 0x8000000000000008LL;
 267     result.d =  _scalb(tested.d, 3);
 268     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 269     ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
 270     errno = 0xDEADBEEF;
 271     tested.l = 0x8000000000000000LL;
 272     expected.l = 0x8000000000000000LL;
 273     result.d =  _scalb(tested.d, 3);
 274     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 275     ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
 276     errno = 0xDEADBEEF;
 277     tested.l = 0x0000000000000000LL;
 278     expected.l = 0x0000000000000000LL;
 279     result.d =  _scalb(tested.d, 3);
 280     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 281     ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
 282     errno = 0xDEADBEEF;
 283     tested.l = 0x0000000000000001LL;
 284     expected.l = 0x0000000000000008LL;
 285     result.d =  _scalb(tested.d, 3);
 286     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 287     ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
 288     errno = 0xDEADBEEF;
 289     tested.l = 0x000FFFFFFFFFFFFFLL;
 290     expected.l = 0x003FFFFFFFFFFFFELL;
 291     result.d =  _scalb(tested.d, 3);
 292     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 293     ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
 294     errno = 0xDEADBEEF;
 295     tested.l = 0x0010000000000000LL;
 296     expected.l = 0x0040000000000000LL;
 297     result.d =  _scalb(tested.d, 3);
 298     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 299     ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
 300     errno = 0xDEADBEEF;
 301     tested.l = 0x7FEFFFFFFFFFFFFFLL;
 302     expected.l = 0x7FF0000000000000LL;
 303     result.d =  _scalb(tested.d, 3);
 304     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 305     ok(errno == ERANGE, "errno: %d\n", errno);
 306     errno = 0xDEADBEEF;
 307     tested.l = 0x7FF0000000000000LL;
 308     expected.l = 0x7FF0000000000000LL;
 309     result.d =  _scalb(tested.d, 3);
 310     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 311     ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
 312     errno = 0xDEADBEEF;
 313     tested.l = 0x7FF0000000000001LL;
 314     expected.l = 0x7FF8000000000001LL;
 315     result.d =  _scalb(tested.d, 3);
 316     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 317     ok(errno == EDOM, "errno: %d\n", errno);
 318     errno = 0xDEADBEEF;
 319     tested.l = 0x7FF7FFFFFFFFFFFFLL;
 320     expected.l = 0x7FFFFFFFFFFFFFFFLL;
 321     result.d =  _scalb(tested.d, 3);
 322     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 323     ok(errno == EDOM, "errno: %d\n", errno);
 324     errno = 0xDEADBEEF;
 325     tested.l = 0x7FF8000000000000LL;
 326     expected.l = 0x7FF8000000000000LL;
 327     result.d =  _scalb(tested.d, 3);
 328     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 329     ok(errno == EDOM, "errno: %d\n", errno);
 330     errno = 0xDEADBEEF;
 331     tested.l = 0x7FFFFFFFFFFFFFFFLL;
 332     expected.l = 0x7FFFFFFFFFFFFFFFLL;
 333     result.d =  _scalb(tested.d, 3);
 334     ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
 335     ok(errno == EDOM, "errno: %d\n", errno);
 336 }
 337
 338 START_TEST(ieee)
 339 {
 340     test_finite();
 341     test_fpclass();
 342     test_isnan();
 343     test_scalb();
 344 }