ReactOS 0.4.16-dev-195-g3bb1e64
ieee.c
Go to the documentation of this file.
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 * REFERENCES: http://msdn.microsoft.com/en-US/library/h7zkk1bz%28v=VS.80%29.aspx
7 */
8
9#include <apitest.h>
10
11#include <float.h>
12#include <math.h>
13
14typedef union
15{
16 double d;
17 long long l;
18} ieee_double;
19
20void test_finite(void)
21{
22 ieee_double tested;
23
24 tested.l = 0xFFFFFFFFFFFFFFFFLL;
25 ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
26 tested.l = 0xFFF8000000000001LL;
27 ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
28 tested.l = 0xFFF8000000000000LL;
29 ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
30 tested.l = 0xFFF7FFFFFFFFFFFFLL;
31 ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
32 tested.l = 0xFFF0000000000001LL;
33 ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
34 tested.l = 0xFFF0000000000000LL;
35 ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
36 tested.l = 0xFFEFFFFFFFFFFFFFLL;
37 ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
38 tested.l = 0x8010000000000000LL;
39 ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
40 tested.l = 0x800FFFFFFFFFFFFFLL;
41 ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
42 tested.l = 0x8000000000000001LL;
43 ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
44 tested.l = 0x8000000000000000LL;
45 ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
46 tested.l = 0x0000000000000000LL;
47 ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
48 tested.l = 0x0000000000000001LL;
49 ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
50 tested.l = 0x000FFFFFFFFFFFFFLL;
51 ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
52 tested.l = 0x0010000000000000LL;
53 ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
54 tested.l = 0x7FEFFFFFFFFFFFFFLL;
55 ok(_finite(tested.d) == TRUE, "_finite = FALSE\n");
56 tested.l = 0x7FF0000000000000LL;
57 ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
58 tested.l = 0x7FF0000000000001LL;
59 ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
60 tested.l = 0x7FF7FFFFFFFFFFFFLL;
61 ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
62 tested.l = 0x7FF8000000000000LL;
63 ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
64 tested.l = 0x7FFFFFFFFFFFFFFFLL;
65 ok(_finite(tested.d) == FALSE, "_finite = TRUE\n");
66
67 /* MSDN example */
68 ok(_finite(2.387000) == TRUE, "_finite = FALSE\n");
69}
70
71void test_fpclass(void)
72{
73 int class;
74 ieee_double tested;
75
76 tested.l = 0xFFFFFFFFFFFFFFFFLL;
77 class = _fpclass(tested.d);
78 ok(class == _FPCLASS_QNAN, "class = %d\n", class);
79 tested.l = 0xFFF8000000000001LL;
80 class = _fpclass(tested.d);
81 ok(class == _FPCLASS_QNAN, "class = %d\n", class);
82 tested.l = 0xFFF8000000000000LL;
83 class = _fpclass(tested.d);
84 /* Normally it has no class, but w2k3 defines it
85 * like that
86 */
87 ok(class == _FPCLASS_QNAN, "class = %d\n", class);
88 tested.l = 0xFFF7FFFFFFFFFFFFLL;
89 class = _fpclass(tested.d);
90 /* According to IEEE, it should be Signaling NaN, but
91 * on w2k3, it's Quiet NAN
92 * ok(class == _FPCLASS_SNAN, "class = %d\n", class);
93 */
94#ifdef _M_AMD64
95 ok(class == _FPCLASS_SNAN, "class = %d\n", class);
96#else
97 ok(class == _FPCLASS_QNAN, "class = %d\n", class);
98#endif
99 tested.l = 0xFFF0000000000001LL;
100 class = _fpclass(tested.d);
101 /* According to IEEE, it should be Signaling NaN, but
102 * on w2k3, it's Quiet NAN
103 * ok(class == _FPCLASS_SNAN, "class = %d\n", class);
104 */
105#ifdef _M_AMD64
106 ok(class == _FPCLASS_SNAN, "class = %d\n", class);
107#else
108 ok(class == _FPCLASS_QNAN, "class = %d\n", class);
109#endif
110 tested.l = 0xFFF0000000000000LL;
111 class = _fpclass(tested.d);
112 ok(class == _FPCLASS_NINF, "class = %d\n", class);
113 tested.l = 0xFFEFFFFFFFFFFFFFLL;
114 class = _fpclass(tested.d);
115 ok(class == _FPCLASS_NN, "class = %d\n", class);
116 tested.l = 0x8010000000000000LL;
117 class = _fpclass(tested.d);
118 ok(class == _FPCLASS_NN, "class = %d\n", class);
119 tested.l = 0x800FFFFFFFFFFFFFLL;
120 class = _fpclass(tested.d);
121 ok(class == _FPCLASS_ND, "class = %d\n", class);
122 tested.l = 0x8000000000000001LL;
123 class = _fpclass(tested.d);
124 ok(class == _FPCLASS_ND, "class = %d\n", class);
125 tested.l = 0x8000000000000000LL;
126 class = _fpclass(tested.d);
127 ok(class == _FPCLASS_NZ, "class = %d\n", class);
128 tested.l = 0x0000000000000000LL;
129 class = _fpclass(tested.d);
130 ok(class == _FPCLASS_PZ, "class = %d\n", class);
131 tested.l = 0x0000000000000001LL;
132 class = _fpclass(tested.d);
133 ok(class == _FPCLASS_PD, "class = %d\n", class);
134 tested.l = 0x000FFFFFFFFFFFFFLL;
135 class = _fpclass(tested.d);
136 ok(class == _FPCLASS_PD, "class = %d\n", class);
137 tested.l = 0x0010000000000000LL;
138 class = _fpclass(tested.d);
139 ok(class == _FPCLASS_PN, "class = %d\n", class);
140 tested.l = 0x7FEFFFFFFFFFFFFFLL;
141 class = _fpclass(tested.d);
142 ok(class == _FPCLASS_PN, "class = %d\n", class);
143 tested.l = 0x7FF0000000000000LL;
144 class = _fpclass(tested.d);
145 ok(class == _FPCLASS_PINF, "class = %d\n", class);
146 tested.l = 0x7FF0000000000001LL;
147 class = _fpclass(tested.d);
148 /* According to IEEE, it should be Signaling NaN, but
149 * on w2k3, it's Quiet NAN
150 * ok(class == _FPCLASS_SNAN, "class = %d\n", class);
151 */
152#ifdef _M_AMD64
153 ok(class == _FPCLASS_SNAN, "class = %d\n", class);
154#else
155 ok(class == _FPCLASS_QNAN, "class = %d\n", class);
156#endif
157 tested.l = 0x7FF7FFFFFFFFFFFFLL;
158 class = _fpclass(tested.d);
159 /* According to IEEE, it should be Signaling NaN, but
160 * on w2k3, it's Quiet NAN
161 * ok(class == _FPCLASS_SNAN, "class = %d\n", class);
162 */
163#ifdef _M_AMD64
164 ok(class == _FPCLASS_SNAN, "class = %d\n", class);
165#else
166 ok(class == _FPCLASS_QNAN, "class = %d\n", class);
167#endif
168 tested.l = 0x7FF8000000000000LL;
169 class = _fpclass(tested.d);
170 ok(class == _FPCLASS_QNAN, "class = %d\n", class);
171 tested.l = 0x7FFFFFFFFFFFFFFFLL;
172 class = _fpclass(tested.d);
173 ok(class == _FPCLASS_QNAN, "class = %d\n", class);
174
175 /* MSDN example */
176 class = _fpclass(2.387000);
177 ok(class == _FPCLASS_PN, "class = %d\n", class);
178}
179
180void test_isnan(void)
181{
182 ieee_double tested;
183
184 tested.l = 0xFFFFFFFFFFFFFFFFLL;
185 ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
186 tested.l = 0xFFF8000000000001LL;
187 ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
188 tested.l = 0xFFF8000000000000LL;
189 ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
190 tested.l = 0xFFF7FFFFFFFFFFFFLL;
191 ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
192 tested.l = 0xFFF0000000000001LL;
193 ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
194 tested.l = 0xFFF0000000000000LL;
195 ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
196 tested.l = 0xFFEFFFFFFFFFFFFFLL;
197 ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
198 tested.l = 0x8010000000000000LL;
199 ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
200 tested.l = 0x800FFFFFFFFFFFFFLL;
201 ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
202 tested.l = 0x8000000000000001LL;
203 ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
204 tested.l = 0x8000000000000000LL;
205 ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
206 tested.l = 0x0000000000000000LL;
207 ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
208 tested.l = 0x0000000000000001LL;
209 ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
210 tested.l = 0x000FFFFFFFFFFFFFLL;
211 ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
212 tested.l = 0x0010000000000000LL;
213 ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
214 tested.l = 0x7FEFFFFFFFFFFFFFLL;
215 ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
216 tested.l = 0x7FF0000000000000LL;
217 ok(_isnan(tested.d) == FALSE, "_isnan = TRUE\n");
218 tested.l = 0x7FF0000000000001LL;
219 ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
220 tested.l = 0x7FF7FFFFFFFFFFFFLL;
221 ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
222 tested.l = 0x7FF8000000000000LL;
223 ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
224 tested.l = 0x7FFFFFFFFFFFFFFFLL;
225 ok(_isnan(tested.d) == TRUE, "_isnan = FALSE\n");
226
227 /* MSDN example */
228 ok(_isnan(2.387000) == FALSE, "_isnan = TRUE\n");
229}
230
231void test_j0(void)
232{
233 ieee_double tested;
234 ieee_double expected;
235 ieee_double result;
236
237 expected.l = 0;
238
239 errno = 0xDEADBEEF;
240 tested.l = 0xFFFFFFFFFFFFFFFFLL;
241 expected.l = 0xFFFFFFFFFFFFFFFFLL;
242 result.d = _j0(tested.d);
243 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
244 ok(errno == EDOM, "errno: %d\n", errno);
245 errno = 0xDEADBEEF;
246 tested.l = 0xFFF8000000000001LL;
247 expected.l = 0xFFF8000000000001LL;
248 result.d = _j0(tested.d);
249 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
250 ok(errno == EDOM, "errno: %d\n", errno);
251 errno = 0xDEADBEEF;
252 tested.l = 0xFFF8000000000000LL;
253 expected.l = 0xFFF8000000000000LL;
254 result.d = _j0(tested.d);
255 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
256 ok(errno == EDOM, "errno: %d\n", errno);
257 errno = 0xDEADBEEF;
258 tested.l = 0xFFF7FFFFFFFFFFFFLL;
259 expected.l = 0xFFFFFFFFFFFFFFFFLL;
260 result.d = _j0(tested.d);
261 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
262 ok(errno == EDOM, "errno: %d\n", errno);
263 errno = 0xDEADBEEF;
264 tested.l = 0xFFF0000000000001LL;
265 expected.l = 0xFFF8000000000001LL;
266 result.d = _j0(tested.d);
267 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
268 ok(errno == EDOM, "errno: %d\n", errno);
269 errno = 0xDEADBEEF;
270 tested.l = 0xFFF0000000000000LL;
271 expected.l = 0xFFF8000000000000LL;
272 result.d = _j0(tested.d);
273 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
274 ok(errno == EDOM, "errno: %d\n", errno);
275 errno = 0xDEADBEEF;
276 tested.l = 0xFFEFFFFFFFFFFFFFLL;
277#ifdef _M_AMD64
278 expected.l = 0x8000000000000000LL;
279#else
280 expected.l = 0x1FE7206E1D6FDCFALL;
281#endif
282 result.d = _j0(tested.d);
283 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
284 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
285 errno = 0xDEADBEEF;
286 tested.l = 0x8010000000000000LL;
287 expected.l = 0x3FF0000000000000LL;
288 result.d = _j0(tested.d);
289 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
290 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
291 errno = 0xDEADBEEF;
292 tested.l = 0x800FFFFFFFFFFFFFLL;
293 expected.l = 0x3FF0000000000000LL;
294 result.d = _j0(tested.d);
295 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
296 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
297 errno = 0xDEADBEEF;
298 tested.l = 0x8000000000000001LL;
299 expected.l = 0x3FF0000000000000LL;
300 result.d = _j0(tested.d);
301 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
302 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
303 errno = 0xDEADBEEF;
304 tested.l = 0x8000000000000000LL;
305 expected.l = 0x3FF0000000000000LL;
306 result.d = _j0(tested.d);
307 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
308 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
309 errno = 0xDEADBEEF;
310 tested.l = 0x0000000000000000LL;
311 expected.l = 0x3FF0000000000000LL;
312 result.d = _j0(tested.d);
313 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
314 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
315 errno = 0xDEADBEEF;
316 tested.l = 0x0000000000000001LL;
317 expected.l = 0x3FF0000000000000LL;
318 result.d = _j0(tested.d);
319 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
320 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
321 errno = 0xDEADBEEF;
322 tested.l = 0x000FFFFFFFFFFFFFLL;
323 expected.l = 0x3FF0000000000000LL;
324 result.d = _j0(tested.d);
325 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
326 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
327 errno = 0xDEADBEEF;
328 tested.l = 0x0010000000000000LL;
329 expected.l = 0x3FF0000000000000LL;
330 result.d = _j0(tested.d);
331 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
332 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
333 errno = 0xDEADBEEF;
334 tested.l = 0x7FEFFFFFFFFFFFFFLL;
335#ifdef _M_AMD64
336 expected.l = 0x8000000000000000LL;
337#else
338 expected.l = 0x1FE7206E1D6FDCFALL;
339#endif
340 result.d = _j0(tested.d);
341 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
342 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
343 errno = 0xDEADBEEF;
344 tested.l = 0x7FF0000000000000LL;
345 expected.l = 0xFFF8000000000000LL;
346 result.d = _j0(tested.d);
347 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
348 ok(errno == EDOM, "errno: %d\n", errno);
349 errno = 0xDEADBEEF;
350 tested.l = 0x7FF0000000000001LL;
351 expected.l = 0x7FF8000000000001LL;
352 result.d = _j0(tested.d);
353 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
354 ok(errno == EDOM, "errno: %d\n", errno);
355 errno = 0xDEADBEEF;
356 tested.l = 0x7FF7FFFFFFFFFFFFLL;
357 expected.l = 0x7FFFFFFFFFFFFFFFLL;
358 result.d = _j0(tested.d);
359 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
360 ok(errno == EDOM, "errno: %d\n", errno);
361 errno = 0xDEADBEEF;
362 tested.l = 0x7FF8000000000000LL;
363 expected.l = 0x7FF8000000000000LL;
364 result.d = _j0(tested.d);
365 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
366 ok(errno == EDOM, "errno: %d\n", errno);
367 errno = 0xDEADBEEF;
368 tested.l = 0x7FFFFFFFFFFFFFFFLL;
369 expected.l = 0x7FFFFFFFFFFFFFFFLL;
370 result.d = _j0(tested.d);
371 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
372 ok(errno == EDOM, "errno: %d\n", errno);
373
374 /* MSDN example */
375 errno = 0xDEADBEEF;
376 tested.d = 2.387000;
377 expected.l = 0x3F83059F9F6F30CALL;
378 result.d = _j0(tested.d);
379 ok(result.l == expected.l, "_j0 returned: %I64x\n", result.l);
380 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
381}
382
383void test_j1(void)
384{
385 ieee_double tested;
386 ieee_double expected;
387 ieee_double result;
388
389 expected.l = 0;
390
391 errno = 0xDEADBEEF;
392 tested.l = 0xFFFFFFFFFFFFFFFFLL;
393 expected.l = 0xFFFFFFFFFFFFFFFFLL;
394 result.d = _j1(tested.d);
395 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
396 ok(errno == EDOM, "errno: %d\n", errno);
397 errno = 0xDEADBEEF;
398 tested.l = 0xFFF8000000000001LL;
399 expected.l = 0xFFF8000000000001LL;
400 result.d = _j1(tested.d);
401 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
402 ok(errno == EDOM, "errno: %d\n", errno);
403 errno = 0xDEADBEEF;
404 tested.l = 0xFFF8000000000000LL;
405 expected.l = 0xFFF8000000000000LL;
406 result.d = _j1(tested.d);
407 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
408 ok(errno == EDOM, "errno: %d\n", errno);
409 errno = 0xDEADBEEF;
410 tested.l = 0xFFF7FFFFFFFFFFFFLL;
411 expected.l = 0xFFFFFFFFFFFFFFFFLL;
412 result.d = _j1(tested.d);
413 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
414 ok(errno == EDOM, "errno: %d\n", errno);
415 errno = 0xDEADBEEF;
416 tested.l = 0xFFF0000000000001LL;
417 expected.l = 0xFFF8000000000001LL;
418 result.d = _j1(tested.d);
419 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
420 ok(errno == EDOM, "errno: %d\n", errno);
421 errno = 0xDEADBEEF;
422 tested.l = 0xFFF0000000000000LL;
423 expected.l = 0xFFF8000000000000LL;
424 result.d = _j1(tested.d);
425 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
426 ok(errno == EDOM, "errno: %d\n", errno);
427 errno = 0xDEADBEEF;
428 tested.l = 0xFFEFFFFFFFFFFFFFLL;
429#ifdef _M_AMD64
430 expected.l = 0;
431#else
432 expected.l = 0x9FE7206E1D6FDCFALL;
433#endif
434 result.d = _j1(tested.d);
435 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
436 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
437 errno = 0xDEADBEEF;
438 tested.l = 0x8010000000000000LL;
439 expected.l = 0x8008000000000000LL;
440 result.d = _j1(tested.d);
441 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
442 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
443 errno = 0xDEADBEEF;
444 tested.l = 0x800FFFFFFFFFFFFFLL;
445 expected.l = 0x8008000000000000LL;
446 result.d = _j1(tested.d);
447 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
448 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
449 errno = 0xDEADBEEF;
450 tested.l = 0x8000000000000001LL;
451 expected.l = 0x8000000000000000LL;
452 result.d = _j1(tested.d);
453 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
454 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
455 errno = 0xDEADBEEF;
456 tested.l = 0x8000000000000000LL;
457 expected.l = 0x8000000000000000LL;
458 result.d = _j1(tested.d);
459 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
460 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
461 errno = 0xDEADBEEF;
462 tested.l = 0x0000000000000000LL;
463 expected.l = 0x0000000000000000LL;
464 result.d = _j1(tested.d);
465 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
466 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
467 errno = 0xDEADBEEF;
468 tested.l = 0x0000000000000001LL;
469 expected.l = 0x0000000000000000LL;
470 result.d = _j1(tested.d);
471 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
472 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
473 errno = 0xDEADBEEF;
474 tested.l = 0x000FFFFFFFFFFFFFLL;
475 expected.l = 0x0008000000000000LL;
476 result.d = _j1(tested.d);
477 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
478 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
479 errno = 0xDEADBEEF;
480 tested.l = 0x0010000000000000LL;
481 expected.l = 0x0008000000000000LL;
482 result.d = _j1(tested.d);
483 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
484 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
485 errno = 0xDEADBEEF;
486 tested.l = 0x7FEFFFFFFFFFFFFFLL;
487#ifdef _M_AMD64
488 expected.l = 0x8000000000000000LL;
489#else
490 expected.l = 0x1FE7206E1D6FDCFALL;
491#endif
492 result.d = _j1(tested.d);
493 ok(result.l == expected.l, "_j1 returned: %I64x, expected %I64x\n", result.l, expected.l);
494 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
495 errno = 0xDEADBEEF;
496 tested.l = 0x7FF0000000000000LL;
497 expected.l = 0xFFF8000000000000LL;
498 result.d = _j1(tested.d);
499 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
500 ok(errno == EDOM, "errno: %d\n", errno);
501 errno = 0xDEADBEEF;
502 tested.l = 0x7FF0000000000001LL;
503 expected.l = 0x7FF8000000000001LL;
504 result.d = _j1(tested.d);
505 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
506 ok(errno == EDOM, "errno: %d\n", errno);
507 errno = 0xDEADBEEF;
508 tested.l = 0x7FF7FFFFFFFFFFFFLL;
509 expected.l = 0x7FFFFFFFFFFFFFFFLL;
510 result.d = _j1(tested.d);
511 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
512 ok(errno == EDOM, "errno: %d\n", errno);
513 errno = 0xDEADBEEF;
514 tested.l = 0x7FF8000000000000LL;
515 expected.l = 0x7FF8000000000000LL;
516 result.d = _j1(tested.d);
517 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
518 ok(errno == EDOM, "errno: %d\n", errno);
519 errno = 0xDEADBEEF;
520 tested.l = 0x7FFFFFFFFFFFFFFFLL;
521 expected.l = 0x7FFFFFFFFFFFFFFFLL;
522 result.d = _j1(tested.d);
523 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
524 ok(errno == EDOM, "errno: %d\n", errno);
525
526 /* MSDN example */
527 errno = 0xDEADBEEF;
528 tested.d = 2.387000;
529 expected.l = 0x3FE0BBEFC62ABAB1LL;
530 result.d = _j1(tested.d);
531 ok(result.l == expected.l, "_j1 returned: %I64x\n", result.l);
532 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
533}
534
535void test_scalb(void)
536{
537 ieee_double tested;
538 ieee_double expected;
539 ieee_double result;
540
541 expected.l = 0;
542
543 errno = 0xDEADBEEF;
544 tested.l = 0xFFFFFFFFFFFFFFFFLL;
545 expected.l = 0xFFFFFFFFFFFFFFFFLL;
546 result.d = _scalb(tested.d, 3);
547 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
548 ok(errno == EDOM, "errno: %d\n", errno);
549 errno = 0xDEADBEEF;
550 tested.l = 0xFFF8000000000001LL;
551 expected.l = 0xFFF8000000000001LL;
552 result.d = _scalb(tested.d, 3);
553 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
554 ok(errno == EDOM, "errno: %d\n", errno);
555 errno = 0xDEADBEEF;
556 tested.l = 0xFFF8000000000000LL;
557 expected.l = 0xFFF8000000000000LL;
558 result.d = _scalb(tested.d, 3);
559 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
560 ok(errno == EDOM, "errno: %d\n", errno);
561 errno = 0xDEADBEEF;
562 tested.l = 0xFFF7FFFFFFFFFFFFLL;
563 expected.l = 0xFFFFFFFFFFFFFFFFLL;
564 result.d = _scalb(tested.d, 3);
565 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
566 ok(errno == EDOM, "errno: %d\n", errno);
567 errno = 0xDEADBEEF;
568 tested.l = 0xFFF0000000000001LL;
569 expected.l = 0xFFF8000000000001LL;
570 result.d = _scalb(tested.d, 3);
571 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
572 ok(errno == EDOM, "errno: %d\n", errno);
573 errno = 0xDEADBEEF;
574 tested.l = 0xFFF0000000000000LL;
575 expected.l = 0xFFF0000000000000LL;
576 result.d = _scalb(tested.d, 3);
577 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
578 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
579 errno = 0xDEADBEEF;
580 tested.l = 0xFFEFFFFFFFFFFFFFLL;
581 expected.l = 0xFFF0000000000000LL;
582 result.d = _scalb(tested.d, 3);
583 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
584 ok(errno == ERANGE, "errno: %d\n", errno);
585 errno = 0xDEADBEEF;
586 tested.l = 0x8010000000000000LL;
587 expected.l = 0x8040000000000000LL;
588 result.d = _scalb(tested.d, 3);
589 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
590 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
591 errno = 0xDEADBEEF;
592 tested.l = 0x800FFFFFFFFFFFFFLL;
593 expected.l = 0x803FFFFFFFFFFFFELL;
594 result.d = _scalb(tested.d, 3);
595 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
596 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
597 errno = 0xDEADBEEF;
598 tested.l = 0x8000000000000001LL;
599 expected.l = 0x8000000000000008LL;
600 result.d = _scalb(tested.d, 3);
601 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
602 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
603 errno = 0xDEADBEEF;
604 tested.l = 0x8000000000000000LL;
605 expected.l = 0x8000000000000000LL;
606 result.d = _scalb(tested.d, 3);
607 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
608 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
609 errno = 0xDEADBEEF;
610 tested.l = 0x0000000000000000LL;
611 expected.l = 0x0000000000000000LL;
612 result.d = _scalb(tested.d, 3);
613 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
614 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
615 errno = 0xDEADBEEF;
616 tested.l = 0x0000000000000001LL;
617 expected.l = 0x0000000000000008LL;
618 result.d = _scalb(tested.d, 3);
619 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
620 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
621 errno = 0xDEADBEEF;
622 tested.l = 0x000FFFFFFFFFFFFFLL;
623 expected.l = 0x003FFFFFFFFFFFFELL;
624 result.d = _scalb(tested.d, 3);
625 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
626 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
627 errno = 0xDEADBEEF;
628 tested.l = 0x0010000000000000LL;
629 expected.l = 0x0040000000000000LL;
630 result.d = _scalb(tested.d, 3);
631 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
632 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
633 errno = 0xDEADBEEF;
634 tested.l = 0x7FEFFFFFFFFFFFFFLL;
635 expected.l = 0x7FF0000000000000LL;
636 result.d = _scalb(tested.d, 3);
637 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
638 ok(errno == ERANGE, "errno: %d\n", errno);
639 errno = 0xDEADBEEF;
640 tested.l = 0x7FF0000000000000LL;
641 expected.l = 0x7FF0000000000000LL;
642 result.d = _scalb(tested.d, 3);
643 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
644 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
645 errno = 0xDEADBEEF;
646 tested.l = 0x7FF0000000000001LL;
647 expected.l = 0x7FF8000000000001LL;
648 result.d = _scalb(tested.d, 3);
649 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
650 ok(errno == EDOM, "errno: %d\n", errno);
651 errno = 0xDEADBEEF;
652 tested.l = 0x7FF7FFFFFFFFFFFFLL;
653 expected.l = 0x7FFFFFFFFFFFFFFFLL;
654 result.d = _scalb(tested.d, 3);
655 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
656 ok(errno == EDOM, "errno: %d\n", errno);
657 errno = 0xDEADBEEF;
658 tested.l = 0x7FF8000000000000LL;
659 expected.l = 0x7FF8000000000000LL;
660 result.d = _scalb(tested.d, 3);
661 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
662 ok(errno == EDOM, "errno: %d\n", errno);
663 errno = 0xDEADBEEF;
664 tested.l = 0x7FFFFFFFFFFFFFFFLL;
665 expected.l = 0x7FFFFFFFFFFFFFFFLL;
666 result.d = _scalb(tested.d, 3);
667 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
668 ok(errno == EDOM, "errno: %d\n", errno);
669
670 /* MSDN example */
671 errno = 0xDEADBEEF;
672 tested.d = 2.387000;
673 expected.l = 0x4033189374BC6A7FLL;
674 result.d = _scalb(tested.d, 3);
675 ok(result.l == expected.l, "_scalb returned: %I64x\n", result.l);
676 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
677}
678
679void test_y0(void)
680{
681 ieee_double tested;
682 ieee_double expected;
683 ieee_double result;
684
685 expected.l = 0;
686
687 errno = 0xDEADBEEF;
688 tested.l = 0xFFFFFFFFFFFFFFFFLL;
689 expected.l = 0xFFFFFFFFFFFFFFFFLL;
690 result.d = _y0(tested.d);
691 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
692 ok(errno == EDOM, "errno: %d\n", errno);
693 errno = 0xDEADBEEF;
694 tested.l = 0xFFF8000000000001LL;
695 expected.l = 0xFFF8000000000001LL;
696 result.d = _y0(tested.d);
697 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
698 ok(errno == EDOM, "errno: %d\n", errno);
699 errno = 0xDEADBEEF;
700 tested.l = 0xFFF8000000000000LL;
701 expected.l = 0xFFF8000000000000LL;
702 result.d = _y0(tested.d);
703 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
704 ok(errno == EDOM, "errno: %d\n", errno);
705 errno = 0xDEADBEEF;
706 tested.l = 0xFFF7FFFFFFFFFFFFLL;
707 expected.l = 0xFFFFFFFFFFFFFFFFLL;
708 result.d = _y0(tested.d);
709 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
710 ok(errno == EDOM, "errno: %d\n", errno);
711 errno = 0xDEADBEEF;
712 tested.l = 0xFFF0000000000001LL;
713 expected.l = 0xFFF8000000000001LL;
714 result.d = _y0(tested.d);
715 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
716 ok(errno == EDOM, "errno: %d\n", errno);
717 errno = 0xDEADBEEF;
718 tested.l = 0xFFF0000000000000LL;
719 expected.l = 0xFFF8000000000000LL;
720 result.d = _y0(tested.d);
721 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
722 ok(errno == EDOM, "errno: %d\n", errno);
723 errno = 0xDEADBEEF;
724 tested.l = 0xFFEFFFFFFFFFFFFFLL;
725 expected.l = 0xFFF8000000000000LL;
726 result.d = _y0(tested.d);
727 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
728 ok(errno == EDOM, "errno: %d\n", errno);
729 errno = 0xDEADBEEF;
730 tested.l = 0x8010000000000000LL;
731 expected.l = 0xFFF8000000000000LL;
732 result.d = _y0(tested.d);
733 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
734 ok(errno == EDOM, "errno: %d\n", errno);
735 errno = 0xDEADBEEF;
736 tested.l = 0x800FFFFFFFFFFFFFLL;
737 expected.l = 0xFFF8000000000000LL;
738 result.d = _y0(tested.d);
739 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
740 ok(errno == EDOM, "errno: %d\n", errno);
741 errno = 0xDEADBEEF;
742 tested.l = 0x8000000000000001LL;
743 expected.l = 0xFFF8000000000000LL;
744 result.d = _y0(tested.d);
745 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
746 ok(errno == EDOM, "errno: %d\n", errno);
747 errno = 0xDEADBEEF;
748 tested.l = 0x8000000000000000LL;
749 expected.l = 0xFFF0000000000000LL;
750 result.d = _y0(tested.d);
751 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
752 ok(errno == ERANGE, "errno: %d\n", errno);
753 errno = 0xDEADBEEF;
754 tested.l = 0x0000000000000000LL;
755 expected.l = 0xFFF0000000000000LL;
756 result.d = _y0(tested.d);
757 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
758 ok(errno == ERANGE, "errno: %d\n", errno);
759 errno = 0xDEADBEEF;
760 tested.l = 0x0000000000000001LL;
761 expected.l = 0xC07D9FFC3469E1B3LL;
762 result.d = _y0(tested.d);
763 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
764 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
765 errno = 0xDEADBEEF;
766 tested.l = 0x000FFFFFFFFFFFFFLL;
767 expected.l = 0xC07C30D8F820740ELL;
768 result.d = _y0(tested.d);
769 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
770 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
771 errno = 0xDEADBEEF;
772 tested.l = 0x0010000000000000LL;
773 expected.l = 0xC07C30D8F820740ELL;
774 result.d = _y0(tested.d);
775 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
776 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
777 errno = 0xDEADBEEF;
778 tested.l = 0x7FEFFFFFFFFFFFFFLL;
779#ifdef _M_AMD64
780 expected.l = 0;
781#else
782 expected.l = 0x9FD5A36F8428F58BLL;
783#endif
784 result.d = _y0(tested.d);
785 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
786 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
787 errno = 0xDEADBEEF;
788 tested.l = 0x7FF0000000000000LL;
789 expected.l = 0xFFF8000000000000LL;
790 result.d = _y0(tested.d);
791 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
792 ok(errno == EDOM, "errno: %d\n", errno);
793 errno = 0xDEADBEEF;
794 tested.l = 0x7FF0000000000001LL;
795 expected.l = 0x7FF8000000000001LL;
796 result.d = _y0(tested.d);
797 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
798 ok(errno == EDOM, "errno: %d\n", errno);
799 errno = 0xDEADBEEF;
800 tested.l = 0x7FF7FFFFFFFFFFFFLL;
801 expected.l = 0x7FFFFFFFFFFFFFFFLL;
802 result.d = _y0(tested.d);
803 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
804 ok(errno == EDOM, "errno: %d\n", errno);
805 errno = 0xDEADBEEF;
806 tested.l = 0x7FF8000000000000LL;
807 expected.l = 0x7FF8000000000000LL;
808 result.d = _y0(tested.d);
809 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
810 ok(errno == EDOM, "errno: %d\n", errno);
811 errno = 0xDEADBEEF;
812 tested.l = 0x7FFFFFFFFFFFFFFFLL;
813 expected.l = 0x7FFFFFFFFFFFFFFFLL;
814 result.d = _y0(tested.d);
815 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
816 ok(errno == EDOM, "errno: %d\n", errno);
817
818 /* MSDN example */
819 errno = 0xDEADBEEF;
820 tested.d = 2.387000;
821 expected.l = 0x3FE05FB1B1E49E66LL;
822 result.d = _y0(tested.d);
823 ok(result.l == expected.l, "_y0 returned: %I64x\n", result.l);
824 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
825}
826
827void test_y1(void)
828{
829 ieee_double tested;
830 ieee_double expected;
831 ieee_double result;
832
833 expected.l = 0;
834
835 errno = 0xDEADBEEF;
836 tested.l = 0xFFFFFFFFFFFFFFFFLL;
837 expected.l = 0xFFFFFFFFFFFFFFFFLL;
838 result.d = _y1(tested.d);
839 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
840 ok(errno == EDOM, "errno: %d\n", errno);
841 errno = 0xDEADBEEF;
842 tested.l = 0xFFF8000000000001LL;
843 expected.l = 0xFFF8000000000001LL;
844 result.d = _y1(tested.d);
845 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
846 ok(errno == EDOM, "errno: %d\n", errno);
847 errno = 0xDEADBEEF;
848 tested.l = 0xFFF8000000000000LL;
849 expected.l = 0xFFF8000000000000LL;
850 result.d = _y1(tested.d);
851 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
852 ok(errno == EDOM, "errno: %d\n", errno);
853 errno = 0xDEADBEEF;
854 tested.l = 0xFFF7FFFFFFFFFFFFLL;
855 expected.l = 0xFFFFFFFFFFFFFFFFLL;
856 result.d = _y1(tested.d);
857 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
858 ok(errno == EDOM, "errno: %d\n", errno);
859 errno = 0xDEADBEEF;
860 tested.l = 0xFFF0000000000001LL;
861 expected.l = 0xFFF8000000000001LL;
862 result.d = _y1(tested.d);
863 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
864 ok(errno == EDOM, "errno: %d\n", errno);
865 errno = 0xDEADBEEF;
866 tested.l = 0xFFF0000000000000LL;
867 expected.l = 0xFFF8000000000000LL;
868 result.d = _y1(tested.d);
869 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
870 ok(errno == EDOM, "errno: %d\n", errno);
871 errno = 0xDEADBEEF;
872 tested.l = 0xFFEFFFFFFFFFFFFFLL;
873 expected.l = 0xFFF8000000000000LL;
874 result.d = _y1(tested.d);
875 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
876 ok(errno == EDOM, "errno: %d\n", errno);
877 errno = 0xDEADBEEF;
878 tested.l = 0x8010000000000000LL;
879 expected.l = 0xFFF8000000000000LL;
880 result.d = _y1(tested.d);
881 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
882 ok(errno == EDOM, "errno: %d\n", errno);
883 errno = 0xDEADBEEF;
884 tested.l = 0x800FFFFFFFFFFFFFLL;
885 expected.l = 0xFFF8000000000000LL;
886 result.d = _y1(tested.d);
887 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
888 ok(errno == EDOM, "errno: %d\n", errno);
889 errno = 0xDEADBEEF;
890 tested.l = 0x8000000000000001LL;
891 expected.l = 0xFFF8000000000000LL;
892 result.d = _y1(tested.d);
893 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
894 ok(errno == EDOM, "errno: %d\n", errno);
895 errno = 0xDEADBEEF;
896 tested.l = 0x8000000000000000LL;
897 expected.l = 0xFFF8000000000000LL;
898 result.d = _y1(tested.d);
899 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
900 ok(errno == ERANGE, "errno: %d\n", errno);
901 errno = 0xDEADBEEF;
902 tested.l = 0x0000000000000000LL;
903 expected.l = 0xFFF8000000000000LL;
904 result.d = _y1(tested.d);
905 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
906 ok(errno == ERANGE, "errno: %d\n", errno);
907 errno = 0xDEADBEEF;
908 tested.l = 0x0000000000000001LL;
909 expected.l = 0xFFF0000000000000LL;
910 result.d = _y1(tested.d);
911 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
912 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
913 errno = 0xDEADBEEF;
914 tested.l = 0x000FFFFFFFFFFFFFLL;
915 expected.l = 0xFFC45F306DC9C884LL;
916 result.d = _y1(tested.d);
917 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
918 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
919 errno = 0xDEADBEEF;
920 tested.l = 0x0010000000000000LL;
921 expected.l = 0xFFC45F306DC9C883LL;
922 result.d = _y1(tested.d);
923 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
924 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
925 errno = 0xDEADBEEF;
926 tested.l = 0x7FEFFFFFFFFFFFFFLL;
927#ifdef _M_AMD64
928 expected.l = 0;
929#else
930 expected.l = 0x9FD5A36F8428F58BLL;
931#endif
932 result.d = _y1(tested.d);
933 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
934 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
935 errno = 0xDEADBEEF;
936 tested.l = 0x7FF0000000000000LL;
937 expected.l = 0xFFF8000000000000LL;
938 result.d = _y1(tested.d);
939 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
940 ok(errno == EDOM, "errno: %d\n", errno);
941 errno = 0xDEADBEEF;
942 tested.l = 0x7FF0000000000001LL;
943 expected.l = 0x7FF8000000000001LL;
944 result.d = _y1(tested.d);
945 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
946 ok(errno == EDOM, "errno: %d\n", errno);
947 errno = 0xDEADBEEF;
948 tested.l = 0x7FF7FFFFFFFFFFFFLL;
949 expected.l = 0x7FFFFFFFFFFFFFFFLL;
950 result.d = _y1(tested.d);
951 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
952 ok(errno == EDOM, "errno: %d\n", errno);
953 errno = 0xDEADBEEF;
954 tested.l = 0x7FF8000000000000LL;
955 expected.l = 0x7FF8000000000000LL;
956 result.d = _y1(tested.d);
957 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
958 ok(errno == EDOM, "errno: %d\n", errno);
959 errno = 0xDEADBEEF;
960 tested.l = 0x7FFFFFFFFFFFFFFFLL;
961 expected.l = 0x7FFFFFFFFFFFFFFFLL;
962 result.d = _y1(tested.d);
963 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
964 ok(errno == EDOM, "errno: %d\n", errno);
965
966 /* MSDN example */
967 errno = 0xDEADBEEF;
968 tested.d = 2.387000;
969 expected.l = 0x3FB828EC13723EE6LL;
970 result.d = _y1(tested.d);
971 ok(result.l == expected.l, "_y1 returned: %I64x\n", result.l);
972 ok(errno == 0xDEADBEEF, "errno: %d\n", errno);
973}
974
975START_TEST(ieee)
976{
977 test_finite();
978 test_fpclass();
979 test_isnan();
980 test_j0();
981 test_j1();
982 test_scalb();
983 test_y0();
984 test_y1();
985}
ERANGE
#define ERANGE
Definition: acclib.h:92
ok
#define ok(value,...)
Definition: atltest.h:57
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
EDOM
#define EDOM
Definition: errno.h:39
result
GLuint64EXT * result
Definition: glext.h:11304
test_isnan
void test_isnan(void)
Definition: ieee.c:180
test_j0
void test_j0(void)
Definition: ieee.c:231
test_scalb
void test_scalb(void)
Definition: ieee.c:535
test_y0
void test_y0(void)
Definition: ieee.c:679
test_y1
void test_y1(void)
Definition: ieee.c:827
test_finite
void test_finite(void)
Definition: ieee.c:20
test_j1
void test_j1(void)
Definition: ieee.c:383
test_fpclass
void test_fpclass(void)
Definition: ieee.c:71
_FPCLASS_PZ
#define _FPCLASS_PZ
Definition: float.h:78
_FPCLASS_PD
#define _FPCLASS_PD
Definition: float.h:79
_fpclass
_Check_return_ __MINGW_NOTHROW _CRTIMP int __cdecl _fpclass(_In_ double)
_FPCLASS_PN
#define _FPCLASS_PN
Definition: float.h:80
_FPCLASS_ND
#define _FPCLASS_ND
Definition: float.h:76
_FPCLASS_QNAN
#define _FPCLASS_QNAN
Definition: float.h:73
_FPCLASS_NINF
#define _FPCLASS_NINF
Definition: float.h:74
_FPCLASS_NN
#define _FPCLASS_NN
Definition: float.h:75
_scalb
_Check_return_ __MINGW_NOTHROW _CRTIMP double __cdecl _scalb(_In_ double, _In_ long)
_isnan
_Check_return_ __MINGW_NOTHROW _CRTIMP int __cdecl _isnan(_In_ double)
_FPCLASS_SNAN
#define _FPCLASS_SNAN
Definition: float.h:72
_finite
_Check_return_ __MINGW_NOTHROW _CRTIMP int __cdecl _finite(_In_ double)
_FPCLASS_NZ
#define _FPCLASS_NZ
Definition: float.h:77
_FPCLASS_PINF
#define _FPCLASS_PINF
Definition: float.h:81
_j0
_Check_return_ _CRTIMP double __cdecl _j0(_In_ double x)
_j1
_Check_return_ _CRTIMP double __cdecl _j1(_In_ double x)
_y0
_Check_return_ _CRTIMP double __cdecl _y0(_In_ double x)
_y1
_Check_return_ _CRTIMP double __cdecl _y1(_In_ double x)
d
#define d
Definition: ke_i.h:81
expected
BOOL expected
Definition: store.c:2063
errno
#define errno
Definition: errno.h:18
ieee_double
Definition: ieee.c:15
ieee_double::l
long long l
Definition: ieee.c:17
ieee_double::d
double d
Definition: ieee.c:16