test: flpt.c Source File

Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

# flpt.c

Go to the documentation of this file.

    00001 /*++
    00002
    00003 Copyright (c) 1991  Microsoft Corporation
    00004
    00005 Module Name:
    00006
    00007     flpt.c
    00008
    00009 Abstract:
    00010
    00011     This module implements user mode IEEE floating point tests.
    00012
    00013 Author:
    00014
    00015     David N. Cutler (davec) 20-Jun-1991
    00016
    00017 Environment:
    00018
    00019     User mode only.
    00020
    00021 Revision History:
    00022
    00023 --*/
    00024
    00025 #include "flpt.h"
    00026
    00027 VOID
    00028 main(
    00029     int argc,
    00030     char *argv[]
    00031     )
    00032
    00033 {
    00034     //
    00035     // Anounce start of floting point tests.
    00036     //
    00037
    00038     printf("\nStart of floating point test\n");
    00039     Test1();
    00040     Test2();
    00041     Test3();
    00042     Test4();
    00043     Test5();
    00044     Test6();
    00045     Test7();
    00046     Test8();
    00047     Test9();
    00048     Test10();
    00049     Test11();
    00050     Test12();
    00051     Test13();
    00052     Test14();
    00053     Test15();
    00054     Test16();
    00055     Test17();
    00056     Test18();
    00057     Test19();
    00058     Test20();
    00059     Test21();
    00060     Test22();
    00061     Test23();
    00062     Test24();
    00063     Test25();
    00064     Test26();
    00065
    00066     //
    00067     // Announce end of floating point test.
    00068     //
    00069
    00070     printf("End of floating point test\n");
    00071     return;
    00072 }
    00073
    00074 VOID
    00075 Test1 (
    00076     VOID
    00077     )
    00078
    00079 {
    00080
    00081     ULONG Count;
    00082     FLOATING_STATUS Fsr;
    00083     ULONG SingleResult;
    00084     ULONG Subtest;
    00085
    00086     //
    00087     // Test 1 - Add single denormalized test.
    00088     //
    00089
    00090     Subtest = 0;
    00091     printf("    Test 1 - add/subtract single denormalized ...");
    00092     Subtest += 1;
    00093     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00094                          0x3ff,
    00095                          0x1,
    00096                          &SingleResult);
    00097
    00098     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00099         (SingleResult != 0x400)) {
    00100         goto TestFailed;
    00101     }
    00102
    00103     Subtest += 1;
    00104     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00105                          0x1,
    00106                          0x7fff,
    00107                          &SingleResult);
    00108
    00109     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00110         (SingleResult != 0x8000)) {
    00111         goto TestFailed;
    00112     }
    00113
    00114     Subtest += 1;
    00115     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00116                          0x400000,
    00117                          SIGN | 0x440000,
    00118                          &SingleResult);
    00119
    00120     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00121         (SingleResult != (SIGN | 0x40000))) {
    00122         goto TestFailed;
    00123     }
    00124
    00125     Subtest += 1;
    00126     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00127                          SIGN | 0x400000,
    00128                          0x440000,
    00129                          &SingleResult);
    00130
    00131     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00132         (SingleResult != 0x40000)) {
    00133         goto TestFailed;
    00134     }
    00135
    00136     Subtest += 1;
    00137     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00138                          0x400000,
    00139                          SIGN | 0x400000,
    00140                          &SingleResult);
    00141
    00142     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00143         (SingleResult != 0x0)) {
    00144         goto TestFailed;
    00145     }
    00146
    00147     Subtest += 1;
    00148     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00149                          SIGN | 0x400000,
    00150                          0x400000,
    00151                          &SingleResult);
    00152
    00153     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00154         (SingleResult != (SIGN | 0x0))) {
    00155         goto TestFailed;
    00156     }
    00157
    00158     Subtest += 1;
    00159     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00160                          0x400000,
    00161                          0x400000,
    00162                          &SingleResult);
    00163
    00164     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00165         (SingleResult != 0x800000)) {
    00166         goto TestFailed;
    00167     }
    00168
    00169     Subtest += 1;
    00170     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00171                          0x800000,
    00172                          0x7fffff,
    00173                          &SingleResult);
    00174
    00175     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00176         (SingleResult != 0xffffff)) {
    00177         goto TestFailed;
    00178     }
    00179
    00180     Subtest += 1;
    00181     Count = 0;
    00182     try {
    00183         Fsr.Data = AddSingle(EI | ROUND_TO_NEAREST,
    00184                              0x800000,
    00185                              0x3f800000,
    00186                              &SingleResult);
    00187
    00188     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    00189               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00190         Count += 1;
    00191     }
    00192
    00193     if (Count == 0) {
    00194         goto TestFailed;
    00195     }
    00196
    00197     Subtest += 1;
    00198     Count = 0;
    00199     try {
    00200         Fsr.Data = AddSingle(EO | ROUND_TO_NEAREST,
    00201                              0x7f000000,
    00202                              0x7f000000,
    00203                              &SingleResult);
    00204
    00205     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    00206               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00207         Count += 1;
    00208     }
    00209
    00210     if (Count == 0) {
    00211         goto TestFailed;
    00212     }
    00213
    00214     Subtest += 1;
    00215     Count = 0;
    00216     try {
    00217         Fsr.Data = AddSingle(EI | ROUND_TO_NEAREST,
    00218                              0x7f000000,
    00219                              0x7f000000,
    00220                              &SingleResult);
    00221
    00222     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    00223               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00224         Count += 1;
    00225     }
    00226
    00227     if (Count == 0) {
    00228         goto TestFailed;
    00229     }
    00230
    00231     Subtest += 1;
    00232     Count = 0;
    00233     try {
    00234         Fsr.Data = AddSingle(EI | EO | ROUND_TO_NEAREST,
    00235                              0x7f000000,
    00236                              0x7f000000,
    00237                              &SingleResult);
    00238
    00239     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    00240               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00241         Count += 1;
    00242     }
    00243
    00244     if (Count == 0) {
    00245         goto TestFailed;
    00246     }
    00247
    00248     Subtest += 1;
    00249     Fsr.Data = SubtractSingle(ROUND_TO_NEAREST,
    00250                               0x3ff,
    00251                               SIGN | 0x1,
    00252                               &SingleResult);
    00253
    00254     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00255         (SingleResult != 0x400)) {
    00256         goto TestFailed;
    00257     }
    00258
    00259     Subtest += 1;
    00260     Fsr.Data = SubtractSingle(ROUND_TO_NEAREST,
    00261                               0x1,
    00262                               SIGN | 0x7fff,
    00263                               &SingleResult);
    00264
    00265     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00266         (SingleResult != 0x8000)) {
    00267         goto TestFailed;
    00268     }
    00269
    00270     Subtest += 1;
    00271     Fsr.Data = SubtractSingle(ROUND_TO_NEAREST,
    00272                               0x400000,
    00273                               0x440000,
    00274                               &SingleResult);
    00275
    00276     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00277         (SingleResult != (SIGN | 0x40000))) {
    00278         goto TestFailed;
    00279     }
    00280
    00281     Subtest += 1;
    00282     Fsr.Data = SubtractSingle(ROUND_TO_NEAREST,
    00283                               SIGN | 0x400000,
    00284                               SIGN | 0x440000,
    00285                               &SingleResult);
    00286
    00287     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00288         (SingleResult != 0x40000)) {
    00289         goto TestFailed;
    00290     }
    00291
    00292     Subtest += 1;
    00293     Fsr.Data = SubtractSingle(ROUND_TO_NEAREST,
    00294                               0x400000,
    00295                               0x400000,
    00296                               &SingleResult);
    00297
    00298     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00299         (SingleResult != 0x0)) {
    00300         goto TestFailed;
    00301     }
    00302
    00303     Subtest += 1;
    00304     Fsr.Data = SubtractSingle(ROUND_TO_NEAREST,
    00305                               SIGN | 0x400000,
    00306                               SIGN | 0x400000,
    00307                               &SingleResult);
    00308
    00309     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00310         (SingleResult != (SIGN | 0x0))) {
    00311         goto TestFailed;
    00312     }
    00313
    00314     Subtest += 1;
    00315     Fsr.Data = SubtractSingle(ROUND_TO_NEAREST,
    00316                               0x400000,
    00317                               SIGN | 0x400000,
    00318                               &SingleResult);
    00319
    00320     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00321         (SingleResult != 0x800000)) {
    00322         goto TestFailed;
    00323     }
    00324
    00325     Subtest += 1;
    00326     Fsr.Data = SubtractSingle(ROUND_TO_NEAREST,
    00327                               0x800000,
    00328                               SIGN | 0x7fffff,
    00329                               &SingleResult);
    00330
    00331     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00332         (SingleResult != 0xffffff)) {
    00333         goto TestFailed;
    00334     }
    00335
    00336     Subtest += 1;
    00337     Count = 0;
    00338     try {
    00339         Fsr.Data = SubtractSingle(EI | ROUND_TO_NEAREST,
    00340                                   0x800000,
    00341                                   SIGN | 0x3f800000,
    00342                                   &SingleResult);
    00343
    00344     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    00345               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00346         Count += 1;
    00347     }
    00348
    00349     if (Count == 0) {
    00350         goto TestFailed;
    00351     }
    00352
    00353     Subtest += 1;
    00354     Count = 0;
    00355     try {
    00356         Fsr.Data = SubtractSingle(EO | ROUND_TO_NEAREST,
    00357                                   0x7f000000,
    00358                                   SIGN | 0x7f000000,
    00359                                   &SingleResult);
    00360
    00361     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    00362               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00363         Count += 1;
    00364     }
    00365
    00366     if (Count == 0) {
    00367         goto TestFailed;
    00368     }
    00369
    00370     Subtest += 1;
    00371     Count = 0;
    00372     try {
    00373         Fsr.Data = SubtractSingle(EI | ROUND_TO_NEAREST,
    00374                                   0x7f000000,
    00375                                   SIGN | 0x7f000000,
    00376                                   &SingleResult);
    00377
    00378     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    00379               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00380         Count += 1;
    00381     }
    00382
    00383     if (Count == 0) {
    00384         goto TestFailed;
    00385     }
    00386
    00387     Subtest += 1;
    00388     Count = 0;
    00389     try {
    00390         Fsr.Data = SubtractSingle(EI | EO | ROUND_TO_NEAREST,
    00391                                   0x7f000000,
    00392                                   SIGN | 0x7f000000,
    00393                                   &SingleResult);
    00394
    00395     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    00396               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00397         Count += 1;
    00398     }
    00399
    00400     if (Count == 0) {
    00401         goto TestFailed;
    00402     }
    00403
    00404     //
    00405     // End of test 1.
    00406     //
    00407
    00408     printf("succeeded\n");
    00409     return;
    00410
    00411     //
    00412     // Test 1 failed.
    00413     //
    00414
    00415 TestFailed:
    00416     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    00417            Subtest,
    00418            Fsr.Data,
    00419            SingleResult);
    00420
    00421     return;
    00422 }
    00423
    00424 VOID
    00425 Test2 (
    00426     VOID
    00427     )
    00428
    00429 {
    00430
    00431     ULONG Count;
    00432     FLOATING_STATUS Fsr;
    00433     ULONG SingleResult;
    00434     ULONG Subtest;
    00435
    00436     //
    00437     // Test 2 - Add single round to nearest test.
    00438     //
    00439
    00440     Subtest = 0;
    00441     printf("    Test 2 - add single round to nearest ...");
    00442     Subtest += 1;
    00443     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00444                          0x1800000,
    00445                          0x7ffff8,
    00446                          &SingleResult);
    00447
    00448     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00449         (SingleResult != 0x19ffffe)) {
    00450         goto TestFailed;
    00451     }
    00452
    00453     Subtest += 1;
    00454     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00455                          0x1800000,
    00456                          0x7ffff9,
    00457                          &SingleResult);
    00458
    00459     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    00460         (SingleResult != 0x19ffffe)) {
    00461         goto TestFailed;
    00462     }
    00463
    00464     Subtest += 1;
    00465     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00466                          0x1800000,
    00467                          0x7ffffa,
    00468                          &SingleResult);
    00469
    00470     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    00471         (SingleResult != 0x19ffffe)) {
    00472         goto TestFailed;
    00473     }
    00474
    00475     Subtest += 1;
    00476     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00477                          0x1800000,
    00478                          0x7ffffb,
    00479                          &SingleResult);
    00480
    00481     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    00482         (SingleResult != 0x19fffff)) {
    00483         goto TestFailed;
    00484     }
    00485
    00486     Subtest += 1;
    00487     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00488                          0x1800000,
    00489                          0x7ffffc,
    00490                          &SingleResult);
    00491
    00492     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00493         (SingleResult != 0x19fffff)) {
    00494         goto TestFailed;
    00495     }
    00496
    00497     Subtest += 1;
    00498     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00499                          0x1800000,
    00500                          0x7ffffd,
    00501                          &SingleResult);
    00502
    00503     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    00504         (SingleResult != 0x19fffff)) {
    00505         goto TestFailed;
    00506     }
    00507
    00508     Subtest += 1;
    00509     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00510                          0x1800000,
    00511                          0x7ffffe,
    00512                          &SingleResult);
    00513
    00514     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    00515         (SingleResult != 0x1a00000)) {
    00516         goto TestFailed;
    00517     }
    00518
    00519     Subtest += 1;
    00520     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    00521                          0x1800000,
    00522                          0x7fffff,
    00523                          &SingleResult);
    00524
    00525     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    00526         (SingleResult != 0x1a00000)) {
    00527         goto TestFailed;
    00528     }
    00529
    00530     Count = 0;
    00531     try {
    00532         Subtest += 1;
    00533         Fsr.Data = AddSingle(EI | ROUND_TO_NEAREST,
    00534                              0x1800000,
    00535                              0x7fffff,
    00536                              &SingleResult);
    00537
    00538     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    00539               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00540         Count += 1;
    00541     }
    00542
    00543     if (Count == 0) {
    00544         goto TestFailed;
    00545     }
    00546
    00547     //
    00548     // End of test 2.
    00549     //
    00550
    00551     printf("succeeded\n");
    00552     return;
    00553
    00554     //
    00555     // Test 2 failed.
    00556     //
    00557
    00558 TestFailed:
    00559     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    00560            Subtest,
    00561            Fsr.Data,
    00562            SingleResult);
    00563
    00564     return;
    00565 }
    00566
    00567 VOID
    00568 Test3 (
    00569     VOID
    00570     )
    00571
    00572 {
    00573
    00574     ULONG Count;
    00575     FLOATING_STATUS Fsr;
    00576     ULONG SingleResult;
    00577     ULONG Subtest;
    00578
    00579     //
    00580     // Test 3 - Add single round to zero test.
    00581     //
    00582
    00583     Subtest = 0;
    00584     printf("    Test 3 - add single round to zero ...");
    00585     Subtest += 1;
    00586     Fsr.Data = AddSingle(ROUND_TO_ZERO,
    00587                          0x1800000,
    00588                          0x7ffff8,
    00589                          &SingleResult);
    00590
    00591     if ((Fsr.Data != ROUND_TO_ZERO) ||
    00592         (SingleResult != 0x19ffffe)) {
    00593         goto TestFailed;
    00594     }
    00595
    00596     Subtest += 1;
    00597     Fsr.Data = AddSingle(ROUND_TO_ZERO,
    00598                          0x1800000,
    00599                          0x7ffff9,
    00600                          &SingleResult);
    00601
    00602     if ((Fsr.Data != (SI | ROUND_TO_ZERO)) ||
    00603         (SingleResult != 0x19ffffe)) {
    00604         goto TestFailed;
    00605     }
    00606
    00607     Subtest += 1;
    00608     Fsr.Data = AddSingle(ROUND_TO_ZERO,
    00609                          0x1800000,
    00610                          0x7ffffa,
    00611                          &SingleResult);
    00612
    00613     if ((Fsr.Data != (SI | ROUND_TO_ZERO)) ||
    00614         (SingleResult != 0x19ffffe)) {
    00615         goto TestFailed;
    00616     }
    00617
    00618     Subtest += 1;
    00619     Fsr.Data = AddSingle(ROUND_TO_ZERO,
    00620                          0x1800000,
    00621                          0x7ffffb,
    00622                          &SingleResult);
    00623
    00624     if ((Fsr.Data != (SI | ROUND_TO_ZERO)) ||
    00625         (SingleResult != 0x19ffffe)) {
    00626         goto TestFailed;
    00627     }
    00628
    00629     Subtest += 1;
    00630     Fsr.Data = AddSingle(ROUND_TO_ZERO,
    00631                          0x1800000,
    00632                          0x7ffffc,
    00633                          &SingleResult);
    00634
    00635     if ((Fsr.Data != ROUND_TO_ZERO) ||
    00636         (SingleResult != 0x19fffff)) {
    00637         goto TestFailed;
    00638     }
    00639
    00640     Subtest += 1;
    00641     Fsr.Data = AddSingle(ROUND_TO_ZERO,
    00642                          0x1800000,
    00643                          0x7ffffd,
    00644                          &SingleResult);
    00645
    00646     if ((Fsr.Data != (SI | ROUND_TO_ZERO)) ||
    00647         (SingleResult != 0x19fffff)) {
    00648         goto TestFailed;
    00649     }
    00650
    00651     Subtest += 1;
    00652     Fsr.Data = AddSingle(ROUND_TO_ZERO,
    00653                          0x1800000,
    00654                          0x7ffffe,
    00655                          &SingleResult);
    00656
    00657     if ((Fsr.Data != (SI | ROUND_TO_ZERO)) ||
    00658         (SingleResult != 0x19fffff)) {
    00659         goto TestFailed;
    00660     }
    00661
    00662     Subtest += 1;
    00663     Fsr.Data = AddSingle(ROUND_TO_ZERO,
    00664                          0x1800000,
    00665                          0x7fffff,
    00666                          &SingleResult);
    00667
    00668     if ((Fsr.Data != (SI | ROUND_TO_ZERO)) ||
    00669         (SingleResult != 0x19fffff)) {
    00670         goto TestFailed;
    00671     }
    00672
    00673     Count = 0;
    00674     try {
    00675         Subtest += 1;
    00676         Fsr.Data = AddSingle(EI | ROUND_TO_ZERO,
    00677                              0x1800000,
    00678                              0x7fffff,
    00679                              &SingleResult);
    00680
    00681     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    00682               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00683         Count += 1;
    00684     }
    00685
    00686     if (Count == 0) {
    00687         goto TestFailed;
    00688     }
    00689
    00690     //
    00691     // End of test 3.
    00692     //
    00693
    00694     printf("succeeded\n");
    00695     return;
    00696
    00697     //
    00698     // Test 3 failed.
    00699     //
    00700
    00701 TestFailed:
    00702     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    00703            Subtest,
    00704            Fsr.Data,
    00705            SingleResult);
    00706
    00707     return;
    00708 }
    00709
    00710 VOID
    00711 Test4 (
    00712     VOID
    00713     )
    00714
    00715 {
    00716
    00717     ULONG Count;
    00718     FLOATING_STATUS Fsr;
    00719     ULONG SingleResult;
    00720     ULONG Subtest;
    00721
    00722     //
    00723     // Test 4 - Add single round to positive infinity test.
    00724     //
    00725
    00726     Subtest = 0;
    00727     printf("    Test 4 - add single round to positive infinity ...");
    00728     Subtest += 1;
    00729     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00730                          0x1800000,
    00731                          0x7ffff8,
    00732                          &SingleResult);
    00733
    00734     if ((Fsr.Data != ROUND_TO_PLUS_INFINITY) ||
    00735         (SingleResult != 0x19ffffe)) {
    00736         goto TestFailed;
    00737     }
    00738
    00739     Subtest += 1;
    00740     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00741                          0x1800000,
    00742                          0x7ffff9,
    00743                          &SingleResult);
    00744
    00745     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    00746         (SingleResult != 0x19fffff)) {
    00747         goto TestFailed;
    00748     }
    00749
    00750     Subtest += 1;
    00751     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00752                          0x1800000,
    00753                          0x7ffffa,
    00754                          &SingleResult);
    00755
    00756     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    00757         (SingleResult != 0x19fffff)) {
    00758         goto TestFailed;
    00759     }
    00760
    00761     Subtest += 1;
    00762     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00763                          0x1800000,
    00764                          0x7ffffb,
    00765                          &SingleResult);
    00766
    00767     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    00768         (SingleResult != 0x19fffff)) {
    00769         goto TestFailed;
    00770     }
    00771
    00772     Subtest += 1;
    00773     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00774                          0x1800000,
    00775                          0x7ffffc,
    00776                          &SingleResult);
    00777
    00778     if ((Fsr.Data != ROUND_TO_PLUS_INFINITY) ||
    00779         (SingleResult != 0x19fffff)) {
    00780         goto TestFailed;
    00781     }
    00782
    00783     Subtest += 1;
    00784     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00785                          0x1800000,
    00786                          0x7ffffd,
    00787                          &SingleResult);
    00788
    00789     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    00790         (SingleResult != 0x1a00000)) {
    00791         goto TestFailed;
    00792     }
    00793
    00794     Subtest += 1;
    00795     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00796                          0x1800000,
    00797                          0x7ffffe,
    00798                          &SingleResult);
    00799
    00800     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    00801         (SingleResult != 0x1a00000)) {
    00802         goto TestFailed;
    00803     }
    00804
    00805     Subtest += 1;
    00806     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00807                          0x1800000,
    00808                          0x7fffff,
    00809                          &SingleResult);
    00810
    00811     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    00812         (SingleResult != 0x1a00000)) {
    00813         goto TestFailed;
    00814     }
    00815
    00816     Count = 0;
    00817     try {
    00818         Subtest += 1;
    00819         Fsr.Data = AddSingle(EI | ROUND_TO_PLUS_INFINITY,
    00820                              0x1800000,
    00821                              0x7fffff,
    00822                              &SingleResult);
    00823
    00824     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    00825               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00826         Count += 1;
    00827     }
    00828
    00829     if (Count == 0) {
    00830         goto TestFailed;
    00831     }
    00832
    00833     Subtest += 1;
    00834     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00835                          SIGN | 0x1800000,
    00836                          SIGN | 0x7ffff8,
    00837                          &SingleResult);
    00838
    00839     if ((Fsr.Data != ROUND_TO_PLUS_INFINITY) ||
    00840         (SingleResult != (SIGN | 0x19ffffe))) {
    00841         goto TestFailed;
    00842     }
    00843
    00844     Subtest += 1;
    00845     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00846                          SIGN | 0x1800000,
    00847                          SIGN | 0x7ffff9,
    00848                          &SingleResult);
    00849
    00850     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    00851         (SingleResult != (SIGN | 0x19ffffe))) {
    00852         goto TestFailed;
    00853     }
    00854
    00855     Subtest += 1;
    00856     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00857                          SIGN | 0x1800000,
    00858                          SIGN | 0x7ffffa,
    00859                          &SingleResult);
    00860
    00861     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    00862         (SingleResult != (SIGN | 0x19ffffe))) {
    00863         goto TestFailed;
    00864     }
    00865
    00866     Subtest += 1;
    00867     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00868                          SIGN | 0x1800000,
    00869                          SIGN | 0x7ffffb,
    00870                          &SingleResult);
    00871
    00872     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    00873         (SingleResult != (SIGN | 0x19ffffe))) {
    00874         goto TestFailed;
    00875     }
    00876
    00877     Subtest += 1;
    00878     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00879                          SIGN | 0x1800000,
    00880                          SIGN | 0x7ffffc,
    00881                          &SingleResult);
    00882
    00883     if ((Fsr.Data != ROUND_TO_PLUS_INFINITY) ||
    00884         (SingleResult != (SIGN | 0x19fffff))) {
    00885         goto TestFailed;
    00886     }
    00887
    00888     Subtest += 1;
    00889     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00890                          SIGN | 0x1800000,
    00891                          SIGN | 0x7ffffd,
    00892                          &SingleResult);
    00893
    00894     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    00895         (SingleResult != (SIGN | 0x19fffff))) {
    00896         goto TestFailed;
    00897     }
    00898
    00899     Subtest += 1;
    00900     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00901                          SIGN | 0x1800000,
    00902                          SIGN | 0x7ffffe,
    00903                          &SingleResult);
    00904
    00905     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    00906         (SingleResult != (SIGN | 0x19fffff))) {
    00907         goto TestFailed;
    00908     }
    00909
    00910     Subtest += 1;
    00911     Fsr.Data = AddSingle(ROUND_TO_PLUS_INFINITY,
    00912                          SIGN | 0x1800000,
    00913                          SIGN | 0x7fffff,
    00914                          &SingleResult);
    00915
    00916     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    00917         (SingleResult != (SIGN | 0x19fffff))) {
    00918         goto TestFailed;
    00919     }
    00920
    00921     //
    00922     // End of test 4.
    00923     //
    00924
    00925     printf("succeeded\n");
    00926     return;
    00927
    00928     //
    00929     // Test 4 failed.
    00930     //
    00931
    00932 TestFailed:
    00933     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    00934            Subtest,
    00935            Fsr.Data,
    00936            SingleResult);
    00937
    00938     return;
    00939 }
    00940
    00941 VOID
    00942 Test5 (
    00943     VOID
    00944     )
    00945
    00946 {
    00947
    00948     ULONG Count;
    00949     FLOATING_STATUS Fsr;
    00950     ULONG SingleResult;
    00951     ULONG Subtest;
    00952
    00953     //
    00954     // Test 5 - Add single round to negative infinity test.
    00955     //
    00956
    00957     Subtest = 0;
    00958     printf("    Test 5 - add single round to negative infinity ...");
    00959     Subtest += 1;
    00960     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    00961                          SIGN | 0x1800000,
    00962                          SIGN | 0x7ffff8,
    00963                          &SingleResult);
    00964
    00965     if ((Fsr.Data != ROUND_TO_MINUS_INFINITY) ||
    00966         (SingleResult != (SIGN | 0x19ffffe))) {
    00967         goto TestFailed;
    00968     }
    00969
    00970     Subtest += 1;
    00971     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    00972                          SIGN | 0x1800000,
    00973                          SIGN | 0x7ffff9,
    00974                          &SingleResult);
    00975
    00976     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    00977         (SingleResult != (SIGN | 0x19fffff))) {
    00978         goto TestFailed;
    00979     }
    00980
    00981     Subtest += 1;
    00982     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    00983                          SIGN | 0x1800000,
    00984                          SIGN | 0x7ffffa,
    00985                          &SingleResult);
    00986
    00987     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    00988         (SingleResult != (SIGN | 0x19fffff))) {
    00989         goto TestFailed;
    00990     }
    00991
    00992     Subtest += 1;
    00993     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    00994                          SIGN | 0x1800000,
    00995                          SIGN | 0x7ffffb,
    00996                          &SingleResult);
    00997
    00998     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    00999         (SingleResult != (SIGN | 0x19fffff))) {
    01000         goto TestFailed;
    01001     }
    01002
    01003     Subtest += 1;
    01004     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    01005                          SIGN | 0x1800000,
    01006                          SIGN | 0x7ffffc,
    01007                          &SingleResult);
    01008
    01009     if ((Fsr.Data != ROUND_TO_MINUS_INFINITY) ||
    01010         (SingleResult != (SIGN | 0x19fffff))) {
    01011         goto TestFailed;
    01012     }
    01013
    01014     Subtest += 1;
    01015     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    01016                          SIGN | 0x1800000,
    01017                          SIGN | 0x7ffffd,
    01018                          &SingleResult);
    01019
    01020     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    01021         (SingleResult != (SIGN | 0x1a00000))) {
    01022         goto TestFailed;
    01023     }
    01024
    01025     Subtest += 1;
    01026     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    01027                          SIGN | 0x1800000,
    01028                          SIGN | 0x7ffffe,
    01029                          &SingleResult);
    01030
    01031     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    01032         (SingleResult != (SIGN | 0x1a00000))) {
    01033         goto TestFailed;
    01034     }
    01035
    01036     Subtest += 1;
    01037     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    01038                          SIGN | 0x1800000,
    01039                          SIGN | 0x7fffff,
    01040                          &SingleResult);
    01041
    01042     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    01043         (SingleResult != (SIGN | 0x1a00000))) {
    01044         goto TestFailed;
    01045     }
    01046
    01047     Count = 0;
    01048     try {
    01049         Subtest += 1;
    01050         Fsr.Data = AddSingle(EI | ROUND_TO_MINUS_INFINITY,
    01051                              0x1800000,
    01052                              0x7fffff,
    01053                              &SingleResult);
    01054
    01055     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    01056               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01057         Count += 1;
    01058     }
    01059
    01060     if (Count == 0) {
    01061         goto TestFailed;
    01062     }
    01063
    01064     Subtest += 1;
    01065     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    01066                          0x1800000,
    01067                          0x7ffff8,
    01068                          &SingleResult);
    01069
    01070     if ((Fsr.Data != ROUND_TO_MINUS_INFINITY) ||
    01071         (SingleResult != 0x19ffffe)) {
    01072         goto TestFailed;
    01073     }
    01074
    01075     Subtest += 1;
    01076     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    01077                          0x1800000,
    01078                          0x7ffff9,
    01079                          &SingleResult);
    01080
    01081     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    01082         (SingleResult != 0x19ffffe)) {
    01083         goto TestFailed;
    01084     }
    01085
    01086     Subtest += 1;
    01087     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    01088                          0x1800000,
    01089                          0x7ffffa,
    01090                          &SingleResult);
    01091
    01092     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    01093         (SingleResult != 0x19ffffe)) {
    01094         goto TestFailed;
    01095     }
    01096
    01097     Subtest += 1;
    01098     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    01099                          0x1800000,
    01100                          0x7ffffb,
    01101                          &SingleResult);
    01102
    01103     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    01104         (SingleResult != 0x19ffffe)) {
    01105         goto TestFailed;
    01106     }
    01107
    01108     Subtest += 1;
    01109     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    01110                          0x1800000,
    01111                          0x7ffffc,
    01112                          &SingleResult);
    01113
    01114     if ((Fsr.Data != ROUND_TO_MINUS_INFINITY) ||
    01115         (SingleResult != 0x19fffff)) {
    01116         goto TestFailed;
    01117     }
    01118
    01119     Subtest += 1;
    01120     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    01121                          0x1800000,
    01122                          0x7ffffd,
    01123                          &SingleResult);
    01124
    01125     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    01126         (SingleResult != 0x19fffff)) {
    01127         goto TestFailed;
    01128     }
    01129
    01130     Subtest += 1;
    01131     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    01132                          0x1800000,
    01133                          0x7ffffe,
    01134                          &SingleResult);
    01135
    01136     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    01137         (SingleResult != 0x19fffff)) {
    01138         goto TestFailed;
    01139     }
    01140
    01141     Subtest += 1;
    01142     Fsr.Data = AddSingle(ROUND_TO_MINUS_INFINITY,
    01143                          0x1800000,
    01144                          0x7fffff,
    01145                          &SingleResult);
    01146
    01147     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    01148         (SingleResult != 0x19fffff)) {
    01149         goto TestFailed;
    01150     }
    01151
    01152     //
    01153     // End of test 5.
    01154     //
    01155
    01156     printf("succeeded\n");
    01157     return;
    01158
    01159     //
    01160     // Test 5 failed.
    01161     //
    01162
    01163 TestFailed:
    01164     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    01165            Subtest,
    01166            Fsr.Data,
    01167            SingleResult);
    01168
    01169     return;
    01170 }
    01171
    01172 VOID
    01173 Test6 (
    01174     VOID
    01175     )
    01176
    01177 {
    01178
    01179     ULONG Count;
    01180     FLOATING_STATUS Fsr;
    01181     ULONG SingleResult;
    01182     ULONG Subtest;
    01183
    01184     //
    01185     // Test 6 - Add single infinity and NaN test.
    01186     //
    01187
    01188     Subtest = 0;
    01189     printf("    Test 6 - add single infinity and NaN ...");
    01190
    01191     Subtest += 1;
    01192     Fsr.Data = AddSingle(FS | ROUND_TO_NEAREST,
    01193                          0x200000,
    01194                          0x200000,
    01195                          &SingleResult);
    01196
    01197     if ((Fsr.Data != (FS | ROUND_TO_NEAREST)) ||
    01198         (SingleResult != 0x0)) {
    01199         goto TestFailed;
    01200     }
    01201
    01202     Subtest += 1;
    01203     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01204                          0x400000,
    01205                          SINGLE_SIGNAL_NAN_PREFIX,
    01206                          &SingleResult);
    01207
    01208     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01209         (SingleResult != SINGLE_QUIET_NAN)) {
    01210         goto TestFailed;
    01211     }
    01212
    01213     Subtest += 1;
    01214     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01215                          SINGLE_SIGNAL_NAN_PREFIX,
    01216                          0x400000,
    01217                          &SingleResult);
    01218
    01219     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01220         (SingleResult != SINGLE_QUIET_NAN)) {
    01221         goto TestFailed;
    01222     }
    01223
    01224     Subtest += 1;
    01225     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01226                          0x400000,
    01227                          SINGLE_INFINITY_VALUE,
    01228                          &SingleResult);
    01229
    01230     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01231         (SingleResult != SINGLE_INFINITY_VALUE)) {
    01232         goto TestFailed;
    01233     }
    01234
    01235     Subtest += 1;
    01236     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01237                          SIGN | 0x400000,
    01238                          SINGLE_INFINITY_VALUE,
    01239                          &SingleResult);
    01240
    01241     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01242         (SingleResult != SINGLE_INFINITY_VALUE)) {
    01243         goto TestFailed;
    01244     }
    01245
    01246     Subtest += 1;
    01247     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01248                          0x400000,
    01249                          MINUS_SINGLE_INFINITY_VALUE,
    01250                          &SingleResult);
    01251
    01252     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01253         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    01254         goto TestFailed;
    01255     }
    01256
    01257     Subtest += 1;
    01258     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01259                          SIGN | 0x400000,
    01260                          MINUS_SINGLE_INFINITY_VALUE,
    01261                          &SingleResult);
    01262
    01263     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01264         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    01265         goto TestFailed;
    01266     }
    01267
    01268     Subtest += 1;
    01269     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01270                          SINGLE_INFINITY_VALUE,
    01271                          SINGLE_INFINITY_VALUE,
    01272                          &SingleResult);
    01273
    01274     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01275         (SingleResult != SINGLE_INFINITY_VALUE)) {
    01276         goto TestFailed;
    01277     }
    01278
    01279     Subtest += 1;
    01280     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01281                          SINGLE_INFINITY_VALUE,
    01282                          0x3f800000,
    01283                          &SingleResult);
    01284
    01285     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01286         (SingleResult != SINGLE_INFINITY_VALUE)) {
    01287         goto TestFailed;
    01288     }
    01289
    01290     Subtest += 1;
    01291     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01292                          0x3f800000,
    01293                          SINGLE_INFINITY_VALUE,
    01294                          &SingleResult);
    01295
    01296     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01297         (SingleResult != SINGLE_INFINITY_VALUE)) {
    01298         goto TestFailed;
    01299     }
    01300
    01301     Subtest += 1;
    01302     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01303                          MINUS_SINGLE_INFINITY_VALUE,
    01304                          MINUS_SINGLE_INFINITY_VALUE,
    01305                          &SingleResult);
    01306
    01307     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01308         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    01309         goto TestFailed;
    01310     }
    01311
    01312     Subtest += 1;
    01313     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01314                          MINUS_SINGLE_INFINITY_VALUE,
    01315                          0x3f800000,
    01316                          &SingleResult);
    01317
    01318     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01319         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    01320         goto TestFailed;
    01321     }
    01322
    01323     Subtest += 1;
    01324     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01325                          0x3f800000,
    01326                          MINUS_SINGLE_INFINITY_VALUE,
    01327                          &SingleResult);
    01328
    01329     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01330         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    01331         goto TestFailed;
    01332     }
    01333
    01334     Subtest += 1;
    01335     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01336                          SINGLE_INFINITY_VALUE,
    01337                          MINUS_SINGLE_INFINITY_VALUE,
    01338                          &SingleResult);
    01339
    01340     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01341         (SingleResult != SINGLE_QUIET_NAN)) {
    01342         goto TestFailed;
    01343     }
    01344
    01345     Subtest += 1;
    01346     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01347                          MINUS_SINGLE_INFINITY_VALUE,
    01348                          SINGLE_INFINITY_VALUE,
    01349                          &SingleResult);
    01350
    01351     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01352         (SingleResult != SINGLE_QUIET_NAN)) {
    01353         goto TestFailed;
    01354     }
    01355
    01356     Subtest += 1;
    01357     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01358                          SINGLE_QUIET_NAN,
    01359                          SINGLE_QUIET_NAN,
    01360                          &SingleResult);
    01361
    01362     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    01363         (SingleResult != SINGLE_QUIET_NAN)) {
    01364         goto TestFailed;
    01365     }
    01366
    01367     Subtest += 1;
    01368     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01369                          SINGLE_QUIET_NAN,
    01370                          0x3f800000,
    01371                          &SingleResult);
    01372
    01373     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    01374         (SingleResult != SINGLE_QUIET_NAN)) {
    01375         goto TestFailed;
    01376     }
    01377
    01378     Subtest += 1;
    01379     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01380                          0x3f800000,
    01381                          SINGLE_QUIET_NAN,
    01382                          &SingleResult);
    01383
    01384     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    01385         (SingleResult != SINGLE_QUIET_NAN)) {
    01386         goto TestFailed;
    01387     }
    01388
    01389     Subtest += 1;
    01390     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01391                          SINGLE_SIGNAL_NAN,
    01392                          SINGLE_SIGNAL_NAN,
    01393                          &SingleResult);
    01394
    01395     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01396         (SingleResult != SINGLE_QUIET_NAN)) {
    01397         goto TestFailed;
    01398     }
    01399
    01400     Subtest += 1;
    01401     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01402                          SINGLE_SIGNAL_NAN,
    01403                          0x3f800000,
    01404                          &SingleResult);
    01405
    01406     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01407         (SingleResult != SINGLE_QUIET_NAN)) {
    01408         goto TestFailed;
    01409     }
    01410
    01411     Subtest += 1;
    01412     Fsr.Data = AddSingle(ROUND_TO_NEAREST,
    01413                          0x3f800000,
    01414                          SINGLE_SIGNAL_NAN,
    01415                          &SingleResult);
    01416
    01417     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01418         (SingleResult != SINGLE_QUIET_NAN)) {
    01419         goto TestFailed;
    01420     }
    01421
    01422     Subtest += 1;
    01423     try {
    01424         Fsr.Data = AddSingle(EV | ROUND_TO_NEAREST,
    01425                              SINGLE_QUIET_NAN,
    01426                              SINGLE_QUIET_NAN,
    01427                              &SingleResult);
    01428
    01429     } except (EXCEPTION_EXECUTE_HANDLER) {
    01430         goto TestFailed;
    01431     }
    01432
    01433     if ((Fsr.Data != (EV | ROUND_TO_NEAREST)) ||
    01434         (SingleResult != SINGLE_QUIET_NAN)) {
    01435         goto TestFailed;
    01436     }
    01437
    01438     Subtest += 1;
    01439     Count = 0;
    01440     try {
    01441         Fsr.Data = AddSingle(EV | ROUND_TO_NEAREST,
    01442                              SINGLE_QUIET_NAN,
    01443                              SINGLE_SIGNAL_NAN,
    01444                              &SingleResult);
    01445
    01446     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01447               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01448         Count += 1;
    01449     }
    01450
    01451     if (Count != 1) {
    01452         goto TestFailed;
    01453     }
    01454
    01455     Subtest += 1;
    01456     Count = 0;
    01457     try {
    01458         Fsr.Data = AddSingle(EV | ROUND_TO_NEAREST,
    01459                              SINGLE_SIGNAL_NAN,
    01460                              SINGLE_QUIET_NAN,
    01461                              &SingleResult);
    01462
    01463     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01464               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01465         Count += 1;
    01466     }
    01467
    01468     if (Count != 1) {
    01469         goto TestFailed;
    01470     }
    01471
    01472     Subtest += 1;
    01473     Count = 0;
    01474     try {
    01475         Fsr.Data = AddSingle(EV | ROUND_TO_NEAREST,
    01476                              SINGLE_INFINITY_VALUE,
    01477                              MINUS_SINGLE_INFINITY_VALUE,
    01478                              &SingleResult);
    01479
    01480     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01481               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01482         Count += 1;
    01483     }
    01484
    01485     if (Count != 1) {
    01486         goto TestFailed;
    01487     }
    01488
    01489     //
    01490     // End of test 6.
    01491     //
    01492
    01493     printf("succeeded\n");
    01494     return;
    01495
    01496     //
    01497     // Test 6 failed.
    01498     //
    01499
    01500 TestFailed:
    01501     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    01502            Subtest,
    01503            Fsr.Data,
    01504            SingleResult);
    01505
    01506     return;
    01507 }
    01508
    01509 VOID
    01510 Test7 (
    01511     VOID
    01512     )
    01513
    01514 {
    01515
    01516     ULONG Count;
    01517     FLOATING_STATUS Fsr;
    01518     ULONG SingleResult;
    01519     ULONG Subtest;
    01520
    01521     //
    01522     // Test 7 - Multiply test.
    01523     //
    01524
    01525     Subtest = 0;
    01526     printf("    Test 7 - multiply single ...");
    01527     Subtest += 1;
    01528     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01529                               SINGLE_INFINITY_VALUE,
    01530                               SINGLE_INFINITY_VALUE,
    01531                               &SingleResult);
    01532
    01533     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01534         (SingleResult != SINGLE_INFINITY_VALUE)) {
    01535         goto TestFailed;
    01536     }
    01537
    01538     Subtest += 1;
    01539     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01540                               SINGLE_INFINITY_VALUE,
    01541                               MINUS_SINGLE_INFINITY_VALUE,
    01542                               &SingleResult);
    01543
    01544     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01545         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    01546         goto TestFailed;
    01547     }
    01548
    01549     Subtest += 1;
    01550     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01551                               MINUS_SINGLE_INFINITY_VALUE,
    01552                               MINUS_SINGLE_INFINITY_VALUE,
    01553                               &SingleResult);
    01554
    01555     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01556         (SingleResult != SINGLE_INFINITY_VALUE)) {
    01557         goto TestFailed;
    01558     }
    01559
    01560     Subtest += 1;
    01561     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01562                               MINUS_SINGLE_INFINITY_VALUE,
    01563                               SINGLE_INFINITY_VALUE,
    01564                               &SingleResult);
    01565
    01566     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01567         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    01568         goto TestFailed;
    01569     }
    01570
    01571     Subtest += 1;
    01572     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01573                               SINGLE_INFINITY_VALUE,
    01574                               0x0,
    01575                               &SingleResult);
    01576
    01577     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01578         (SingleResult != SINGLE_QUIET_NAN)) {
    01579         goto TestFailed;
    01580     }
    01581
    01582     Subtest += 1;
    01583     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01584                               0x0,
    01585                               SINGLE_INFINITY_VALUE,
    01586                               &SingleResult);
    01587
    01588     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01589         (SingleResult != SINGLE_QUIET_NAN)) {
    01590         goto TestFailed;
    01591     }
    01592
    01593     Subtest += 1;
    01594     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01595                               MINUS_SINGLE_INFINITY_VALUE,
    01596                               0x0,
    01597                               &SingleResult);
    01598
    01599     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01600         (SingleResult != SINGLE_QUIET_NAN)) {
    01601         goto TestFailed;
    01602     }
    01603
    01604     Subtest += 1;
    01605     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01606                               0x0,
    01607                               MINUS_SINGLE_INFINITY_VALUE,
    01608                               &SingleResult);
    01609
    01610     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01611         (SingleResult != SINGLE_QUIET_NAN)) {
    01612         goto TestFailed;
    01613     }
    01614
    01615     Subtest += 1;
    01616     Count = 0;
    01617     try {
    01618         Fsr.Data = MultiplySingle(EV | ROUND_TO_NEAREST,
    01619                                   SINGLE_INFINITY_VALUE,
    01620                                   0x0,
    01621                                   &SingleResult);
    01622
    01623     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01624               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01625         Count += 1;
    01626     }
    01627
    01628     if (Count == 0) {
    01629         goto TestFailed;
    01630     }
    01631
    01632     Subtest += 1;
    01633     Count = 0;
    01634     try {
    01635         Fsr.Data = MultiplySingle(EV | ROUND_TO_NEAREST,
    01636                                   0x0,
    01637                                   SINGLE_INFINITY_VALUE,
    01638                                   &SingleResult);
    01639
    01640     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01641               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01642         Count += 1;
    01643     }
    01644
    01645     if (Count == 0) {
    01646         goto TestFailed;
    01647     }
    01648
    01649     Subtest += 1;
    01650     Count = 0;
    01651     try {
    01652         Fsr.Data = MultiplySingle(EV | ROUND_TO_NEAREST,
    01653                                   MINUS_SINGLE_INFINITY_VALUE,
    01654                                   0x0,
    01655                                   &SingleResult);
    01656
    01657     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01658               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01659         Count += 1;
    01660     }
    01661
    01662     if (Count == 0) {
    01663         goto TestFailed;
    01664     }
    01665
    01666     Subtest += 1;
    01667     Count = 0;
    01668     try {
    01669         Fsr.Data = MultiplySingle(EV | ROUND_TO_NEAREST,
    01670                                   0x0,
    01671                                   MINUS_SINGLE_INFINITY_VALUE,
    01672                                   &SingleResult);
    01673
    01674     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01675               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01676         Count += 1;
    01677     }
    01678
    01679     if (Count == 0) {
    01680         goto TestFailed;
    01681     }
    01682
    01683     Subtest += 1;
    01684     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01685                               SINGLE_QUIET_NAN,
    01686                               SINGLE_QUIET_NAN,
    01687                               &SingleResult);
    01688
    01689     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    01690         (SingleResult != SINGLE_QUIET_NAN)) {
    01691         goto TestFailed;
    01692     }
    01693
    01694     Subtest += 1;
    01695     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01696                               SINGLE_QUIET_NAN,
    01697                               0x3f800000,
    01698                               &SingleResult);
    01699
    01700     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    01701         (SingleResult != SINGLE_QUIET_NAN)) {
    01702         goto TestFailed;
    01703     }
    01704
    01705     Subtest += 1;
    01706     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01707                               0x3f800000,
    01708                               SINGLE_QUIET_NAN,
    01709                               &SingleResult);
    01710
    01711     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    01712         (SingleResult != SINGLE_QUIET_NAN)) {
    01713         goto TestFailed;
    01714     }
    01715
    01716     Subtest += 1;
    01717     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01718                               SINGLE_SIGNAL_NAN,
    01719                               SINGLE_SIGNAL_NAN,
    01720                               &SingleResult);
    01721
    01722     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01723         (SingleResult != SINGLE_QUIET_NAN)) {
    01724         goto TestFailed;
    01725     }
    01726
    01727     Subtest += 1;
    01728     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01729                               SINGLE_SIGNAL_NAN,
    01730                               0x3f800000,
    01731                               &SingleResult);
    01732
    01733     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01734         (SingleResult != SINGLE_QUIET_NAN)) {
    01735         goto TestFailed;
    01736     }
    01737
    01738     Subtest += 1;
    01739     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01740                               0x3f800000,
    01741                               SINGLE_SIGNAL_NAN,
    01742                               &SingleResult);
    01743
    01744     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01745         (SingleResult != SINGLE_QUIET_NAN)) {
    01746         goto TestFailed;
    01747     }
    01748
    01749     Subtest += 1;
    01750     try {
    01751         Fsr.Data = MultiplySingle(EV | ROUND_TO_NEAREST,
    01752                                   SINGLE_QUIET_NAN,
    01753                                   SINGLE_QUIET_NAN,
    01754                                   &SingleResult);
    01755
    01756     } except (EXCEPTION_EXECUTE_HANDLER) {
    01757         goto TestFailed;
    01758     }
    01759
    01760     if ((Fsr.Data != (EV | ROUND_TO_NEAREST)) ||
    01761         (SingleResult != SINGLE_QUIET_NAN)) {
    01762         goto TestFailed;
    01763     }
    01764
    01765     Subtest += 1;
    01766     Count = 0;
    01767     try {
    01768         Fsr.Data = MultiplySingle(EV | ROUND_TO_NEAREST,
    01769                                   SINGLE_QUIET_NAN,
    01770                                   SINGLE_SIGNAL_NAN,
    01771                                   &SingleResult);
    01772
    01773     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01774               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01775         Count += 1;
    01776     }
    01777
    01778     if (Count != 1) {
    01779         goto TestFailed;
    01780     }
    01781
    01782     Subtest += 1;
    01783     Count = 0;
    01784     try {
    01785         Fsr.Data = MultiplySingle(EV | ROUND_TO_NEAREST,
    01786                                   SINGLE_SIGNAL_NAN,
    01787                                   SINGLE_QUIET_NAN,
    01788                                   &SingleResult);
    01789
    01790     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01791               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01792         Count += 1;
    01793     }
    01794
    01795     if (Count != 1) {
    01796         goto TestFailed;
    01797     }
    01798
    01799     Subtest += 1;
    01800     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01801                               0x7f000000,
    01802                               0x400000,
    01803                               &SingleResult);
    01804
    01805     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01806         (SingleResult != 0x3f800000)) {
    01807         goto TestFailed;
    01808     }
    01809
    01810     Subtest += 1;
    01811     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01812                               0x400000,
    01813                               0x7f000000,
    01814                               &SingleResult);
    01815
    01816     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01817         (SingleResult != 0x3f800000)) {
    01818         goto TestFailed;
    01819     }
    01820
    01821     Subtest += 1;
    01822     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01823                               0x7f000000,
    01824                               SIGN | 0x400000,
    01825                               &SingleResult);
    01826
    01827     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01828         (SingleResult != (SIGN | 0x3f800000))) {
    01829         goto TestFailed;
    01830     }
    01831
    01832     Subtest += 1;
    01833     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01834                               0x400000,
    01835                               SIGN | 0x7f000000,
    01836                               &SingleResult);
    01837
    01838     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01839         (SingleResult != (SIGN | 0x3f800000))) {
    01840         goto TestFailed;
    01841     }
    01842
    01843     Subtest += 1;
    01844     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01845                               0x400004,
    01846                               0x7f000001,
    01847                               &SingleResult);
    01848
    01849     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    01850         (SingleResult != 0x3f800009)) {
    01851         goto TestFailed;
    01852     }
    01853
    01854     Subtest += 1;
    01855     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01856                               0x400004,
    01857                               SIGN | 0x7f000001,
    01858                               &SingleResult);
    01859
    01860     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    01861         (SingleResult != (SIGN | 0x3f800009))) {
    01862         goto TestFailed;
    01863     }
    01864
    01865     Subtest += 1;
    01866     Count = 0;
    01867     try {
    01868         Fsr.Data = MultiplySingle(EI | ROUND_TO_NEAREST,
    01869                                   0x400004,
    01870                                   0x7f000001,
    01871                                   &SingleResult);
    01872
    01873     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    01874               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01875         Count += 1;
    01876     }
    01877
    01878     if (Count != 1) {
    01879         goto TestFailed;
    01880     }
    01881
    01882     Subtest += 1;
    01883     Count = 0;
    01884     try {
    01885         Fsr.Data = MultiplySingle(EI | ROUND_TO_NEAREST,
    01886                                   0x400004,
    01887                                   SIGN | 0x7f000001,
    01888                                   &SingleResult);
    01889
    01890     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    01891               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01892         Count += 1;
    01893     }
    01894
    01895     if (Count != 1) {
    01896         goto TestFailed;
    01897     }
    01898
    01899     Subtest += 1;
    01900     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01901                               0x400000,
    01902                               0x400000,
    01903                               &SingleResult);
    01904
    01905     if ((Fsr.Data != (SU | SI | ROUND_TO_NEAREST)) ||
    01906         (SingleResult != 0x0)) {
    01907         goto TestFailed;
    01908     }
    01909
    01910     Subtest += 1;
    01911     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    01912                               0x400000,
    01913                               SIGN | 0x400000,
    01914                               &SingleResult);
    01915
    01916     if ((Fsr.Data != (SU | SI | ROUND_TO_NEAREST)) ||
    01917         (SingleResult != (SIGN | 0x0))) {
    01918         goto TestFailed;
    01919     }
    01920
    01921     Subtest += 1;
    01922     Count = 0;
    01923     try {
    01924         Fsr.Data = MultiplySingle(EI | ROUND_TO_NEAREST,
    01925                                   0x400000,
    01926                                   0x400000,
    01927                                   &SingleResult);
    01928
    01929     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    01930               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01931         Count += 1;
    01932     }
    01933
    01934     if (Count != 1) {
    01935         goto TestFailed;
    01936     }
    01937
    01938     Subtest += 1;
    01939     Count = 0;
    01940     try {
    01941         Fsr.Data = MultiplySingle(EI | ROUND_TO_NEAREST,
    01942                                   0x400000,
    01943                                   SIGN | 0x400000,
    01944                                   &SingleResult);
    01945
    01946     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    01947               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01948         Count += 1;
    01949     }
    01950
    01951     if (Count != 1) {
    01952         goto TestFailed;
    01953     }
    01954
    01955     Subtest += 1;
    01956     Count = 0;
    01957     try {
    01958         Fsr.Data = MultiplySingle(EU | ROUND_TO_NEAREST,
    01959                                   0x400000,
    01960                                   0x400000,
    01961                                   &SingleResult);
    01962
    01963     } except ((GetExceptionCode() == STATUS_FLOAT_UNDERFLOW) ?
    01964               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01965         Count += 1;
    01966     }
    01967
    01968     if (Count != 1) {
    01969         goto TestFailed;
    01970     }
    01971
    01972     Subtest += 1;
    01973     Count = 0;
    01974     try {
    01975         Fsr.Data = MultiplySingle(EU | ROUND_TO_NEAREST,
    01976                                   0x400000,
    01977                                   SIGN | 0x400000,
    01978                                   &SingleResult);
    01979
    01980     } except ((GetExceptionCode() == STATUS_FLOAT_UNDERFLOW) ?
    01981               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01982         Count += 1;
    01983     }
    01984
    01985     if (Count != 1) {
    01986         goto TestFailed;
    01987     }
    01988
    01989     Subtest += 1;
    01990     Count = 0;
    01991     try {
    01992         Fsr.Data = MultiplySingle(EU | EI | ROUND_TO_NEAREST,
    01993                                   0x400000,
    01994                                   0x400000,
    01995                                   &SingleResult);
    01996
    01997     } except ((GetExceptionCode() == STATUS_FLOAT_UNDERFLOW) ?
    01998               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01999         Count += 1;
    02000     }
    02001
    02002     if (Count != 1) {
    02003         goto TestFailed;
    02004     }
    02005
    02006     Subtest += 1;
    02007     Count = 0;
    02008     try {
    02009         Fsr.Data = MultiplySingle(EU | EI | ROUND_TO_NEAREST,
    02010                                   0x400000,
    02011                                   SIGN | 0x400000,
    02012                                   &SingleResult);
    02013
    02014     } except ((GetExceptionCode() == STATUS_FLOAT_UNDERFLOW) ?
    02015               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02016         Count += 1;
    02017     }
    02018
    02019     if (Count != 1) {
    02020         goto TestFailed;
    02021     }
    02022
    02023     Subtest += 1;
    02024     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    02025                               SINGLE_MAXIMUM_VALUE,
    02026                               SINGLE_MAXIMUM_VALUE,
    02027                               &SingleResult);
    02028
    02029     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_NEAREST)) ||
    02030         (SingleResult != SINGLE_INFINITY_VALUE)) {
    02031         goto TestFailed;
    02032     }
    02033
    02034     Subtest += 1;
    02035     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    02036                               SIGN | SINGLE_MAXIMUM_VALUE,
    02037                               SINGLE_MAXIMUM_VALUE,
    02038                               &SingleResult);
    02039
    02040     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_NEAREST)) ||
    02041         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    02042         goto TestFailed;
    02043     }
    02044
    02045     Subtest += 1;
    02046     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    02047                               SINGLE_MAXIMUM_VALUE,
    02048                               SIGN | SINGLE_MAXIMUM_VALUE,
    02049                               &SingleResult);
    02050
    02051     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_NEAREST)) ||
    02052         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    02053         goto TestFailed;
    02054     }
    02055
    02056     Subtest += 1;
    02057     Fsr.Data = MultiplySingle(ROUND_TO_NEAREST,
    02058                               SIGN | SINGLE_MAXIMUM_VALUE,
    02059                               SIGN | SINGLE_MAXIMUM_VALUE,
    02060                               &SingleResult);
    02061
    02062     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_NEAREST)) ||
    02063         (SingleResult != SINGLE_INFINITY_VALUE)) {
    02064         goto TestFailed;
    02065     }
    02066
    02067     Subtest += 1;
    02068     Fsr.Data = MultiplySingle(ROUND_TO_ZERO,
    02069                               SINGLE_MAXIMUM_VALUE,
    02070                               SINGLE_MAXIMUM_VALUE,
    02071                               &SingleResult);
    02072
    02073     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_ZERO)) ||
    02074         (SingleResult != SINGLE_MAXIMUM_VALUE)) {
    02075         goto TestFailed;
    02076     }
    02077
    02078     Subtest += 1;
    02079     Fsr.Data = MultiplySingle(ROUND_TO_ZERO,
    02080                               SIGN | SINGLE_MAXIMUM_VALUE,
    02081                               SINGLE_MAXIMUM_VALUE,
    02082                               &SingleResult);
    02083
    02084     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_ZERO)) ||
    02085         (SingleResult != (SIGN | SINGLE_MAXIMUM_VALUE))) {
    02086         goto TestFailed;
    02087     }
    02088
    02089     Subtest += 1;
    02090     Fsr.Data = MultiplySingle(ROUND_TO_ZERO,
    02091                               SINGLE_MAXIMUM_VALUE,
    02092                               SIGN | SINGLE_MAXIMUM_VALUE,
    02093                               &SingleResult);
    02094
    02095     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_ZERO)) ||
    02096         (SingleResult != (SIGN | SINGLE_MAXIMUM_VALUE))) {
    02097         goto TestFailed;
    02098     }
    02099
    02100     Subtest += 1;
    02101     Fsr.Data = MultiplySingle(ROUND_TO_ZERO,
    02102                               SIGN | SINGLE_MAXIMUM_VALUE,
    02103                               SIGN | SINGLE_MAXIMUM_VALUE,
    02104                               &SingleResult);
    02105
    02106     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_ZERO)) ||
    02107         (SingleResult != SINGLE_MAXIMUM_VALUE)) {
    02108         goto TestFailed;
    02109     }
    02110
    02111     Subtest += 1;
    02112     Fsr.Data = MultiplySingle(ROUND_TO_PLUS_INFINITY,
    02113                               SINGLE_MAXIMUM_VALUE,
    02114                               SINGLE_MAXIMUM_VALUE,
    02115                               &SingleResult);
    02116
    02117     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_PLUS_INFINITY)) ||
    02118         (SingleResult != SINGLE_INFINITY_VALUE)) {
    02119         goto TestFailed;
    02120     }
    02121
    02122     Subtest += 1;
    02123     Fsr.Data = MultiplySingle(ROUND_TO_PLUS_INFINITY,
    02124                               SIGN | SINGLE_MAXIMUM_VALUE,
    02125                               SINGLE_MAXIMUM_VALUE,
    02126                               &SingleResult);
    02127
    02128     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_PLUS_INFINITY)) ||
    02129         (SingleResult != (SIGN | SINGLE_MAXIMUM_VALUE))) {
    02130         goto TestFailed;
    02131     }
    02132
    02133     Subtest += 1;
    02134     Fsr.Data = MultiplySingle(ROUND_TO_PLUS_INFINITY,
    02135                               SINGLE_MAXIMUM_VALUE,
    02136                               SIGN | SINGLE_MAXIMUM_VALUE,
    02137                               &SingleResult);
    02138
    02139     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_PLUS_INFINITY)) ||
    02140         (SingleResult != (SIGN | SINGLE_MAXIMUM_VALUE))) {
    02141         goto TestFailed;
    02142     }
    02143
    02144     Subtest += 1;
    02145     Fsr.Data = MultiplySingle(ROUND_TO_PLUS_INFINITY,
    02146                               SIGN | SINGLE_MAXIMUM_VALUE,
    02147                               SIGN | SINGLE_MAXIMUM_VALUE,
    02148                               &SingleResult);
    02149
    02150     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_PLUS_INFINITY)) ||
    02151         (SingleResult != SINGLE_INFINITY_VALUE)) {
    02152         goto TestFailed;
    02153     }
    02154
    02155     Subtest += 1;
    02156     Fsr.Data = MultiplySingle(ROUND_TO_MINUS_INFINITY,
    02157                               SINGLE_MAXIMUM_VALUE,
    02158                               SINGLE_MAXIMUM_VALUE,
    02159                               &SingleResult);
    02160
    02161     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_MINUS_INFINITY)) ||
    02162         (SingleResult != SINGLE_MAXIMUM_VALUE)) {
    02163         goto TestFailed;
    02164     }
    02165
    02166     Subtest += 1;
    02167     Fsr.Data = MultiplySingle(ROUND_TO_MINUS_INFINITY,
    02168                               SIGN | SINGLE_MAXIMUM_VALUE,
    02169                               SINGLE_MAXIMUM_VALUE,
    02170                               &SingleResult);
    02171
    02172     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_MINUS_INFINITY)) ||
    02173         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    02174         goto TestFailed;
    02175     }
    02176
    02177     Subtest += 1;
    02178     Fsr.Data = MultiplySingle(ROUND_TO_MINUS_INFINITY,
    02179                               SINGLE_MAXIMUM_VALUE,
    02180                               SIGN | SINGLE_MAXIMUM_VALUE,
    02181                               &SingleResult);
    02182
    02183     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_MINUS_INFINITY)) ||
    02184         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    02185         goto TestFailed;
    02186     }
    02187
    02188     Subtest += 1;
    02189     Fsr.Data = MultiplySingle(ROUND_TO_MINUS_INFINITY,
    02190                               SIGN | SINGLE_MAXIMUM_VALUE,
    02191                               SIGN | SINGLE_MAXIMUM_VALUE,
    02192                               &SingleResult);
    02193
    02194     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_MINUS_INFINITY)) ||
    02195         (SingleResult != SINGLE_MAXIMUM_VALUE)) {
    02196         goto TestFailed;
    02197     }
    02198
    02199     Subtest += 1;
    02200     Count = 0;
    02201     try {
    02202         Fsr.Data = MultiplySingle(EI | ROUND_TO_NEAREST,
    02203                                   SINGLE_MAXIMUM_VALUE,
    02204                                   SINGLE_MAXIMUM_VALUE,
    02205                                   &SingleResult);
    02206
    02207     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    02208               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02209         Count += 1;
    02210     }
    02211
    02212     if (Count != 1) {
    02213         goto TestFailed;
    02214     }
    02215
    02216     Subtest += 1;
    02217     Count = 0;
    02218     try {
    02219         Fsr.Data = MultiplySingle(EI | ROUND_TO_NEAREST,
    02220                                   SINGLE_MAXIMUM_VALUE,
    02221                                   SIGN | SINGLE_MAXIMUM_VALUE,
    02222                                   &SingleResult);
    02223
    02224     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    02225               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02226         Count += 1;
    02227     }
    02228
    02229     if (Count != 1) {
    02230         goto TestFailed;
    02231     }
    02232
    02233     Subtest += 1;
    02234     Count = 0;
    02235     try {
    02236         Fsr.Data = MultiplySingle(EO | ROUND_TO_NEAREST,
    02237                                   SINGLE_MAXIMUM_VALUE,
    02238                                   SINGLE_MAXIMUM_VALUE,
    02239                                   &SingleResult);
    02240
    02241     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    02242               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02243         Count += 1;
    02244     }
    02245
    02246     if (Count != 1) {
    02247         goto TestFailed;
    02248     }
    02249
    02250     Subtest += 1;
    02251     Count = 0;
    02252     try {
    02253         Fsr.Data = MultiplySingle(EO | ROUND_TO_NEAREST,
    02254                                   SINGLE_MAXIMUM_VALUE,
    02255                                   SIGN | SINGLE_MAXIMUM_VALUE,
    02256                                   &SingleResult);
    02257
    02258     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    02259               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02260         Count += 1;
    02261     }
    02262
    02263     if (Count != 1) {
    02264         goto TestFailed;
    02265     }
    02266
    02267     Subtest += 1;
    02268     Count = 0;
    02269     try {
    02270         Fsr.Data = MultiplySingle(EO | EI | ROUND_TO_NEAREST,
    02271                                   SINGLE_MAXIMUM_VALUE,
    02272                                   SINGLE_MAXIMUM_VALUE,
    02273                                   &SingleResult);
    02274
    02275     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    02276               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02277         Count += 1;
    02278     }
    02279
    02280     if (Count != 1) {
    02281         goto TestFailed;
    02282     }
    02283
    02284     Subtest += 1;
    02285     Count = 0;
    02286     try {
    02287         Fsr.Data = MultiplySingle(EO | EI | ROUND_TO_NEAREST,
    02288                                   SINGLE_MAXIMUM_VALUE,
    02289                                   SIGN | SINGLE_MAXIMUM_VALUE,
    02290                                   &SingleResult);
    02291
    02292     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    02293               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02294         Count += 1;
    02295     }
    02296
    02297     if (Count != 1) {
    02298         goto TestFailed;
    02299     }
    02300
    02301     //
    02302     // End of test 7.
    02303     //
    02304
    02305     printf("succeeded\n");
    02306     return;
    02307
    02308     //
    02309     // Test 7 failed.
    02310     //
    02311
    02312 TestFailed:
    02313     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    02314            Subtest,
    02315            Fsr.Data,
    02316            SingleResult);
    02317
    02318     return;
    02319 }
    02320
    02321 VOID
    02322 Test8 (
    02323     VOID
    02324     )
    02325
    02326 {
    02327
    02328     ULONG Count;
    02329     FLOATING_STATUS Fsr;
    02330     ULONG SingleResult;
    02331     ULONG Subtest;
    02332
    02333     //
    02334     // Test 8 - Divide test.
    02335     //
    02336
    02337     Subtest = 0;
    02338     printf("    Test 8 - divide single ...");
    02339     Subtest += 1;
    02340     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02341                             SINGLE_INFINITY_VALUE,
    02342                             SINGLE_INFINITY_VALUE,
    02343                             &SingleResult);
    02344
    02345     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02346         (SingleResult != SINGLE_QUIET_NAN)) {
    02347         goto TestFailed;
    02348     }
    02349
    02350     Subtest += 1;
    02351     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02352                             SINGLE_INFINITY_VALUE,
    02353                             MINUS_SINGLE_INFINITY_VALUE,
    02354                             &SingleResult);
    02355
    02356     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02357         (SingleResult != SINGLE_QUIET_NAN)) {
    02358         goto TestFailed;
    02359     }
    02360
    02361     Subtest += 1;
    02362     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02363                             MINUS_SINGLE_INFINITY_VALUE,
    02364                             MINUS_SINGLE_INFINITY_VALUE,
    02365                             &SingleResult);
    02366
    02367     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02368         (SingleResult != SINGLE_QUIET_NAN)) {
    02369         goto TestFailed;
    02370     }
    02371
    02372     Subtest += 1;
    02373     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02374                             MINUS_SINGLE_INFINITY_VALUE,
    02375                             SINGLE_INFINITY_VALUE,
    02376                             &SingleResult);
    02377
    02378     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02379         (SingleResult != SINGLE_QUIET_NAN)) {
    02380         goto TestFailed;
    02381     }
    02382
    02383     Subtest += 1;
    02384     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02385                             0x0,
    02386                             0x0,
    02387                             &SingleResult);
    02388
    02389     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02390         (SingleResult != SINGLE_QUIET_NAN)) {
    02391         goto TestFailed;
    02392     }
    02393
    02394     Subtest += 1;
    02395     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02396                             0x0,
    02397                             SIGN | 0x0,
    02398                             &SingleResult);
    02399
    02400     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02401         (SingleResult != SINGLE_QUIET_NAN)) {
    02402         goto TestFailed;
    02403     }
    02404
    02405     Subtest += 1;
    02406     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02407                             SIGN | 0x0,
    02408                             SIGN | 0x0,
    02409                             &SingleResult);
    02410
    02411     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02412         (SingleResult != SINGLE_QUIET_NAN)) {
    02413         goto TestFailed;
    02414     }
    02415
    02416     Subtest += 1;
    02417     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02418                             SIGN | 0x0,
    02419                             0x0,
    02420                             &SingleResult);
    02421
    02422     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02423         (SingleResult != SINGLE_QUIET_NAN)) {
    02424         goto TestFailed;
    02425     }
    02426
    02427     Subtest += 1;
    02428     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02429                             SINGLE_INFINITY_VALUE,
    02430                             0x0,
    02431                             &SingleResult);
    02432
    02433     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02434         (SingleResult != SINGLE_INFINITY_VALUE)) {
    02435         goto TestFailed;
    02436     }
    02437
    02438     Subtest += 1;
    02439     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02440                             0x3f800000,
    02441                             0x0,
    02442                             &SingleResult);
    02443
    02444     if ((Fsr.Data != (SZ | XZ | ROUND_TO_NEAREST)) ||
    02445         (SingleResult != SINGLE_INFINITY_VALUE)) {
    02446         goto TestFailed;
    02447     }
    02448
    02449
    02450     Subtest += 1;
    02451     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02452                             MINUS_SINGLE_INFINITY_VALUE,
    02453                             0x0,
    02454                             &SingleResult);
    02455
    02456     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02457         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    02458         goto TestFailed;
    02459     }
    02460
    02461     Subtest += 1;
    02462     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02463                             SIGN | 0x3f80000,
    02464                             0x0,
    02465                             &SingleResult);
    02466
    02467     if ((Fsr.Data != (SZ | XZ | ROUND_TO_NEAREST)) ||
    02468         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    02469         goto TestFailed;
    02470     }
    02471
    02472     Subtest += 1;
    02473     Count = 0;
    02474     try {
    02475         Fsr.Data = DivideSingle(EV | ROUND_TO_NEAREST,
    02476                                 SINGLE_INFINITY_VALUE,
    02477                                 SINGLE_INFINITY_VALUE,
    02478                                 &SingleResult);
    02479
    02480     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    02481               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02482         Count += 1;
    02483     }
    02484
    02485     if (Count == 0) {
    02486         goto TestFailed;
    02487     }
    02488
    02489     Subtest += 1;
    02490     Count = 0;
    02491     try {
    02492         Fsr.Data = DivideSingle(EV | ROUND_TO_NEAREST,
    02493                                 0x0,
    02494                                 0x0,
    02495                                 &SingleResult);
    02496
    02497     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    02498               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02499         Count += 1;
    02500     }
    02501
    02502     if (Count == 0) {
    02503         goto TestFailed;
    02504     }
    02505
    02506     Subtest += 1;
    02507     Count = 0;
    02508     try {
    02509         Fsr.Data = DivideSingle(EZ | ROUND_TO_NEAREST,
    02510                                 0x3f800000,
    02511                                 0x0,
    02512                                 &SingleResult);
    02513
    02514     } except ((GetExceptionCode() == STATUS_FLOAT_DIVIDE_BY_ZERO) ?
    02515               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02516         Count += 1;
    02517     }
    02518
    02519     if (Count == 0) {
    02520         goto TestFailed;
    02521     }
    02522
    02523     Subtest += 1;
    02524     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02525                             SINGLE_QUIET_NAN,
    02526                             SINGLE_QUIET_NAN,
    02527                             &SingleResult);
    02528
    02529     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    02530         (SingleResult != SINGLE_QUIET_NAN)) {
    02531         goto TestFailed;
    02532     }
    02533
    02534     Subtest += 1;
    02535     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02536                             SINGLE_QUIET_NAN,
    02537                             0x3f800000,
    02538                             &SingleResult);
    02539
    02540     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    02541         (SingleResult != SINGLE_QUIET_NAN)) {
    02542         goto TestFailed;
    02543     }
    02544
    02545     Subtest += 1;
    02546     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02547                             0x3f800000,
    02548                             SINGLE_QUIET_NAN,
    02549                             &SingleResult);
    02550
    02551     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    02552         (SingleResult != SINGLE_QUIET_NAN)) {
    02553         goto TestFailed;
    02554     }
    02555
    02556     Subtest += 1;
    02557     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02558                             SINGLE_SIGNAL_NAN,
    02559                             SINGLE_SIGNAL_NAN,
    02560                             &SingleResult);
    02561
    02562     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02563         (SingleResult != SINGLE_QUIET_NAN)) {
    02564         goto TestFailed;
    02565     }
    02566
    02567     Subtest += 1;
    02568     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02569                             SINGLE_SIGNAL_NAN,
    02570                             0x3f800000,
    02571                             &SingleResult);
    02572
    02573     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02574         (SingleResult != SINGLE_QUIET_NAN)) {
    02575         goto TestFailed;
    02576     }
    02577
    02578     Subtest += 1;
    02579     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02580                             0x3f800000,
    02581                             SINGLE_SIGNAL_NAN,
    02582                             &SingleResult);
    02583
    02584     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02585         (SingleResult != SINGLE_QUIET_NAN)) {
    02586         goto TestFailed;
    02587     }
    02588
    02589     Subtest += 1;
    02590     try {
    02591         Fsr.Data = DivideSingle(EV | ROUND_TO_NEAREST,
    02592                                 SINGLE_QUIET_NAN,
    02593                                 SINGLE_QUIET_NAN,
    02594                                 &SingleResult);
    02595
    02596     } except (EXCEPTION_EXECUTE_HANDLER) {
    02597         goto TestFailed;
    02598     }
    02599
    02600     if ((Fsr.Data != (EV | ROUND_TO_NEAREST)) ||
    02601         (SingleResult != SINGLE_QUIET_NAN)) {
    02602         goto TestFailed;
    02603     }
    02604
    02605     Subtest += 1;
    02606     Count = 0;
    02607     try {
    02608         Fsr.Data = DivideSingle(EV | ROUND_TO_NEAREST,
    02609                                 SINGLE_QUIET_NAN,
    02610                                 SINGLE_SIGNAL_NAN,
    02611                                 &SingleResult);
    02612
    02613     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    02614               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02615         Count += 1;
    02616     }
    02617
    02618     if (Count != 1) {
    02619         goto TestFailed;
    02620     }
    02621
    02622     Subtest += 1;
    02623     Count = 0;
    02624     try {
    02625         Fsr.Data = DivideSingle(EV | ROUND_TO_NEAREST,
    02626                                 SINGLE_SIGNAL_NAN,
    02627                                 SINGLE_QUIET_NAN,
    02628                                 &SingleResult);
    02629
    02630     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    02631               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02632         Count += 1;
    02633     }
    02634
    02635     if (Count != 1) {
    02636         goto TestFailed;
    02637     }
    02638
    02639     Subtest += 1;
    02640     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02641                             0x400000,
    02642                             SINGLE_INFINITY_VALUE,
    02643                             &SingleResult);
    02644
    02645     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02646         (SingleResult != 0x0)) {
    02647         goto TestFailed;
    02648     }
    02649
    02650     Subtest += 1;
    02651     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02652                             SIGN | 0x400000,
    02653                             SINGLE_INFINITY_VALUE,
    02654                             &SingleResult);
    02655
    02656     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02657         (SingleResult != (SIGN | 0x0))) {
    02658         goto TestFailed;
    02659     }
    02660
    02661     Subtest += 1;
    02662     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02663                             0x400000,
    02664                             MINUS_SINGLE_INFINITY_VALUE,
    02665                             &SingleResult);
    02666
    02667     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02668         (SingleResult != (SIGN | 0x0))) {
    02669         goto TestFailed;
    02670     }
    02671
    02672     Subtest += 1;
    02673     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02674                             SIGN | 0x400000,
    02675                             MINUS_SINGLE_INFINITY_VALUE,
    02676                             &SingleResult);
    02677
    02678     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02679         (SingleResult != 0x0)) {
    02680         goto TestFailed;
    02681     }
    02682
    02683     Subtest += 1;
    02684     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02685                             0x400000,
    02686                             0x400000,
    02687                             &SingleResult);
    02688
    02689     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02690         (SingleResult != 0x3f800000)) {
    02691         goto TestFailed;
    02692     }
    02693
    02694     Subtest += 1;
    02695     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02696                             SIGN | 0x400000,
    02697                             0x400000,
    02698                             &SingleResult);
    02699
    02700     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02701         (SingleResult != (SIGN | 0x3f800000))) {
    02702         goto TestFailed;
    02703     }
    02704
    02705     Subtest += 1;
    02706     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02707                             0x400000,
    02708                             SIGN | 0x400000,
    02709                             &SingleResult);
    02710
    02711     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02712         (SingleResult != (SIGN | 0x3f800000))) {
    02713         goto TestFailed;
    02714     }
    02715
    02716     Subtest += 1;
    02717     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02718                             SIGN | 0x400000,
    02719                             SIGN | 0x400000,
    02720                             &SingleResult);
    02721
    02722     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02723         (SingleResult != 0x3f800000)) {
    02724         goto TestFailed;
    02725     }
    02726
    02727     Subtest += 1;
    02728     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02729                             0x3f800000,
    02730                             0x400000,
    02731                             &SingleResult);
    02732
    02733     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02734         (SingleResult != 0x7f000000)) {
    02735         goto TestFailed;
    02736     }
    02737
    02738     Subtest += 1;
    02739     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02740                             0x40000000,
    02741                             0x400000,
    02742                             &SingleResult);
    02743
    02744     if ((Fsr.Data != (SO | SI | ROUND_TO_NEAREST)) ||
    02745         (SingleResult != SINGLE_INFINITY_VALUE)) {
    02746         goto TestFailed;
    02747     }
    02748
    02749     Subtest += 1;
    02750     Fsr.Data = DivideSingle(ROUND_TO_NEAREST,
    02751                             0x3fffffff,
    02752                             0x400000,
    02753                             &SingleResult);
    02754
    02755     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02756         (SingleResult != 0x7f7fffff)) {
    02757         goto TestFailed;
    02758     }
    02759
    02760     //
    02761     // End of test 8.
    02762     //
    02763
    02764     printf("succeeded\n");
    02765     return;
    02766
    02767     //
    02768     // Test 8 failed.
    02769     //
    02770
    02771 TestFailed:
    02772     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    02773            Subtest,
    02774            Fsr.Data,
    02775            SingleResult);
    02776
    02777     return;
    02778 }
    02779
    02780 VOID
    02781 Test9 (
    02782     VOID
    02783     )
    02784
    02785 {
    02786
    02787     ULONG Count;
    02788     FLOATING_STATUS Fsr;
    02789     ULONG Subtest;
    02790
    02791     //
    02792     // Test 9 - Compare single test.
    02793     //
    02794
    02795     Subtest = 0;
    02796     printf("    Test 9 - compare single ...");
    02797
    02798 // ****** //
    02799
    02800     Subtest += 1;
    02801     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    02802                                0x0,
    02803                                0x400000);
    02804
    02805     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02806         goto TestFailed;
    02807     }
    02808
    02809     Subtest += 1;
    02810     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    02811                                SIGN | 0x0,
    02812                                0x400000);
    02813
    02814     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02815         goto TestFailed;
    02816     }
    02817
    02818     Subtest += 1;
    02819     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    02820                                0x400000,
    02821                                0x0);
    02822
    02823     if (Fsr.Data != ROUND_TO_NEAREST) {
    02824         goto TestFailed;
    02825     }
    02826
    02827     Subtest += 1;
    02828     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    02829                                0X400000,
    02830                                SIGN | 0x0);
    02831
    02832     if (Fsr.Data != ROUND_TO_NEAREST) {
    02833         goto TestFailed;
    02834     }
    02835
    02836 // ****** //
    02837
    02838     Subtest += 1;
    02839     Fsr.Data = CompareEqSingle(ROUND_TO_NEAREST,
    02840                                SINGLE_INFINITY_VALUE,
    02841                                SINGLE_INFINITY_VALUE);
    02842
    02843     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02844         goto TestFailed;
    02845     }
    02846
    02847     Subtest += 1;
    02848     Fsr.Data = CompareEqSingle(ROUND_TO_NEAREST,
    02849                                0x400000,
    02850                                0x400000);
    02851
    02852     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02853         goto TestFailed;
    02854     }
    02855
    02856     Subtest += 1;
    02857     Fsr.Data = CompareEqSingle(ROUND_TO_NEAREST,
    02858                                MINUS_SINGLE_INFINITY_VALUE,
    02859                                SINGLE_INFINITY_VALUE);
    02860
    02861     if (Fsr.Data != ROUND_TO_NEAREST) {
    02862         goto TestFailed;
    02863     }
    02864
    02865     Subtest += 1;
    02866     Fsr.Data = CompareEqSingle(ROUND_TO_NEAREST,
    02867                                0x400000,
    02868                                SIGN | 0x400000);
    02869
    02870     if (Fsr.Data != ROUND_TO_NEAREST) {
    02871         goto TestFailed;
    02872     }
    02873
    02874     Subtest += 1;
    02875     Fsr.Data = CompareLeSingle(ROUND_TO_NEAREST,
    02876                                SINGLE_INFINITY_VALUE,
    02877                                SINGLE_INFINITY_VALUE);
    02878
    02879     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02880         goto TestFailed;
    02881     }
    02882
    02883     Subtest += 1;
    02884     Fsr.Data = CompareLeSingle(ROUND_TO_NEAREST,
    02885                                0x400000,
    02886                                0x400000);
    02887
    02888     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02889         goto TestFailed;
    02890     }
    02891
    02892     Subtest += 1;
    02893     Fsr.Data = CompareLeSingle(ROUND_TO_NEAREST,
    02894                                MINUS_SINGLE_INFINITY_VALUE,
    02895                                SINGLE_INFINITY_VALUE);
    02896
    02897     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02898         goto TestFailed;
    02899     }
    02900
    02901     Subtest += 1;
    02902     Fsr.Data = CompareLeSingle(ROUND_TO_NEAREST,
    02903                                SIGN | 0x400000,
    02904                                0x400000);
    02905
    02906     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02907         goto TestFailed;
    02908     }
    02909
    02910     Subtest += 1;
    02911     Fsr.Data = CompareLeSingle(ROUND_TO_NEAREST,
    02912                                SINGLE_INFINITY_VALUE,
    02913                                MINUS_SINGLE_INFINITY_VALUE);
    02914
    02915     if (Fsr.Data != ROUND_TO_NEAREST) {
    02916         goto TestFailed;
    02917     }
    02918
    02919     Subtest += 1;
    02920     Fsr.Data = CompareLeSingle(ROUND_TO_NEAREST,
    02921                                0x400000,
    02922                                SIGN | 0x400000);
    02923
    02924     if (Fsr.Data != ROUND_TO_NEAREST) {
    02925         goto TestFailed;
    02926     }
    02927
    02928     Subtest += 1;
    02929     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    02930                                SINGLE_INFINITY_VALUE,
    02931                                SINGLE_INFINITY_VALUE);
    02932
    02933     if (Fsr.Data != ROUND_TO_NEAREST) {
    02934         goto TestFailed;
    02935     }
    02936
    02937     Subtest += 1;
    02938     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    02939                                0x400000,
    02940                                0x400000);
    02941
    02942     if (Fsr.Data != ROUND_TO_NEAREST) {
    02943         goto TestFailed;
    02944     }
    02945
    02946     Subtest += 1;
    02947     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    02948                                MINUS_SINGLE_INFINITY_VALUE,
    02949                                SINGLE_INFINITY_VALUE);
    02950
    02951     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02952         goto TestFailed;
    02953     }
    02954
    02955     Subtest += 1;
    02956     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    02957                                SIGN | 0x400000,
    02958                                0x400000);
    02959
    02960     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02961         goto TestFailed;
    02962     }
    02963
    02964     Subtest += 1;
    02965     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    02966                                0x400000,
    02967                                0x410000);
    02968
    02969     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02970         goto TestFailed;
    02971     }
    02972
    02973     Subtest += 1;
    02974     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    02975                                0x200000,
    02976                                0x400000);
    02977
    02978     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02979         goto TestFailed;
    02980     }
    02981
    02982     Subtest += 1;
    02983     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    02984                                SIGN | 0x400000,
    02985                                0x400000);
    02986
    02987     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02988         goto TestFailed;
    02989     }
    02990
    02991     Subtest += 1;
    02992     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    02993                                SIGN | 0x410000,
    02994                                SIGN | 0x400000);
    02995
    02996     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    02997         goto TestFailed;
    02998     }
    02999
    03000     Subtest += 1;
    03001     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    03002                                SIGN | 0x400000,
    03003                                SIGN | 0x200000);
    03004
    03005     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    03006         goto TestFailed;
    03007     }
    03008
    03009     Subtest += 1;
    03010     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    03011                                SIGN | 0x400000,
    03012                                0x400000);
    03013
    03014     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    03015         goto TestFailed;
    03016     }
    03017
    03018     Subtest += 1;
    03019     Fsr.Data = CompareFSingle(ROUND_TO_NEAREST,
    03020                                0x400000,
    03021                                0x400000);
    03022
    03023     if (Fsr.Data != ROUND_TO_NEAREST) {
    03024         goto TestFailed;
    03025     }
    03026
    03027     Subtest += 1;
    03028     Fsr.Data = CompareUnSingle(ROUND_TO_NEAREST,
    03029                                0x400000,
    03030                                0x400000);
    03031
    03032     if (Fsr.Data != ROUND_TO_NEAREST) {
    03033         goto TestFailed;
    03034     }
    03035
    03036     Subtest += 1;
    03037     Fsr.Data = CompareUnSingle(ROUND_TO_NEAREST,
    03038                                SINGLE_QUIET_NAN,
    03039                                0x400000);
    03040
    03041     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    03042         goto TestFailed;
    03043     }
    03044
    03045     Subtest += 1;
    03046     Fsr.Data = CompareEqSingle(ROUND_TO_NEAREST,
    03047                                SINGLE_QUIET_NAN,
    03048                                SINGLE_INFINITY_VALUE);
    03049
    03050     if (Fsr.Data != ROUND_TO_NEAREST) {
    03051         goto TestFailed;
    03052     }
    03053
    03054     Subtest += 1;
    03055     Fsr.Data = CompareEqSingle(ROUND_TO_NEAREST,
    03056                                SINGLE_INFINITY_VALUE,
    03057                                SINGLE_INFINITY_VALUE);
    03058
    03059     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    03060         goto TestFailed;
    03061     }
    03062
    03063     Subtest += 1;
    03064     Fsr.Data = CompareUeqSingle(ROUND_TO_NEAREST,
    03065                                 0x400000,
    03066                                 SINGLE_INFINITY_VALUE);
    03067
    03068     if (Fsr.Data != ROUND_TO_NEAREST) {
    03069         goto TestFailed;
    03070     }
    03071
    03072     Subtest += 1;
    03073     Fsr.Data = CompareUeqSingle(ROUND_TO_NEAREST,
    03074                                 SINGLE_QUIET_NAN,
    03075                                 SINGLE_INFINITY_VALUE);
    03076
    03077     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    03078         goto TestFailed;
    03079     }
    03080
    03081     Subtest += 1;
    03082     Fsr.Data = CompareOltSingle(ROUND_TO_NEAREST,
    03083                                 0x400000,
    03084                                 SINGLE_QUIET_NAN);
    03085
    03086     if (Fsr.Data != ROUND_TO_NEAREST) {
    03087         goto TestFailed;
    03088     }
    03089
    03090     Subtest += 1;
    03091     Fsr.Data = CompareOltSingle(ROUND_TO_NEAREST,
    03092                                 0x400000,
    03093                                 SINGLE_INFINITY_VALUE);
    03094
    03095     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    03096         goto TestFailed;
    03097     }
    03098
    03099     Subtest += 1;
    03100     Fsr.Data = CompareUltSingle(ROUND_TO_NEAREST,
    03101                                 0x400000,
    03102                                 0x400000);
    03103
    03104     if (Fsr.Data != ROUND_TO_NEAREST) {
    03105         goto TestFailed;
    03106     }
    03107
    03108     Subtest += 1;
    03109     Fsr.Data = CompareUltSingle(ROUND_TO_NEAREST,
    03110                                 SINGLE_QUIET_NAN,
    03111                                 SINGLE_INFINITY_VALUE);
    03112
    03113     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    03114         goto TestFailed;
    03115     }
    03116
    03117     Subtest += 1;
    03118     Fsr.Data = CompareOleSingle(ROUND_TO_NEAREST,
    03119                                 0x410000,
    03120                                 0x400000);
    03121
    03122     if (Fsr.Data != ROUND_TO_NEAREST) {
    03123         goto TestFailed;
    03124     }
    03125
    03126     Subtest += 1;
    03127     Fsr.Data = CompareOleSingle(ROUND_TO_NEAREST,
    03128                                 SINGLE_INFINITY_VALUE,
    03129                                 SINGLE_INFINITY_VALUE);
    03130
    03131     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    03132         goto TestFailed;
    03133     }
    03134
    03135     Subtest += 1;
    03136     Fsr.Data = CompareSfSingle(ROUND_TO_NEAREST,
    03137                                0x410000,
    03138                                0x400000);
    03139
    03140     if (Fsr.Data != ROUND_TO_NEAREST) {
    03141         goto TestFailed;
    03142     }
    03143
    03144     Subtest += 1;
    03145     Fsr.Data = CompareSfSingle(ROUND_TO_NEAREST,
    03146                                SINGLE_INFINITY_VALUE,
    03147                                SINGLE_QUIET_NAN);
    03148
    03149     if (Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) {
    03150         goto TestFailed;
    03151     }
    03152
    03153     Subtest += 1;
    03154     Fsr.Data = CompareNgleSingle(ROUND_TO_NEAREST,
    03155                                  0x410000,
    03156                                  0x400000);
    03157
    03158     if (Fsr.Data != ROUND_TO_NEAREST) {
    03159         goto TestFailed;
    03160     }
    03161
    03162     Subtest += 1;
    03163     Fsr.Data = CompareNgleSingle(ROUND_TO_NEAREST,
    03164                                  SINGLE_QUIET_NAN,
    03165                                  SINGLE_INFINITY_VALUE);
    03166
    03167     if (Fsr.Data != (CC | SV | XV | ROUND_TO_NEAREST)) {
    03168         goto TestFailed;
    03169     }
    03170
    03171     Subtest += 1;
    03172     Fsr.Data = CompareSeqSingle(ROUND_TO_NEAREST,
    03173                                 0x410000,
    03174                                 0x400000);
    03175
    03176     if (Fsr.Data != ROUND_TO_NEAREST) {
    03177         goto TestFailed;
    03178     }
    03179
    03180     Subtest += 1;
    03181     Fsr.Data = CompareSeqSingle(ROUND_TO_NEAREST,
    03182                                 SINGLE_QUIET_NAN,
    03183                                 SINGLE_INFINITY_VALUE);
    03184
    03185     if (Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) {
    03186         goto TestFailed;
    03187     }
    03188
    03189     Subtest += 1;
    03190     Fsr.Data = CompareNglSingle(ROUND_TO_NEAREST,
    03191                                 0x410000,
    03192                                 0x400000);
    03193
    03194     if (Fsr.Data != ROUND_TO_NEAREST) {
    03195         goto TestFailed;
    03196     }
    03197
    03198     Subtest += 1;
    03199     Fsr.Data = CompareNglSingle(ROUND_TO_NEAREST,
    03200                                 SINGLE_QUIET_NAN,
    03201                                 SINGLE_INFINITY_VALUE);
    03202
    03203     if (Fsr.Data != (CC | SV | XV | ROUND_TO_NEAREST)) {
    03204         goto TestFailed;
    03205     }
    03206
    03207     Subtest += 1;
    03208     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    03209                                0x410000,
    03210                                0x400000);
    03211
    03212     if (Fsr.Data != ROUND_TO_NEAREST) {
    03213         goto TestFailed;
    03214     }
    03215
    03216     Subtest += 1;
    03217     Fsr.Data = CompareLtSingle(ROUND_TO_NEAREST,
    03218                                SINGLE_QUIET_NAN,
    03219                                SINGLE_INFINITY_VALUE);
    03220
    03221     if (Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) {
    03222         goto TestFailed;
    03223     }
    03224
    03225     Subtest += 1;
    03226     Fsr.Data = CompareNgeSingle(ROUND_TO_NEAREST,
    03227                                 0x410000,
    03228                                 0x400000);
    03229
    03230     if (Fsr.Data != ROUND_TO_NEAREST) {
    03231         goto TestFailed;
    03232     }
    03233
    03234     Subtest += 1;
    03235     Fsr.Data = CompareNgeSingle(ROUND_TO_NEAREST,
    03236                                 SINGLE_QUIET_NAN,
    03237                                 SINGLE_INFINITY_VALUE);
    03238
    03239     if (Fsr.Data != (CC | SV | XV | ROUND_TO_NEAREST)) {
    03240         goto TestFailed;
    03241     }
    03242
    03243     Subtest += 1;
    03244     Fsr.Data = CompareLeSingle(ROUND_TO_NEAREST,
    03245                                0x410000,
    03246                                0x400000);
    03247
    03248     if (Fsr.Data != ROUND_TO_NEAREST) {
    03249         goto TestFailed;
    03250     }
    03251
    03252     Subtest += 1;
    03253     Fsr.Data = CompareLeSingle(ROUND_TO_NEAREST,
    03254                                SINGLE_QUIET_NAN,
    03255                                SINGLE_INFINITY_VALUE);
    03256
    03257     if (Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) {
    03258         goto TestFailed;
    03259     }
    03260
    03261     Subtest += 1;
    03262     Fsr.Data = CompareNgtSingle(ROUND_TO_NEAREST,
    03263                                 0x410000,
    03264                                 0x400000);
    03265
    03266     if (Fsr.Data != ROUND_TO_NEAREST) {
    03267         goto TestFailed;
    03268     }
    03269
    03270     Subtest += 1;
    03271     Fsr.Data = CompareNgtSingle(ROUND_TO_NEAREST,
    03272                                 SINGLE_QUIET_NAN,
    03273                                 SINGLE_INFINITY_VALUE);
    03274
    03275     if (Fsr.Data != (CC | SV | XV | ROUND_TO_NEAREST)) {
    03276         goto TestFailed;
    03277     }
    03278
    03279     Subtest += 1;
    03280     Count = 0;
    03281     try {
    03282         Fsr.Data = CompareSfSingle(EV | ROUND_TO_NEAREST,
    03283                                    SINGLE_INFINITY_VALUE,
    03284                                    SINGLE_QUIET_NAN);
    03285
    03286     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    03287               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03288         Count += 1;
    03289     }
    03290
    03291     if (Count == 0) {
    03292         goto TestFailed;
    03293     }
    03294
    03295     Subtest += 1;
    03296     Count = 0;
    03297     try {
    03298         Fsr.Data = CompareNgleSingle(EV | ROUND_TO_NEAREST,
    03299                                      SINGLE_QUIET_NAN,
    03300                                      SINGLE_INFINITY_VALUE);
    03301
    03302     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    03303               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03304         Count += 1;
    03305     }
    03306
    03307     if (Count == 0) {
    03308         goto TestFailed;
    03309     }
    03310
    03311     Subtest += 1;
    03312     Count = 0;
    03313     try {
    03314         Fsr.Data = CompareSeqSingle(EV | ROUND_TO_NEAREST,
    03315                                     SINGLE_QUIET_NAN,
    03316                                     SINGLE_INFINITY_VALUE);
    03317
    03318     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    03319               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03320         Count += 1;
    03321     }
    03322
    03323     if (Count == 0) {
    03324         goto TestFailed;
    03325     }
    03326
    03327     Subtest += 1;
    03328     Count = 0;
    03329     try {
    03330         Fsr.Data = CompareNglSingle(EV | ROUND_TO_NEAREST,
    03331                                     SINGLE_QUIET_NAN,
    03332                                     SINGLE_INFINITY_VALUE);
    03333
    03334     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    03335               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03336         Count += 1;
    03337     }
    03338
    03339     if (Count == 0) {
    03340         goto TestFailed;
    03341     }
    03342
    03343     Subtest += 1;
    03344     Count = 0;
    03345     try {
    03346         Fsr.Data = CompareLtSingle(EV | ROUND_TO_NEAREST,
    03347                                    SINGLE_QUIET_NAN,
    03348                                    SINGLE_INFINITY_VALUE);
    03349
    03350     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    03351               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03352         Count += 1;
    03353     }
    03354
    03355     if (Count == 0) {
    03356         goto TestFailed;
    03357     }
    03358
    03359     Subtest += 1;
    03360     Count = 0;
    03361     try {
    03362         Fsr.Data = CompareNgeSingle(EV | ROUND_TO_NEAREST,
    03363                                     SINGLE_QUIET_NAN,
    03364                                     SINGLE_INFINITY_VALUE);
    03365
    03366     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    03367               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03368         Count += 1;
    03369     }
    03370
    03371     if (Count == 0) {
    03372         goto TestFailed;
    03373     }
    03374
    03375     Subtest += 1;
    03376     Count = 0;
    03377     try {
    03378         Fsr.Data = CompareLeSingle(EV | ROUND_TO_NEAREST,
    03379                                    SINGLE_QUIET_NAN,
    03380                                    SINGLE_INFINITY_VALUE);
    03381
    03382     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    03383               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03384         Count += 1;
    03385     }
    03386
    03387     if (Count == 0) {
    03388         goto TestFailed;
    03389     }
    03390
    03391     Subtest += 1;
    03392     Count = 0;
    03393     try {
    03394         Fsr.Data = CompareNgtSingle(EV | ROUND_TO_NEAREST,
    03395                                     SINGLE_QUIET_NAN,
    03396                                     SINGLE_INFINITY_VALUE);
    03397
    03398     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    03399               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03400         Count += 1;
    03401     }
    03402
    03403     if (Count == 0) {
    03404         goto TestFailed;
    03405     }
    03406
    03407     Subtest += 1;
    03408     Count = 0;
    03409     try {
    03410         Fsr.Data = CompareEqSingle(EV | ROUND_TO_NEAREST,
    03411                                    SINGLE_SIGNAL_NAN,
    03412                                    SINGLE_INFINITY_VALUE);
    03413
    03414     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    03415               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03416         Count += 1;
    03417     }
    03418
    03419     if (Count == 0) {
    03420         goto TestFailed;
    03421     }
    03422
    03423     //
    03424     // End of test 9.
    03425     //
    03426
    03427     printf("succeeded\n");
    03428     return;
    03429
    03430     //
    03431     // Test 9 failed.
    03432     //
    03433
    03434 TestFailed:
    03435     printf(" subtest %d failed, fsr = %lx\n", Subtest, Fsr.Data);
    03436     return;
    03437 }
    03438
    03439 VOID
    03440 Test10 (
    03441     VOID
    03442     )
    03443
    03444 {
    03445
    03446     ULONG Count;
    03447     FLOATING_STATUS Fsr;
    03448     ULONG Subtest;
    03449     ULONG SingleResult;
    03450
    03451     //
    03452     // Test 10 - Absolute, move, and negate single test.
    03453     //
    03454
    03455     Subtest = 0;
    03456     printf("    Test 10 - absolute, move, and negate single ...");
    03457     Subtest += 1;
    03458     Fsr.Data = AbsoluteSingle(ROUND_TO_NEAREST,
    03459                               0x400000,
    03460                               &SingleResult);
    03461
    03462     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03463         (SingleResult != 0x400000)) {
    03464         goto TestFailed;
    03465     }
    03466
    03467     Subtest += 1;
    03468     Fsr.Data = AbsoluteSingle(ROUND_TO_NEAREST,
    03469                               SIGN | 0x400000,
    03470                               &SingleResult);
    03471
    03472     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03473         (SingleResult != 0x400000)) {
    03474         goto TestFailed;
    03475     }
    03476
    03477     Subtest += 1;
    03478     Fsr.Data = AbsoluteSingle(ROUND_TO_NEAREST,
    03479                               SINGLE_QUIET_NAN,
    03480                               &SingleResult);
    03481
    03482     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03483         (SingleResult != SINGLE_QUIET_NAN)) {
    03484         goto TestFailed;
    03485     }
    03486
    03487     Subtest += 1;
    03488     Fsr.Data = AbsoluteSingle(ROUND_TO_NEAREST,
    03489                               SINGLE_SIGNAL_NAN,
    03490                               &SingleResult);
    03491
    03492     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    03493         (SingleResult != SINGLE_QUIET_NAN)) {
    03494         goto TestFailed;
    03495     }
    03496
    03497     Subtest += 1;
    03498     Count = 0;
    03499     try {
    03500         Fsr.Data = AbsoluteSingle(EV | ROUND_TO_NEAREST,
    03501                                   SINGLE_SIGNAL_NAN,
    03502                                   &SingleResult);
    03503
    03504     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    03505               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03506         Count += 1;
    03507     }
    03508
    03509     if (Count == 0) {
    03510         goto TestFailed;
    03511     }
    03512
    03513     Subtest += 1;
    03514     Fsr.Data = MoveSingle(ROUND_TO_NEAREST,
    03515                           0x400000,
    03516                           &SingleResult);
    03517
    03518     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03519         (SingleResult != 0x400000)) {
    03520         goto TestFailed;
    03521     }
    03522
    03523     Subtest += 1;
    03524     Fsr.Data = MoveSingle(ROUND_TO_NEAREST,
    03525                           SIGN | 0x400000,
    03526                           &SingleResult);
    03527
    03528     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03529         (SingleResult != (SIGN | 0x400000))) {
    03530         goto TestFailed;
    03531     }
    03532
    03533     Subtest += 1;
    03534     Fsr.Data = MoveSingle(ROUND_TO_NEAREST,
    03535                           SINGLE_QUIET_NAN,
    03536                           &SingleResult);
    03537
    03538     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03539         (SingleResult != SINGLE_QUIET_NAN)) {
    03540         goto TestFailed;
    03541     }
    03542
    03543     Subtest += 1;
    03544     Fsr.Data = MoveSingle(ROUND_TO_NEAREST,
    03545                           SINGLE_SIGNAL_NAN,
    03546                           &SingleResult);
    03547
    03548     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03549         (SingleResult != SINGLE_SIGNAL_NAN)) {
    03550         goto TestFailed;
    03551     }
    03552
    03553     Subtest += 1;
    03554     Fsr.Data = MoveSingle(EV | ROUND_TO_NEAREST,
    03555                           SINGLE_SIGNAL_NAN,
    03556                           &SingleResult);
    03557
    03558     if ((Fsr.Data != (EV | ROUND_TO_NEAREST)) ||
    03559         (SingleResult != SINGLE_SIGNAL_NAN)) {
    03560         goto TestFailed;
    03561     }
    03562
    03563     Subtest += 1;
    03564     Fsr.Data = NegateSingle(ROUND_TO_NEAREST,
    03565                             0x400000,
    03566                             &SingleResult);
    03567
    03568     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03569         (SingleResult != (SIGN | 0x400000))) {
    03570         goto TestFailed;
    03571     }
    03572
    03573     Subtest += 1;
    03574     Fsr.Data = NegateSingle(ROUND_TO_NEAREST,
    03575                             SIGN | 0x400000,
    03576                             &SingleResult);
    03577
    03578     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03579         (SingleResult != 0x400000)) {
    03580         goto TestFailed;
    03581     }
    03582
    03583     Subtest += 1;
    03584     Fsr.Data = NegateSingle(ROUND_TO_NEAREST,
    03585                             SINGLE_QUIET_NAN,
    03586                             &SingleResult);
    03587
    03588     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03589         (SingleResult != SINGLE_QUIET_NAN)) {
    03590         goto TestFailed;
    03591     }
    03592
    03593     Subtest += 1;
    03594     Fsr.Data = NegateSingle(ROUND_TO_NEAREST,
    03595                             SINGLE_SIGNAL_NAN,
    03596                             &SingleResult);
    03597
    03598     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    03599         (SingleResult != SINGLE_QUIET_NAN)) {
    03600         goto TestFailed;
    03601     }
    03602
    03603     Subtest += 1;
    03604     Count = 0;
    03605     try {
    03606         Fsr.Data = NegateSingle(EV | ROUND_TO_NEAREST,
    03607                                 SINGLE_SIGNAL_NAN,
    03608                                 &SingleResult);
    03609
    03610     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    03611               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03612         Count += 1;
    03613     }
    03614
    03615     if (Count == 0) {
    03616         goto TestFailed;
    03617     }
    03618
    03619     //
    03620     // End of test 10.
    03621     //
    03622
    03623     printf("succeeded\n");
    03624     return;
    03625
    03626     //
    03627     // Test 10 failed.
    03628     //
    03629
    03630 TestFailed:
    03631     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    03632            Subtest,
    03633            Fsr.Data,
    03634            SingleResult);
    03635
    03636     return;
    03637 }
    03638
    03639 VOID
    03640 Test11 (
    03641     VOID
    03642     )
    03643
    03644 {
    03645
    03646     ULONG Count;
    03647     ULARGE_INTEGER DoubleOperand1;
    03648     ULARGE_INTEGER DoubleOperand2;
    03649     ULARGE_INTEGER DoubleResult;
    03650     FLOATING_STATUS Fsr;
    03651     ULONG Subtest;
    03652
    03653     //
    03654     // Test 11 - Add double denormalized test.
    03655     //
    03656
    03657     Subtest = 0;
    03658     printf("    Test 11 - add/subtract double denormalized ...");
    03659     Subtest += 1;
    03660     DoubleOperand1.LowPart = 0x3ff;
    03661     DoubleOperand1.HighPart = 0x0;
    03662     DoubleOperand2.LowPart = 0x1;
    03663     DoubleOperand2.HighPart = 0x0;
    03664     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    03665                          &DoubleOperand1,
    03666                          &DoubleOperand2,
    03667                          &DoubleResult);
    03668
    03669     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03670         (DoubleResult.LowPart != 0x400) ||
    03671         (DoubleResult.HighPart != 0x0)) {
    03672         goto TestFailed;
    03673     }
    03674
    03675     Subtest += 1;
    03676     DoubleOperand1.LowPart = 0x0;
    03677     DoubleOperand1.HighPart = 0x1;
    03678     DoubleOperand2.LowPart = 0x0;
    03679     DoubleOperand2.HighPart = 0x7fff;
    03680     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    03681                          &DoubleOperand1,
    03682                          &DoubleOperand2,
    03683                          &DoubleResult);
    03684
    03685     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03686         (DoubleResult.LowPart != 0x0) ||
    03687         (DoubleResult.HighPart != 0x8000)) {
    03688         goto TestFailed;
    03689     }
    03690
    03691     Subtest += 1;
    03692     DoubleOperand1.LowPart = 0x0;
    03693     DoubleOperand1.HighPart = 0x80000;
    03694     DoubleOperand2.LowPart = 0x0;
    03695     DoubleOperand2.HighPart = SIGN | 0x84000;
    03696     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    03697                          &DoubleOperand1,
    03698                          &DoubleOperand2,
    03699                          &DoubleResult);
    03700
    03701     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03702         (DoubleResult.LowPart != 0x0) ||
    03703         (DoubleResult.HighPart != (SIGN | 0x4000))) {
    03704         goto TestFailed;
    03705     }
    03706
    03707     Subtest += 1;
    03708     DoubleOperand1.LowPart = 0x0;
    03709     DoubleOperand1.HighPart = SIGN | 0x80000;
    03710     DoubleOperand2.LowPart = 0x0;
    03711     DoubleOperand2.HighPart = 0x84000;
    03712     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    03713                          &DoubleOperand1,
    03714                          &DoubleOperand2,
    03715                          &DoubleResult);
    03716
    03717     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03718         (DoubleResult.LowPart != 0x0) ||
    03719         (DoubleResult.HighPart != 0x4000)) {
    03720         goto TestFailed;
    03721     }
    03722
    03723     Subtest += 1;
    03724     DoubleOperand1.LowPart = 0x0;
    03725     DoubleOperand1.HighPart = 0x80000;
    03726     DoubleOperand2.LowPart = 0x0;
    03727     DoubleOperand2.HighPart = SIGN | 0x80000;
    03728     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    03729                          &DoubleOperand1,
    03730                          &DoubleOperand2,
    03731                          &DoubleResult);
    03732
    03733     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03734         (DoubleResult.LowPart != 0x0) ||
    03735         (DoubleResult.HighPart != 0x0)) {
    03736         goto TestFailed;
    03737     }
    03738
    03739     Subtest += 1;
    03740     DoubleOperand1.LowPart = 0x0;
    03741     DoubleOperand1.HighPart = SIGN | 0x80000;
    03742     DoubleOperand2.LowPart = 0x0;
    03743     DoubleOperand2.HighPart = 0x80000;
    03744     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    03745                          &DoubleOperand1,
    03746                          &DoubleOperand2,
    03747                          &DoubleResult);
    03748
    03749     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03750         (DoubleResult.LowPart != 0x0) ||
    03751         (DoubleResult.HighPart != (SIGN | 0x0))) {
    03752         goto TestFailed;
    03753     }
    03754
    03755     Subtest += 1;
    03756     DoubleOperand1.LowPart = 0x0;
    03757     DoubleOperand1.HighPart = 0x80000;
    03758     DoubleOperand2.LowPart = 0x0;
    03759     DoubleOperand2.HighPart = 0x80000;
    03760     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    03761                          &DoubleOperand1,
    03762                          &DoubleOperand2,
    03763                          &DoubleResult);
    03764
    03765     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03766         (DoubleResult.LowPart != 0x0) ||
    03767         (DoubleResult.HighPart != 0x100000)) {
    03768         goto TestFailed;
    03769     }
    03770
    03771     Subtest += 1;
    03772     DoubleOperand1.LowPart = 0x0;
    03773     DoubleOperand1.HighPart = 0x100000;
    03774     DoubleOperand2.LowPart = 0x0;
    03775     DoubleOperand2.HighPart = 0xfffff;
    03776     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    03777                          &DoubleOperand1,
    03778                          &DoubleOperand2,
    03779                          &DoubleResult);
    03780
    03781     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03782         (DoubleResult.LowPart != 0x0) ||
    03783         (DoubleResult.HighPart != 0x1fffff)) {
    03784         goto TestFailed;
    03785     }
    03786
    03787     Subtest += 1;
    03788     DoubleOperand1.LowPart = 0x0;
    03789     DoubleOperand1.HighPart = 0x80000;
    03790     DoubleOperand2.LowPart = 0x0;
    03791     DoubleOperand2.HighPart = 0x1600000;
    03792     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    03793                          &DoubleOperand1,
    03794                          &DoubleOperand2,
    03795                          &DoubleResult);
    03796
    03797     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03798         (DoubleResult.LowPart != 0x40000000) ||
    03799         (DoubleResult.HighPart != 0x1600000)) {
    03800         goto TestFailed;
    03801     }
    03802
    03803     Subtest += 1;
    03804     DoubleOperand1.LowPart = 0x0;
    03805     DoubleOperand1.HighPart = 0x80000;
    03806     DoubleOperand2.LowPart = 0x0;
    03807     DoubleOperand2.HighPart = 0x2600000;
    03808     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    03809                          &DoubleOperand1,
    03810                          &DoubleOperand2,
    03811                          &DoubleResult);
    03812
    03813     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03814         (DoubleResult.LowPart != 0x4000) ||
    03815         (DoubleResult.HighPart != 0x2600000)) {
    03816         goto TestFailed;
    03817     }
    03818
    03819     Subtest += 1;
    03820     DoubleOperand1.LowPart = 0x0;
    03821     DoubleOperand1.HighPart = 0x80000;
    03822     DoubleOperand2.LowPart = 0x0;
    03823     DoubleOperand2.HighPart = 0x3f000000;
    03824     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    03825                          &DoubleOperand1,
    03826                          &DoubleOperand2,
    03827                          &DoubleResult);
    03828
    03829     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    03830         (DoubleResult.LowPart != 0x0) ||
    03831         (DoubleResult.HighPart != 0x3f000000)) {
    03832         goto TestFailed;
    03833     }
    03834
    03835     Subtest += 1;
    03836     DoubleOperand1.LowPart = 0x0;
    03837     DoubleOperand1.HighPart = 0x100000;
    03838     DoubleOperand2.LowPart = 0x0;
    03839     DoubleOperand2.HighPart = 0x3ff00000;
    03840     Count = 0;
    03841     try {
    03842         Fsr.Data = AddDouble(EI | ROUND_TO_NEAREST,
    03843                              &DoubleOperand1,
    03844                              &DoubleOperand2,
    03845                              &DoubleResult);
    03846
    03847     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    03848               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03849         Count += 1;
    03850     }
    03851
    03852     if (Count == 0) {
    03853         goto TestFailed;
    03854     }
    03855
    03856     Subtest += 1;
    03857     DoubleOperand1.LowPart = 0x0;
    03858     DoubleOperand1.HighPart = 0x7fe00000;
    03859     DoubleOperand2.LowPart = 0x0;
    03860     DoubleOperand2.HighPart = 0x7fe00000;
    03861     Count = 0;
    03862     try {
    03863         Fsr.Data = AddDouble(EO | ROUND_TO_NEAREST,
    03864                              &DoubleOperand1,
    03865                              &DoubleOperand2,
    03866                              &DoubleResult);
    03867
    03868     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    03869               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03870         Count += 1;
    03871     }
    03872
    03873     if (Count == 0) {
    03874         goto TestFailed;
    03875     }
    03876
    03877     Subtest += 1;
    03878     DoubleOperand1.LowPart = 0x0;
    03879     DoubleOperand1.HighPart = 0x7fe00000;
    03880     DoubleOperand2.LowPart = 0x0;
    03881     DoubleOperand2.HighPart = 0x7fe00000;
    03882     Count = 0;
    03883     try {
    03884         Fsr.Data = AddDouble(EI | ROUND_TO_NEAREST,
    03885                              &DoubleOperand1,
    03886                              &DoubleOperand2,
    03887                              &DoubleResult);
    03888
    03889     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    03890               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03891         Count += 1;
    03892     }
    03893
    03894     if (Count == 0) {
    03895         goto TestFailed;
    03896     }
    03897
    03898     Subtest += 1;
    03899     DoubleOperand1.LowPart = 0x0;
    03900     DoubleOperand1.HighPart = 0x7fe00000;
    03901     DoubleOperand2.LowPart = 0x0;
    03902     DoubleOperand2.HighPart = 0x7fe00000;
    03903     Count = 0;
    03904     try {
    03905         Fsr.Data = AddDouble(EI | EO | ROUND_TO_NEAREST,
    03906                              &DoubleOperand1,
    03907                              &DoubleOperand2,
    03908                              &DoubleResult);
    03909
    03910     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    03911               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    03912         Count += 1;
    03913     }
    03914
    03915     if (Count == 0) {
    03916         goto TestFailed;
    03917     }
    03918
    03919     Subtest += 1;
    03920     DoubleOperand1.LowPart = 0x3ff;
    03921     DoubleOperand1.HighPart = 0x0;
    03922     DoubleOperand2.LowPart = 0x1;
    03923     DoubleOperand2.HighPart = SIGN;
    03924     Fsr.Data = SubtractDouble(ROUND_TO_NEAREST,
    03925                               &DoubleOperand1,
    03926                               &DoubleOperand2,
    03927                               &DoubleResult);
    03928
    03929     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03930         (DoubleResult.LowPart != 0x400) ||
    03931         (DoubleResult.HighPart != 0x0)) {
    03932         goto TestFailed;
    03933     }
    03934
    03935     Subtest += 1;
    03936     DoubleOperand1.LowPart = 0x0;
    03937     DoubleOperand1.HighPart = 0x1;
    03938     DoubleOperand2.LowPart = 0x0;
    03939     DoubleOperand2.HighPart = SIGN | 0x7fff;
    03940     Fsr.Data = SubtractDouble(ROUND_TO_NEAREST,
    03941                               &DoubleOperand1,
    03942                               &DoubleOperand2,
    03943                               &DoubleResult);
    03944
    03945     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03946         (DoubleResult.LowPart != 0x0) ||
    03947         (DoubleResult.HighPart != 0x8000)) {
    03948         goto TestFailed;
    03949     }
    03950
    03951     Subtest += 1;
    03952     DoubleOperand1.LowPart = 0x0;
    03953     DoubleOperand1.HighPart = 0x80000;
    03954     DoubleOperand2.LowPart = 0x0;
    03955     DoubleOperand2.HighPart = 0x84000;
    03956     Fsr.Data = SubtractDouble(ROUND_TO_NEAREST,
    03957                               &DoubleOperand1,
    03958                               &DoubleOperand2,
    03959                               &DoubleResult);
    03960
    03961     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03962         (DoubleResult.LowPart != 0x0) ||
    03963         (DoubleResult.HighPart != (SIGN | 0x4000))) {
    03964         goto TestFailed;
    03965     }
    03966
    03967     Subtest += 1;
    03968     DoubleOperand1.LowPart = 0x0;
    03969     DoubleOperand1.HighPart = SIGN | 0x80000;
    03970     DoubleOperand2.LowPart = 0x0;
    03971     DoubleOperand2.HighPart = SIGN | 0x84000;
    03972     Fsr.Data = SubtractDouble(ROUND_TO_NEAREST,
    03973                               &DoubleOperand1,
    03974                               &DoubleOperand2,
    03975                               &DoubleResult);
    03976
    03977     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03978         (DoubleResult.LowPart != 0x0) ||
    03979         (DoubleResult.HighPart != 0x4000)) {
    03980         goto TestFailed;
    03981     }
    03982
    03983     Subtest += 1;
    03984     DoubleOperand1.LowPart = 0x0;
    03985     DoubleOperand1.HighPart = 0x80000;
    03986     DoubleOperand2.LowPart = 0x0;
    03987     DoubleOperand2.HighPart = 0x80000;
    03988     Fsr.Data = SubtractDouble(ROUND_TO_NEAREST,
    03989                               &DoubleOperand1,
    03990                               &DoubleOperand2,
    03991                               &DoubleResult);
    03992
    03993     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    03994         (DoubleResult.LowPart != 0x0) ||
    03995         (DoubleResult.HighPart != 0x0)) {
    03996         goto TestFailed;
    03997     }
    03998
    03999     Subtest += 1;
    04000     DoubleOperand1.LowPart = 0x0;
    04001     DoubleOperand1.HighPart = SIGN | 0x80000;
    04002     DoubleOperand2.LowPart = 0x0;
    04003     DoubleOperand2.HighPart = SIGN | 0x80000;
    04004     Fsr.Data = SubtractDouble(ROUND_TO_NEAREST,
    04005                               &DoubleOperand1,
    04006                               &DoubleOperand2,
    04007                               &DoubleResult);
    04008
    04009     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    04010         (DoubleResult.LowPart != 0x0) ||
    04011         (DoubleResult.HighPart != (SIGN | 0x0))) {
    04012         goto TestFailed;
    04013     }
    04014
    04015     Subtest += 1;
    04016     DoubleOperand1.LowPart = 0x0;
    04017     DoubleOperand1.HighPart = 0x80000;
    04018     DoubleOperand2.LowPart = 0x0;
    04019     DoubleOperand2.HighPart = SIGN | 0x80000;
    04020     Fsr.Data = SubtractDouble(ROUND_TO_NEAREST,
    04021                               &DoubleOperand1,
    04022                               &DoubleOperand2,
    04023                               &DoubleResult);
    04024
    04025     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    04026         (DoubleResult.LowPart != 0x0) ||
    04027         (DoubleResult.HighPart != 0x100000)) {
    04028         goto TestFailed;
    04029     }
    04030
    04031     Subtest += 1;
    04032     DoubleOperand1.LowPart = 0x0;
    04033     DoubleOperand1.HighPart = 0x100000;
    04034     DoubleOperand2.LowPart = 0x0;
    04035     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04036     Fsr.Data = SubtractDouble(ROUND_TO_NEAREST,
    04037                               &DoubleOperand1,
    04038                               &DoubleOperand2,
    04039                               &DoubleResult);
    04040
    04041     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    04042         (DoubleResult.LowPart != 0x0) ||
    04043         (DoubleResult.HighPart != 0x1fffff)) {
    04044         goto TestFailed;
    04045     }
    04046
    04047     Subtest += 1;
    04048     DoubleOperand1.LowPart = 0x0;
    04049     DoubleOperand1.HighPart = 0x80000;
    04050     DoubleOperand2.LowPart = 0x0;
    04051     DoubleOperand2.HighPart = SIGN | 0x1600000;
    04052     Fsr.Data = SubtractDouble(ROUND_TO_NEAREST,
    04053                               &DoubleOperand1,
    04054                               &DoubleOperand2,
    04055                               &DoubleResult);
    04056
    04057     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    04058         (DoubleResult.LowPart != 0x40000000) ||
    04059         (DoubleResult.HighPart != 0x1600000)) {
    04060         goto TestFailed;
    04061     }
    04062
    04063     Subtest += 1;
    04064     DoubleOperand1.LowPart = 0x0;
    04065     DoubleOperand1.HighPart = 0x80000;
    04066     DoubleOperand2.LowPart = 0x0;
    04067     DoubleOperand2.HighPart = SIGN | 0x2600000;
    04068     Fsr.Data = SubtractDouble(ROUND_TO_NEAREST,
    04069                               &DoubleOperand1,
    04070                               &DoubleOperand2,
    04071                               &DoubleResult);
    04072
    04073     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    04074         (DoubleResult.LowPart != 0x4000) ||
    04075         (DoubleResult.HighPart != 0x2600000)) {
    04076         goto TestFailed;
    04077     }
    04078
    04079     Subtest += 1;
    04080     DoubleOperand1.LowPart = 0x0;
    04081     DoubleOperand1.HighPart = 0x80000;
    04082     DoubleOperand2.LowPart = 0x0;
    04083     DoubleOperand2.HighPart = SIGN | 0x3f000000;
    04084     Fsr.Data = SubtractDouble(ROUND_TO_NEAREST,
    04085                               &DoubleOperand1,
    04086                               &DoubleOperand2,
    04087                               &DoubleResult);
    04088
    04089     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    04090         (DoubleResult.LowPart != 0x0) ||
    04091         (DoubleResult.HighPart != 0x3f000000)) {
    04092         goto TestFailed;
    04093     }
    04094
    04095     Subtest += 1;
    04096     DoubleOperand1.LowPart = 0x0;
    04097     DoubleOperand1.HighPart = 0x80000;
    04098     DoubleOperand2.LowPart = 0x0;
    04099     DoubleOperand2.HighPart = SIGN | 0x3ff00000;
    04100     Count = 0;
    04101     try {
    04102         Fsr.Data = SubtractDouble(EI | ROUND_TO_NEAREST,
    04103                                   &DoubleOperand1,
    04104                                   &DoubleOperand2,
    04105                                   &DoubleResult);
    04106
    04107     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    04108               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    04109         Count += 1;
    04110     }
    04111
    04112     if (Count == 0) {
    04113         goto TestFailed;
    04114     }
    04115
    04116     Subtest += 1;
    04117     DoubleOperand1.LowPart = 0x0;
    04118     DoubleOperand1.HighPart = 0x7fe00000;
    04119     DoubleOperand2.LowPart = 0x0;
    04120     DoubleOperand2.HighPart = SIGN | 0x7fe00000;
    04121     Count = 0;
    04122     try {
    04123         Fsr.Data = SubtractDouble(EO | ROUND_TO_NEAREST,
    04124                                   &DoubleOperand1,
    04125                                   &DoubleOperand2,
    04126                                   &DoubleResult);
    04127
    04128     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    04129               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    04130         Count += 1;
    04131     }
    04132
    04133     if (Count == 0) {
    04134         goto TestFailed;
    04135     }
    04136
    04137     Subtest += 1;
    04138     DoubleOperand1.LowPart = 0x0;
    04139     DoubleOperand1.HighPart = 0x7fe00000;
    04140     DoubleOperand2.LowPart = 0x0;
    04141     DoubleOperand2.HighPart = SIGN | 0x7fe00000;
    04142     Count = 0;
    04143     try {
    04144         Fsr.Data = SubtractDouble(EI | ROUND_TO_NEAREST,
    04145                                   &DoubleOperand1,
    04146                                   &DoubleOperand2,
    04147                                   &DoubleResult);
    04148
    04149     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    04150               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    04151         Count += 1;
    04152     }
    04153
    04154     if (Count == 0) {
    04155         goto TestFailed;
    04156     }
    04157
    04158     Subtest += 1;
    04159     DoubleOperand1.LowPart = 0x0;
    04160     DoubleOperand1.HighPart = 0x7fe00000;
    04161     DoubleOperand2.LowPart = 0x0;
    04162     DoubleOperand2.HighPart = SIGN | 0x7fe00000;
    04163     Count = 0;
    04164     try {
    04165         Fsr.Data = SubtractDouble(EI | EO | ROUND_TO_NEAREST,
    04166                                   &DoubleOperand1,
    04167                                   &DoubleOperand2,
    04168                                   &DoubleResult);
    04169
    04170     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    04171               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    04172         Count += 1;
    04173     }
    04174
    04175     if (Count == 0) {
    04176         goto TestFailed;
    04177     }
    04178
    04179     //
    04180     // End of test 11.
    04181     //
    04182
    04183     printf("succeeded\n");
    04184     return;
    04185
    04186     //
    04187     // Test 11 failed.
    04188     //
    04189
    04190 TestFailed:
    04191     printf(" subtest %d failed, fsr = %lx, result = %lx, %lx\n",
    04192            Subtest,
    04193            Fsr.Data,
    04194            DoubleResult.LowPart,
    04195            DoubleResult.HighPart);
    04196
    04197     return;
    04198 }
    04199
    04200 VOID
    04201 Test12 (
    04202     VOID
    04203     )
    04204
    04205 {
    04206
    04207     ULONG Count;
    04208     ULARGE_INTEGER DoubleOperand1;
    04209     ULARGE_INTEGER DoubleOperand2;
    04210     ULARGE_INTEGER DoubleResult;
    04211     FLOATING_STATUS Fsr;
    04212     ULONG Subtest;
    04213
    04214     //
    04215     // Test 12 - Add double round to nearest test.
    04216     //
    04217
    04218     Subtest = 0;
    04219     printf("    Test 12 - add double round to nearest ...");
    04220     Subtest += 1;
    04221     DoubleOperand1.LowPart = 0x0;
    04222     DoubleOperand1.HighPart = 0x300000;
    04223     DoubleOperand2.LowPart = 0xfffffff8;
    04224     DoubleOperand2.HighPart = 0xfffff;
    04225     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    04226                          &DoubleOperand1,
    04227                          &DoubleOperand2,
    04228                          &DoubleResult);
    04229
    04230     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    04231         (DoubleResult.LowPart != 0xfffffffe) ||
    04232         (DoubleResult.HighPart != 0x33ffff)) {
    04233         goto TestFailed;
    04234     }
    04235
    04236     Subtest += 1;
    04237     DoubleOperand1.LowPart = 0x0;
    04238     DoubleOperand1.HighPart = 0x300000;
    04239     DoubleOperand2.LowPart = 0xfffffff9;
    04240     DoubleOperand2.HighPart = 0xfffff;
    04241     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    04242                          &DoubleOperand1,
    04243                          &DoubleOperand2,
    04244                          &DoubleResult);
    04245
    04246     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    04247         (DoubleResult.LowPart != 0xfffffffe) ||
    04248         (DoubleResult.HighPart != 0x33ffff)) {
    04249         goto TestFailed;
    04250     }
    04251
    04252     Subtest += 1;
    04253     DoubleOperand1.LowPart = 0x0;
    04254     DoubleOperand1.HighPart = 0x300000;
    04255     DoubleOperand2.LowPart = 0xfffffffa;
    04256     DoubleOperand2.HighPart = 0xfffff;
    04257     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    04258                          &DoubleOperand1,
    04259                          &DoubleOperand2,
    04260                          &DoubleResult);
    04261
    04262     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    04263         (DoubleResult.LowPart != 0xfffffffe) ||
    04264         (DoubleResult.HighPart != 0x33ffff)) {
    04265         goto TestFailed;
    04266     }
    04267
    04268     Subtest += 1;
    04269     DoubleOperand1.LowPart = 0x0;
    04270     DoubleOperand1.HighPart = 0x300000;
    04271     DoubleOperand2.LowPart = 0xfffffffb;
    04272     DoubleOperand2.HighPart = 0xfffff;
    04273     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    04274                          &DoubleOperand1,
    04275                          &DoubleOperand2,
    04276                          &DoubleResult);
    04277
    04278     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    04279         (DoubleResult.LowPart != 0xffffffff) ||
    04280         (DoubleResult.HighPart != 0x33ffff)) {
    04281         goto TestFailed;
    04282     }
    04283
    04284     Subtest += 1;
    04285     DoubleOperand1.LowPart = 0x0;
    04286     DoubleOperand1.HighPart = 0x300000;
    04287     DoubleOperand2.LowPart = 0xfffffffc;
    04288     DoubleOperand2.HighPart = 0xfffff;
    04289     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    04290                          &DoubleOperand1,
    04291                          &DoubleOperand2,
    04292                          &DoubleResult);
    04293
    04294     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    04295         (DoubleResult.LowPart != 0xffffffff) ||
    04296         (DoubleResult.HighPart != 0x33ffff)) {
    04297         goto TestFailed;
    04298     }
    04299
    04300     Subtest += 1;
    04301     DoubleOperand1.LowPart = 0x0;
    04302     DoubleOperand1.HighPart = 0x300000;
    04303     DoubleOperand2.LowPart = 0xfffffffd;
    04304     DoubleOperand2.HighPart = 0xfffff;
    04305     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    04306                          &DoubleOperand1,
    04307                          &DoubleOperand2,
    04308                          &DoubleResult);
    04309
    04310     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    04311         (DoubleResult.LowPart != 0xffffffff) ||
    04312         (DoubleResult.HighPart != 0x33ffff)) {
    04313         goto TestFailed;
    04314     }
    04315
    04316     Subtest += 1;
    04317     DoubleOperand1.LowPart = 0x0;
    04318     DoubleOperand1.HighPart = 0x300000;
    04319     DoubleOperand2.LowPart = 0xfffffffe;
    04320     DoubleOperand2.HighPart = 0xfffff;
    04321     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    04322                          &DoubleOperand1,
    04323                          &DoubleOperand2,
    04324                          &DoubleResult);
    04325
    04326     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    04327         (DoubleResult.LowPart != 0x0) ||
    04328         (DoubleResult.HighPart != 0x340000)) {
    04329         goto TestFailed;
    04330     }
    04331
    04332     Subtest += 1;
    04333     DoubleOperand1.LowPart = 0x0;
    04334     DoubleOperand1.HighPart = 0x300000;
    04335     DoubleOperand2.LowPart = 0xffffffff;
    04336     DoubleOperand2.HighPart = 0xfffff;
    04337     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    04338                          &DoubleOperand1,
    04339                          &DoubleOperand2,
    04340                          &DoubleResult);
    04341
    04342     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    04343         (DoubleResult.LowPart != 0x0) ||
    04344         (DoubleResult.HighPart != 0x340000)) {
    04345         goto TestFailed;
    04346     }
    04347
    04348     Subtest += 1;
    04349     DoubleOperand1.LowPart = 0x0;
    04350     DoubleOperand1.HighPart = 0x300000;
    04351     DoubleOperand2.LowPart = 0xffffffff;
    04352     DoubleOperand2.HighPart = 0xfffff;
    04353     Count = 0;
    04354     try {
    04355         Fsr.Data = AddDouble(EI | ROUND_TO_NEAREST,
    04356                              &DoubleOperand1,
    04357                              &DoubleOperand2,
    04358                              &DoubleResult);
    04359
    04360     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    04361               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    04362         Count += 1;
    04363     }
    04364
    04365     if (Count == 0) {
    04366         goto TestFailed;
    04367     }
    04368
    04369     //
    04370     // End of test 12.
    04371     //
    04372
    04373     printf("succeeded\n");
    04374     return;
    04375
    04376     //
    04377     // Test 12 failed.
    04378     //
    04379
    04380 TestFailed:
    04381     printf(" subtest %d failed, fsr = %lx, result = %lx, %lx\n",
    04382            Subtest,
    04383            Fsr.Data,
    04384            DoubleResult.LowPart,
    04385            DoubleResult.HighPart);
    04386
    04387     return;
    04388 }
    04389
    04390 VOID
    04391 Test13 (
    04392     VOID
    04393     )
    04394
    04395 {
    04396
    04397     ULONG Count;
    04398     ULARGE_INTEGER DoubleOperand1;
    04399     ULARGE_INTEGER DoubleOperand2;
    04400     ULARGE_INTEGER DoubleResult;
    04401     FLOATING_STATUS Fsr;
    04402     ULONG Subtest;
    04403
    04404     //
    04405     // Test 13 - Add double round to zero test.
    04406     //
    04407
    04408     Subtest = 0;
    04409     printf("    Test 13 - add double round to zero ...");
    04410     Subtest += 1;
    04411     DoubleOperand1.LowPart = 0x0;
    04412     DoubleOperand1.HighPart = 0x300000;
    04413     DoubleOperand2.LowPart = 0xfffffff8;
    04414     DoubleOperand2.HighPart = 0xfffff;
    04415     Fsr.Data = AddDouble(ROUND_TO_ZERO,
    04416                          &DoubleOperand1,
    04417                          &DoubleOperand2,
    04418                          &DoubleResult);
    04419
    04420     if ((Fsr.Data != ROUND_TO_ZERO) ||
    04421         (DoubleResult.LowPart != 0xfffffffe) ||
    04422         (DoubleResult.HighPart != 0x33ffff)) {
    04423         goto TestFailed;
    04424     }
    04425
    04426     Subtest += 1;
    04427     DoubleOperand1.LowPart = 0x0;
    04428     DoubleOperand1.HighPart = 0x300000;
    04429     DoubleOperand2.LowPart = 0xfffffff9;
    04430     DoubleOperand2.HighPart = 0xfffff;
    04431     Fsr.Data = AddDouble(ROUND_TO_ZERO,
    04432                          &DoubleOperand1,
    04433                          &DoubleOperand2,
    04434                          &DoubleResult);
    04435
    04436     if ((Fsr.Data != (SI | ROUND_TO_ZERO)) ||
    04437         (DoubleResult.LowPart != 0xfffffffe) ||
    04438         (DoubleResult.HighPart != 0x33ffff)) {
    04439         goto TestFailed;
    04440     }
    04441
    04442     Subtest += 1;
    04443     DoubleOperand1.LowPart = 0x0;
    04444     DoubleOperand1.HighPart = 0x300000;
    04445     DoubleOperand2.LowPart = 0xfffffffa;
    04446     DoubleOperand2.HighPart = 0xfffff;
    04447     Fsr.Data = AddDouble(ROUND_TO_ZERO,
    04448                          &DoubleOperand1,
    04449                          &DoubleOperand2,
    04450                          &DoubleResult);
    04451
    04452     if ((Fsr.Data != (SI | ROUND_TO_ZERO)) ||
    04453         (DoubleResult.LowPart != 0xfffffffe) ||
    04454         (DoubleResult.HighPart != 0x33ffff)) {
    04455         goto TestFailed;
    04456     }
    04457
    04458     Subtest += 1;
    04459     DoubleOperand1.LowPart = 0x0;
    04460     DoubleOperand1.HighPart = 0x300000;
    04461     DoubleOperand2.LowPart = 0xfffffffb;
    04462     DoubleOperand2.HighPart = 0xfffff;
    04463     Fsr.Data = AddDouble(ROUND_TO_ZERO,
    04464                          &DoubleOperand1,
    04465                          &DoubleOperand2,
    04466                          &DoubleResult);
    04467
    04468     if ((Fsr.Data != (SI | ROUND_TO_ZERO)) ||
    04469         (DoubleResult.LowPart != 0xfffffffe) ||
    04470         (DoubleResult.HighPart != 0x33ffff)) {
    04471         goto TestFailed;
    04472     }
    04473
    04474     Subtest += 1;
    04475     DoubleOperand1.LowPart = 0x0;
    04476     DoubleOperand1.HighPart = 0x300000;
    04477     DoubleOperand2.LowPart = 0xfffffffc;
    04478     DoubleOperand2.HighPart = 0xfffff;
    04479     Fsr.Data = AddDouble(ROUND_TO_ZERO,
    04480                          &DoubleOperand1,
    04481                          &DoubleOperand2,
    04482                          &DoubleResult);
    04483
    04484     if ((Fsr.Data != ROUND_TO_ZERO) ||
    04485         (DoubleResult.LowPart != 0xffffffff) ||
    04486         (DoubleResult.HighPart != 0x33ffff)) {
    04487         goto TestFailed;
    04488     }
    04489
    04490     Subtest += 1;
    04491     DoubleOperand1.LowPart = 0x0;
    04492     DoubleOperand1.HighPart = 0x300000;
    04493     DoubleOperand2.LowPart = 0xfffffffd;
    04494     DoubleOperand2.HighPart = 0xfffff;
    04495     Fsr.Data = AddDouble(ROUND_TO_ZERO,
    04496                          &DoubleOperand1,
    04497                          &DoubleOperand2,
    04498                          &DoubleResult);
    04499
    04500     if ((Fsr.Data != (SI | ROUND_TO_ZERO)) ||
    04501         (DoubleResult.LowPart != 0xffffffff) ||
    04502         (DoubleResult.HighPart != 0x33ffff)) {
    04503         goto TestFailed;
    04504     }
    04505
    04506     Subtest += 1;
    04507     DoubleOperand1.LowPart = 0x0;
    04508     DoubleOperand1.HighPart = 0x300000;
    04509     DoubleOperand2.LowPart = 0xfffffffe;
    04510     DoubleOperand2.HighPart = 0xfffff;
    04511     Fsr.Data = AddDouble(ROUND_TO_ZERO,
    04512                          &DoubleOperand1,
    04513                          &DoubleOperand2,
    04514                          &DoubleResult);
    04515
    04516     if ((Fsr.Data != (SI | ROUND_TO_ZERO)) ||
    04517         (DoubleResult.LowPart != 0xffffffff) ||
    04518         (DoubleResult.HighPart != 0x33ffff)) {
    04519         goto TestFailed;
    04520     }
    04521
    04522     Subtest += 1;
    04523     DoubleOperand1.LowPart = 0x0;
    04524     DoubleOperand1.HighPart = 0x300000;
    04525     DoubleOperand2.LowPart = 0xffffffff;
    04526     DoubleOperand2.HighPart = 0xfffff;
    04527     Fsr.Data = AddDouble(ROUND_TO_ZERO,
    04528                          &DoubleOperand1,
    04529                          &DoubleOperand2,
    04530                          &DoubleResult);
    04531
    04532     if ((Fsr.Data != (SI | ROUND_TO_ZERO)) ||
    04533         (DoubleResult.LowPart != 0xffffffff) ||
    04534         (DoubleResult.HighPart != 0x33ffff)) {
    04535         goto TestFailed;
    04536     }
    04537
    04538     Subtest += 1;
    04539     DoubleOperand1.LowPart = 0x0;
    04540     DoubleOperand1.HighPart = 0x300000;
    04541     DoubleOperand2.LowPart = 0xffffffff;
    04542     DoubleOperand2.HighPart = 0xfffff;
    04543     Count = 0;
    04544     try {
    04545         Fsr.Data = AddDouble(EI | ROUND_TO_ZERO,
    04546                              &DoubleOperand1,
    04547                              &DoubleOperand2,
    04548                              &DoubleResult);
    04549
    04550     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    04551               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    04552         Count += 1;
    04553     }
    04554
    04555     if (Count == 0) {
    04556         goto TestFailed;
    04557     }
    04558
    04559     //
    04560     // End of test 13.
    04561     //
    04562
    04563     printf("succeeded\n");
    04564     return;
    04565
    04566     //
    04567     // Test 13 failed.
    04568     //
    04569
    04570 TestFailed:
    04571     printf(" subtest %d failed, fsr = %lx, result = %lx, %lx\n",
    04572            Subtest,
    04573            Fsr.Data,
    04574            DoubleResult.LowPart,
    04575            DoubleResult.HighPart);
    04576
    04577     return;
    04578 }
    04579
    04580 VOID
    04581 Test14 (
    04582     VOID
    04583     )
    04584
    04585 {
    04586
    04587     ULONG Count;
    04588     ULARGE_INTEGER DoubleOperand1;
    04589     ULARGE_INTEGER DoubleOperand2;
    04590     FLOATING_STATUS Fsr;
    04591     ULARGE_INTEGER DoubleResult;
    04592     ULONG Subtest;
    04593
    04594     //
    04595     // Test 14 - Add double round to positive infinity test.
    04596     //
    04597
    04598     Subtest = 0;
    04599     printf("    Test 14 - add double round to positive infinity ...");
    04600     Subtest += 1;
    04601     DoubleOperand1.LowPart = 0x0;
    04602     DoubleOperand1.HighPart = 0x300000;
    04603     DoubleOperand2.LowPart = 0xfffffff8;
    04604     DoubleOperand2.HighPart = 0xfffff;
    04605     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04606                          &DoubleOperand1,
    04607                          &DoubleOperand2,
    04608                          &DoubleResult);
    04609
    04610     if ((Fsr.Data != ROUND_TO_PLUS_INFINITY) ||
    04611         (DoubleResult.LowPart != 0xfffffffe) ||
    04612         (DoubleResult.HighPart != 0x33ffff)) {
    04613         goto TestFailed;
    04614     }
    04615
    04616     Subtest += 1;
    04617     DoubleOperand1.LowPart = 0x0;
    04618     DoubleOperand1.HighPart = 0x300000;
    04619     DoubleOperand2.LowPart = 0xfffffff9;
    04620     DoubleOperand2.HighPart = 0xfffff;
    04621     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04622                          &DoubleOperand1,
    04623                          &DoubleOperand2,
    04624                          &DoubleResult);
    04625
    04626     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    04627         (DoubleResult.LowPart != 0xffffffff) ||
    04628         (DoubleResult.HighPart != 0x33ffff)) {
    04629         goto TestFailed;
    04630     }
    04631
    04632     Subtest += 1;
    04633     DoubleOperand1.LowPart = 0x0;
    04634     DoubleOperand1.HighPart = 0x300000;
    04635     DoubleOperand2.LowPart = 0xfffffffa;
    04636     DoubleOperand2.HighPart = 0xfffff;
    04637     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04638                          &DoubleOperand1,
    04639                          &DoubleOperand2,
    04640                          &DoubleResult);
    04641
    04642     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    04643         (DoubleResult.LowPart != 0xffffffff) ||
    04644         (DoubleResult.HighPart != 0x33ffff)) {
    04645         goto TestFailed;
    04646     }
    04647
    04648     Subtest += 1;
    04649     DoubleOperand1.LowPart = 0x0;
    04650     DoubleOperand1.HighPart = 0x300000;
    04651     DoubleOperand2.LowPart = 0xfffffffb;
    04652     DoubleOperand2.HighPart = 0xfffff;
    04653     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04654                          &DoubleOperand1,
    04655                          &DoubleOperand2,
    04656                          &DoubleResult);
    04657
    04658     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    04659         (DoubleResult.LowPart != 0xffffffff) ||
    04660         (DoubleResult.HighPart != 0x33ffff)) {
    04661         goto TestFailed;
    04662     }
    04663
    04664     Subtest += 1;
    04665     DoubleOperand1.LowPart = 0x0;
    04666     DoubleOperand1.HighPart = 0x300000;
    04667     DoubleOperand2.LowPart = 0xfffffffc;
    04668     DoubleOperand2.HighPart = 0xfffff;
    04669     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04670                          &DoubleOperand1,
    04671                          &DoubleOperand2,
    04672                          &DoubleResult);
    04673
    04674     if ((Fsr.Data != ROUND_TO_PLUS_INFINITY) ||
    04675         (DoubleResult.LowPart != 0xffffffff) ||
    04676         (DoubleResult.HighPart != 0x33ffff)) {
    04677         goto TestFailed;
    04678     }
    04679
    04680     Subtest += 1;
    04681     DoubleOperand1.LowPart = 0x0;
    04682     DoubleOperand1.HighPart = 0x300000;
    04683     DoubleOperand2.LowPart = 0xfffffffd;
    04684     DoubleOperand2.HighPart = 0xfffff;
    04685     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04686                          &DoubleOperand1,
    04687                          &DoubleOperand2,
    04688                          &DoubleResult);
    04689
    04690     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    04691         (DoubleResult.LowPart != 0x0) ||
    04692         (DoubleResult.HighPart != 0x340000)) {
    04693         goto TestFailed;
    04694     }
    04695
    04696     Subtest += 1;
    04697     DoubleOperand1.LowPart = 0x0;
    04698     DoubleOperand1.HighPart = 0x300000;
    04699     DoubleOperand2.LowPart = 0xfffffffe;
    04700     DoubleOperand2.HighPart = 0xfffff;
    04701     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04702                          &DoubleOperand1,
    04703                          &DoubleOperand2,
    04704                          &DoubleResult);
    04705
    04706     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    04707         (DoubleResult.LowPart != 0x0) ||
    04708         (DoubleResult.HighPart != 0x340000)) {
    04709         goto TestFailed;
    04710     }
    04711
    04712     Subtest += 1;
    04713     DoubleOperand1.LowPart = 0x0;
    04714     DoubleOperand1.HighPart = 0x300000;
    04715     DoubleOperand2.LowPart = 0xffffffff;
    04716     DoubleOperand2.HighPart = 0xfffff;
    04717     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04718                          &DoubleOperand1,
    04719                          &DoubleOperand2,
    04720                          &DoubleResult);
    04721
    04722     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    04723         (DoubleResult.LowPart != 0x0) ||
    04724         (DoubleResult.HighPart != 0x340000)) {
    04725         goto TestFailed;
    04726     }
    04727
    04728     Subtest += 1;
    04729     DoubleOperand1.LowPart = 0x0;
    04730     DoubleOperand1.HighPart = 0x300000;
    04731     DoubleOperand2.LowPart = 0xffffffff;
    04732     DoubleOperand2.HighPart = 0xfffff;
    04733     Count = 0;
    04734     try {
    04735         Fsr.Data = AddDouble(EI | ROUND_TO_PLUS_INFINITY,
    04736                              &DoubleOperand1,
    04737                              &DoubleOperand2,
    04738                              &DoubleResult);
    04739
    04740     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    04741               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    04742         Count += 1;
    04743     }
    04744
    04745     if (Count == 0) {
    04746         goto TestFailed;
    04747     }
    04748
    04749     Subtest += 1;
    04750     DoubleOperand1.LowPart = 0x0;
    04751     DoubleOperand1.HighPart = SIGN | 0x300000;
    04752     DoubleOperand2.LowPart = 0xfffffff8;
    04753     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04754     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04755                          &DoubleOperand1,
    04756                          &DoubleOperand2,
    04757                          &DoubleResult);
    04758
    04759     if ((Fsr.Data != ROUND_TO_PLUS_INFINITY) ||
    04760         (DoubleResult.LowPart != 0xfffffffe) ||
    04761         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04762         goto TestFailed;
    04763     }
    04764
    04765     Subtest += 1;
    04766     DoubleOperand1.LowPart = 0x0;
    04767     DoubleOperand1.HighPart = SIGN | 0x300000;
    04768     DoubleOperand2.LowPart = 0xfffffff9;
    04769     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04770     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04771                          &DoubleOperand1,
    04772                          &DoubleOperand2,
    04773                          &DoubleResult);
    04774
    04775     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    04776         (DoubleResult.LowPart != 0xfffffffe) ||
    04777         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04778         goto TestFailed;
    04779     }
    04780
    04781     Subtest += 1;
    04782     DoubleOperand1.LowPart = 0x0;
    04783     DoubleOperand1.HighPart = SIGN | 0x300000;
    04784     DoubleOperand2.LowPart = 0xfffffffa;
    04785     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04786     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04787                          &DoubleOperand1,
    04788                          &DoubleOperand2,
    04789                          &DoubleResult);
    04790
    04791     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    04792         (DoubleResult.LowPart != 0xfffffffe) ||
    04793         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04794         goto TestFailed;
    04795     }
    04796
    04797     Subtest += 1;
    04798     DoubleOperand1.LowPart = 0x0;
    04799     DoubleOperand1.HighPart = SIGN | 0x300000;
    04800     DoubleOperand2.LowPart = 0xfffffffb;
    04801     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04802     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04803                          &DoubleOperand1,
    04804                          &DoubleOperand2,
    04805                          &DoubleResult);
    04806
    04807     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    04808         (DoubleResult.LowPart != 0xfffffffe) ||
    04809         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04810         goto TestFailed;
    04811     }
    04812
    04813     Subtest += 1;
    04814     DoubleOperand1.LowPart = 0x0;
    04815     DoubleOperand1.HighPart = SIGN | 0x300000;
    04816     DoubleOperand2.LowPart = 0xfffffffc;
    04817     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04818     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04819                          &DoubleOperand1,
    04820                          &DoubleOperand2,
    04821                          &DoubleResult);
    04822
    04823     if ((Fsr.Data != ROUND_TO_PLUS_INFINITY) ||
    04824         (DoubleResult.LowPart != 0xffffffff) ||
    04825         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04826         goto TestFailed;
    04827     }
    04828
    04829     Subtest += 1;
    04830     DoubleOperand1.LowPart = 0x0;
    04831     DoubleOperand1.HighPart = SIGN | 0x300000;
    04832     DoubleOperand2.LowPart = 0xfffffffd;
    04833     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04834     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04835                          &DoubleOperand1,
    04836                          &DoubleOperand2,
    04837                          &DoubleResult);
    04838
    04839     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    04840         (DoubleResult.LowPart != 0xffffffff) ||
    04841         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04842         goto TestFailed;
    04843     }
    04844
    04845     Subtest += 1;
    04846     DoubleOperand1.LowPart = 0x0;
    04847     DoubleOperand1.HighPart = SIGN | 0x300000;
    04848     DoubleOperand2.LowPart = 0xfffffffe;
    04849     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04850     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04851                          &DoubleOperand1,
    04852                          &DoubleOperand2,
    04853                          &DoubleResult);
    04854
    04855     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    04856         (DoubleResult.LowPart != 0xffffffff) ||
    04857         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04858         goto TestFailed;
    04859     }
    04860
    04861     Subtest += 1;
    04862     DoubleOperand1.LowPart = 0x0;
    04863     DoubleOperand1.HighPart = SIGN | 0x300000;
    04864     DoubleOperand2.LowPart = 0xffffffff;
    04865     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04866     Fsr.Data = AddDouble(ROUND_TO_PLUS_INFINITY,
    04867                          &DoubleOperand1,
    04868                          &DoubleOperand2,
    04869                          &DoubleResult);
    04870
    04871     if ((Fsr.Data != (SI | ROUND_TO_PLUS_INFINITY)) ||
    04872         (DoubleResult.LowPart != 0xffffffff) ||
    04873         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04874         goto TestFailed;
    04875     }
    04876
    04877     //
    04878     // End of test 14.
    04879     //
    04880
    04881     printf("succeeded\n");
    04882     return;
    04883
    04884     //
    04885     // Test 14 failed.
    04886     //
    04887
    04888 TestFailed:
    04889     printf(" subtest %d failed, fsr = %lx, result = %lx, %lx\n",
    04890            Subtest,
    04891            Fsr.Data,
    04892            DoubleResult.LowPart,
    04893            DoubleResult.HighPart);
    04894
    04895     return;
    04896 }
    04897
    04898 VOID
    04899 Test15 (
    04900     VOID
    04901     )
    04902
    04903 {
    04904
    04905     ULONG Count;
    04906     ULARGE_INTEGER DoubleOperand1;
    04907     ULARGE_INTEGER DoubleOperand2;
    04908     ULARGE_INTEGER DoubleResult;
    04909     FLOATING_STATUS Fsr;
    04910     ULONG Subtest;
    04911
    04912     //
    04913     // Test 15 - Add double round to negative infinity test.
    04914     //
    04915
    04916     Subtest = 0;
    04917     printf("    Test 15 - add double round to negative infinity ...");
    04918     Subtest += 1;
    04919     DoubleOperand1.LowPart = 0x0;
    04920     DoubleOperand1.HighPart = SIGN | 0x300000;
    04921     DoubleOperand2.LowPart = 0xfffffff8;
    04922     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04923     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    04924                          &DoubleOperand1,
    04925                          &DoubleOperand2,
    04926                          &DoubleResult);
    04927
    04928     if ((Fsr.Data != ROUND_TO_MINUS_INFINITY) ||
    04929         (DoubleResult.LowPart != 0xfffffffe) ||
    04930         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04931         goto TestFailed;
    04932     }
    04933
    04934     Subtest += 1;
    04935     DoubleOperand1.LowPart = 0x0;
    04936     DoubleOperand1.HighPart = SIGN | 0x300000;
    04937     DoubleOperand2.LowPart = 0xfffffff9;
    04938     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04939     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    04940                          &DoubleOperand1,
    04941                          &DoubleOperand2,
    04942                          &DoubleResult);
    04943
    04944     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    04945         (DoubleResult.LowPart != 0xffffffff) ||
    04946         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04947         goto TestFailed;
    04948     }
    04949
    04950     Subtest += 1;
    04951     DoubleOperand1.LowPart = 0x0;
    04952     DoubleOperand1.HighPart = SIGN | 0x300000;
    04953     DoubleOperand2.LowPart = 0xfffffffa;
    04954     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04955     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    04956                          &DoubleOperand1,
    04957                          &DoubleOperand2,
    04958                          &DoubleResult);
    04959
    04960     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    04961         (DoubleResult.LowPart != 0xffffffff) ||
    04962         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04963         goto TestFailed;
    04964     }
    04965
    04966     Subtest += 1;
    04967     DoubleOperand1.LowPart = 0x0;
    04968     DoubleOperand1.HighPart = SIGN | 0x300000;
    04969     DoubleOperand2.LowPart = 0xfffffffb;
    04970     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04971     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    04972                          &DoubleOperand1,
    04973                          &DoubleOperand2,
    04974                          &DoubleResult);
    04975
    04976     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    04977         (DoubleResult.LowPart != 0xffffffff) ||
    04978         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04979         goto TestFailed;
    04980     }
    04981
    04982     Subtest += 1;
    04983     DoubleOperand1.LowPart = 0x0;
    04984     DoubleOperand1.HighPart = SIGN | 0x300000;
    04985     DoubleOperand2.LowPart = 0xfffffffc;
    04986     DoubleOperand2.HighPart = SIGN | 0xfffff;
    04987     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    04988                          &DoubleOperand1,
    04989                          &DoubleOperand2,
    04990                          &DoubleResult);
    04991
    04992     if ((Fsr.Data != ROUND_TO_MINUS_INFINITY) ||
    04993         (DoubleResult.LowPart != 0xffffffff) ||
    04994         (DoubleResult.HighPart != (SIGN | 0x33ffff))) {
    04995         goto TestFailed;
    04996     }
    04997
    04998     Subtest += 1;
    04999     DoubleOperand1.LowPart = 0x0;
    05000     DoubleOperand1.HighPart = SIGN | 0x300000;
    05001     DoubleOperand2.LowPart = 0xfffffffd;
    05002     DoubleOperand2.HighPart = SIGN | 0xfffff;
    05003     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    05004                          &DoubleOperand1,
    05005                          &DoubleOperand2,
    05006                          &DoubleResult);
    05007
    05008     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    05009         (DoubleResult.LowPart != 0x0) ||
    05010         (DoubleResult.HighPart != (SIGN | 0x340000))) {
    05011         goto TestFailed;
    05012     }
    05013
    05014     Subtest += 1;
    05015     DoubleOperand1.LowPart = 0x0;
    05016     DoubleOperand1.HighPart = SIGN | 0x300000;
    05017     DoubleOperand2.LowPart = 0xfffffffe;
    05018     DoubleOperand2.HighPart = SIGN | 0xfffff;
    05019     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    05020                          &DoubleOperand1,
    05021                          &DoubleOperand2,
    05022                          &DoubleResult);
    05023
    05024     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    05025         (DoubleResult.LowPart != 0x0) ||
    05026         (DoubleResult.HighPart != (SIGN | 0x340000))) {
    05027         goto TestFailed;
    05028     }
    05029
    05030     Subtest += 1;
    05031     DoubleOperand1.LowPart = 0x0;
    05032     DoubleOperand1.HighPart = SIGN | 0x300000;
    05033     DoubleOperand2.LowPart = 0xffffffff;
    05034     DoubleOperand2.HighPart = SIGN | 0xfffff;
    05035     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    05036                          &DoubleOperand1,
    05037                          &DoubleOperand2,
    05038                          &DoubleResult);
    05039
    05040     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    05041         (DoubleResult.LowPart != 0x0) ||
    05042         (DoubleResult.HighPart != (SIGN | 0x340000))) {
    05043         goto TestFailed;
    05044     }
    05045
    05046     Subtest += 1;
    05047     DoubleOperand1.LowPart = 0x0;
    05048     DoubleOperand1.HighPart = SIGN | 0x300000;
    05049     DoubleOperand2.LowPart = 0xffffffff;
    05050     DoubleOperand2.HighPart = SIGN | 0xfffff;
    05051     Count = 0;
    05052     try {
    05053         Fsr.Data = AddDouble(EI | ROUND_TO_MINUS_INFINITY,
    05054                              &DoubleOperand1,
    05055                              &DoubleOperand2,
    05056                              &DoubleResult);
    05057
    05058     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    05059               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    05060         Count += 1;
    05061     }
    05062
    05063     if (Count == 0) {
    05064         goto TestFailed;
    05065     }
    05066
    05067     Subtest += 1;
    05068     DoubleOperand1.LowPart = 0x0;
    05069     DoubleOperand1.HighPart = 0x300000;
    05070     DoubleOperand2.LowPart = 0xfffffff8;
    05071     DoubleOperand2.HighPart = 0xfffff;
    05072     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    05073                          &DoubleOperand1,
    05074                          &DoubleOperand2,
    05075                          &DoubleResult);
    05076
    05077     if ((Fsr.Data != ROUND_TO_MINUS_INFINITY) ||
    05078         (DoubleResult.LowPart != 0xfffffffe) ||
    05079         (DoubleResult.HighPart != 0x33ffff)) {
    05080         goto TestFailed;
    05081     }
    05082
    05083     Subtest += 1;
    05084     DoubleOperand1.LowPart = 0x0;
    05085     DoubleOperand1.HighPart = 0x300000;
    05086     DoubleOperand2.LowPart = 0xfffffff9;
    05087     DoubleOperand2.HighPart = 0xfffff;
    05088     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    05089                          &DoubleOperand1,
    05090                          &DoubleOperand2,
    05091                          &DoubleResult);
    05092
    05093     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    05094         (DoubleResult.LowPart != 0xfffffffe) ||
    05095         (DoubleResult.HighPart != 0x33ffff)) {
    05096         goto TestFailed;
    05097     }
    05098
    05099     Subtest += 1;
    05100     DoubleOperand1.LowPart = 0x0;
    05101     DoubleOperand1.HighPart = 0x300000;
    05102     DoubleOperand2.LowPart = 0xfffffffa;
    05103     DoubleOperand2.HighPart = 0xfffff;
    05104     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    05105                          &DoubleOperand1,
    05106                          &DoubleOperand2,
    05107                          &DoubleResult);
    05108
    05109     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    05110         (DoubleResult.LowPart != 0xfffffffe) ||
    05111         (DoubleResult.HighPart != 0x33ffff)) {
    05112         goto TestFailed;
    05113     }
    05114
    05115     Subtest += 1;
    05116     DoubleOperand1.LowPart = 0x0;
    05117     DoubleOperand1.HighPart = 0x300000;
    05118     DoubleOperand2.LowPart = 0xfffffffb;
    05119     DoubleOperand2.HighPart = 0xfffff;
    05120     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    05121                          &DoubleOperand1,
    05122                          &DoubleOperand2,
    05123                          &DoubleResult);
    05124
    05125     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    05126         (DoubleResult.LowPart != 0xfffffffe) ||
    05127         (DoubleResult.HighPart != 0x33ffff)) {
    05128         goto TestFailed;
    05129     }
    05130
    05131     Subtest += 1;
    05132     DoubleOperand1.LowPart = 0x0;
    05133     DoubleOperand1.HighPart = 0x300000;
    05134     DoubleOperand2.LowPart = 0xfffffffc;
    05135     DoubleOperand2.HighPart = 0xfffff;
    05136     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    05137                          &DoubleOperand1,
    05138                          &DoubleOperand2,
    05139                          &DoubleResult);
    05140
    05141     if ((Fsr.Data != ROUND_TO_MINUS_INFINITY) ||
    05142         (DoubleResult.LowPart != 0xffffffff) ||
    05143         (DoubleResult.HighPart != 0x33ffff)) {
    05144         goto TestFailed;
    05145     }
    05146
    05147     Subtest += 1;
    05148     DoubleOperand1.LowPart = 0x0;
    05149     DoubleOperand1.HighPart = 0x300000;
    05150     DoubleOperand2.LowPart = 0xfffffffd;
    05151     DoubleOperand2.HighPart = 0xfffff;
    05152     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    05153                          &DoubleOperand1,
    05154                          &DoubleOperand2,
    05155                          &DoubleResult);
    05156
    05157     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    05158         (DoubleResult.LowPart != 0xffffffff) ||
    05159         (DoubleResult.HighPart != 0x33ffff)) {
    05160         goto TestFailed;
    05161     }
    05162
    05163     Subtest += 1;
    05164     DoubleOperand1.LowPart = 0x0;
    05165     DoubleOperand1.HighPart = 0x300000;
    05166     DoubleOperand2.LowPart = 0xfffffffe;
    05167     DoubleOperand2.HighPart = 0xfffff;
    05168     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    05169                          &DoubleOperand1,
    05170                          &DoubleOperand2,
    05171                          &DoubleResult);
    05172
    05173     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    05174         (DoubleResult.LowPart != 0xffffffff) ||
    05175         (DoubleResult.HighPart != 0x33ffff)) {
    05176         goto TestFailed;
    05177     }
    05178
    05179     Subtest += 1;
    05180     DoubleOperand1.LowPart = 0x0;
    05181     DoubleOperand1.HighPart = 0x300000;
    05182     DoubleOperand2.LowPart = 0xffffffff;
    05183     DoubleOperand2.HighPart = 0xfffff;
    05184     Fsr.Data = AddDouble(ROUND_TO_MINUS_INFINITY,
    05185                          &DoubleOperand1,
    05186                          &DoubleOperand2,
    05187                          &DoubleResult);
    05188
    05189     if ((Fsr.Data != (SI | ROUND_TO_MINUS_INFINITY)) ||
    05190         (DoubleResult.LowPart != 0xffffffff) ||
    05191         (DoubleResult.HighPart != 0x33ffff)) {
    05192         goto TestFailed;
    05193     }
    05194
    05195     //
    05196     // End of test 15.
    05197     //
    05198
    05199     printf("succeeded\n");
    05200     return;
    05201
    05202     //
    05203     // Test 15 failed.
    05204     //
    05205
    05206 TestFailed:
    05207     printf(" subtest %d failed, fsr = %lx, result = %lx, %lx\n",
    05208            Subtest,
    05209            Fsr.Data,
    05210            DoubleResult.LowPart,
    05211            DoubleResult.HighPart);
    05212
    05213     return;
    05214 }
    05215
    05216 VOID
    05217 Test16 (
    05218     VOID
    05219     )
    05220
    05221 {
    05222
    05223     ULONG Count;
    05224     ULARGE_INTEGER DoubleOperand1;
    05225     ULARGE_INTEGER DoubleOperand2;
    05226     ULARGE_INTEGER DoubleResult;
    05227     FLOATING_STATUS Fsr;
    05228     ULONG Subtest;
    05229
    05230     //
    05231     // Test 16 - Add double infinity and NaN test.
    05232     //
    05233
    05234     Subtest = 0;
    05235     printf("    Test 16 - add double infinity and NaN ...");
    05236
    05237     Subtest += 1;
    05238     DoubleOperand1.LowPart = 0x0;
    05239     DoubleOperand1.HighPart = 0x40000;
    05240     DoubleOperand2.LowPart = 0x0;
    05241     DoubleOperand2.HighPart = 0x40000;
    05242     Fsr.Data = AddDouble(FS | ROUND_TO_NEAREST,
    05243                          &DoubleOperand1,
    05244                          &DoubleOperand2,
    05245                          &DoubleResult);
    05246
    05247     if ((Fsr.Data != (FS | ROUND_TO_NEAREST)) ||
    05248         (DoubleResult.LowPart != 0x0) ||
    05249         (DoubleResult.HighPart != 0x0)) {
    05250         goto TestFailed;
    05251     }
    05252
    05253     Subtest += 1;
    05254     DoubleOperand1.LowPart = 0x0;
    05255     DoubleOperand1.HighPart = 0x80000;
    05256     DoubleOperand2.LowPart = 0x0;
    05257     DoubleOperand2.HighPart = DOUBLE_SIGNAL_NAN_PREFIX;
    05258     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05259                          &DoubleOperand1,
    05260                          &DoubleOperand2,
    05261                          &DoubleResult);
    05262
    05263     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    05264         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05265         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05266         goto TestFailed;
    05267     }
    05268
    05269     Subtest += 1;
    05270     DoubleOperand1.LowPart = 0x0;
    05271     DoubleOperand1.HighPart = DOUBLE_SIGNAL_NAN_PREFIX;
    05272     DoubleOperand2.LowPart = 0x0;
    05273     DoubleOperand2.HighPart = 0x80000;
    05274     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05275                          &DoubleOperand1,
    05276                          &DoubleOperand2,
    05277                          &DoubleResult);
    05278
    05279     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    05280         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05281         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05282         goto TestFailed;
    05283     }
    05284
    05285     Subtest += 1;
    05286     DoubleOperand1.LowPart = 0x0;
    05287     DoubleOperand1.HighPart = 0x80000;
    05288     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05289     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05290     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05291                          &DoubleOperand1,
    05292                          &DoubleOperand2,
    05293                          &DoubleResult);
    05294
    05295     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05296         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05297         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    05298         goto TestFailed;
    05299     }
    05300
    05301     Subtest += 1;
    05302     DoubleOperand1.LowPart = 0x0;
    05303     DoubleOperand1.HighPart = SIGN | 0x80000;
    05304     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05305     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05306     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05307                          &DoubleOperand1,
    05308                          &DoubleOperand2,
    05309                          &DoubleResult);
    05310
    05311     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05312         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05313         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    05314         goto TestFailed;
    05315     }
    05316
    05317     Subtest += 1;
    05318     DoubleOperand1.LowPart = 0x0;
    05319     DoubleOperand1.HighPart = 0x80000;
    05320     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05321     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05322     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05323                          &DoubleOperand1,
    05324                          &DoubleOperand2,
    05325                          &DoubleResult);
    05326
    05327     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05328         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05329         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    05330         goto TestFailed;
    05331     }
    05332
    05333     Subtest += 1;
    05334     DoubleOperand1.LowPart = 0x0;
    05335     DoubleOperand1.HighPart = SIGN | 0x80000;
    05336     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05337     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05338     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05339                          &DoubleOperand1,
    05340                          &DoubleOperand2,
    05341                          &DoubleResult);
    05342
    05343     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05344         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05345         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    05346         goto TestFailed;
    05347     }
    05348
    05349     Subtest += 1;
    05350     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05351     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05352     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05353     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05354     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05355                          &DoubleOperand1,
    05356                          &DoubleOperand2,
    05357                          &DoubleResult);
    05358
    05359     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05360         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05361         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    05362         goto TestFailed;
    05363     }
    05364
    05365     Subtest += 1;
    05366     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05367     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05368     DoubleOperand2.LowPart = 0x0;
    05369     DoubleOperand2.HighPart = 0x3ff00000;
    05370     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05371                          &DoubleOperand1,
    05372                          &DoubleOperand2,
    05373                          &DoubleResult);
    05374
    05375     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05376         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05377         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    05378         goto TestFailed;
    05379     }
    05380
    05381     Subtest += 1;
    05382     DoubleOperand1.LowPart = 0x0;
    05383     DoubleOperand1.HighPart = 0x3ff00000;
    05384     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05385     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05386     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05387                          &DoubleOperand1,
    05388                          &DoubleOperand2,
    05389                          &DoubleResult);
    05390
    05391     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05392         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05393         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    05394         goto TestFailed;
    05395     }
    05396
    05397     Subtest += 1;
    05398     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05399     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05400     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05401     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05402     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05403                          &DoubleOperand1,
    05404                          &DoubleOperand2,
    05405                          &DoubleResult);
    05406
    05407     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05408         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05409         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    05410         goto TestFailed;
    05411     }
    05412
    05413     Subtest += 1;
    05414     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05415     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05416     DoubleOperand2.LowPart = 0x0;
    05417     DoubleOperand2.HighPart = 0x3ff00000;
    05418     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05419                          &DoubleOperand1,
    05420                          &DoubleOperand2,
    05421                          &DoubleResult);
    05422
    05423     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05424         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05425         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    05426         goto TestFailed;
    05427     }
    05428
    05429     Subtest += 1;
    05430     DoubleOperand1.LowPart = 0x0;
    05431     DoubleOperand1.HighPart = 0x3ff00000;
    05432     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05433     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05434     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05435                          &DoubleOperand1,
    05436                          &DoubleOperand2,
    05437                          &DoubleResult);
    05438
    05439     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05440         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05441         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    05442         goto TestFailed;
    05443     }
    05444
    05445     Subtest += 1;
    05446     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05447     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05448     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05449     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05450     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05451                          &DoubleOperand1,
    05452                          &DoubleOperand2,
    05453                          &DoubleResult);
    05454
    05455     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    05456         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05457         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05458         goto TestFailed;
    05459     }
    05460
    05461     Subtest += 1;
    05462     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05463     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05464     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05465     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05466     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05467                          &DoubleOperand1,
    05468                          &DoubleOperand2,
    05469                          &DoubleResult);
    05470
    05471     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    05472         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05473         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05474         goto TestFailed;
    05475     }
    05476
    05477     Subtest += 1;
    05478     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    05479     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    05480     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    05481     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    05482     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05483                          &DoubleOperand1,
    05484                          &DoubleOperand2,
    05485                          &DoubleResult);
    05486
    05487     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    05488         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05489         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05490         goto TestFailed;
    05491     }
    05492
    05493     Subtest += 1;
    05494     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    05495     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    05496     DoubleOperand2.LowPart = 0x0;
    05497     DoubleOperand2.HighPart = 0x3ff00000;
    05498     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05499                          &DoubleOperand1,
    05500                          &DoubleOperand2,
    05501                          &DoubleResult);
    05502
    05503     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    05504         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05505         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05506         goto TestFailed;
    05507     }
    05508
    05509     Subtest += 1;
    05510     DoubleOperand1.LowPart = 0x0;
    05511     DoubleOperand1.HighPart = 0x3ff00000;
    05512     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    05513     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    05514     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05515                          &DoubleOperand1,
    05516                          &DoubleOperand2,
    05517                          &DoubleResult);
    05518
    05519     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    05520         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05521         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05522         goto TestFailed;
    05523     }
    05524
    05525     Subtest += 1;
    05526     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    05527     DoubleOperand1.HighPart = DOUBLE_SIGNAL_NAN;
    05528     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    05529     DoubleOperand2.HighPart = DOUBLE_SIGNAL_NAN;
    05530     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05531                          &DoubleOperand1,
    05532                          &DoubleOperand2,
    05533                          &DoubleResult);
    05534
    05535     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    05536         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05537         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05538         goto TestFailed;
    05539     }
    05540
    05541     Subtest += 1;
    05542     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    05543     DoubleOperand1.HighPart = DOUBLE_SIGNAL_NAN;
    05544     DoubleOperand2.LowPart = 0x0;
    05545     DoubleOperand2.HighPart = 0x3ff00000;
    05546     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05547                          &DoubleOperand1,
    05548                          &DoubleOperand2,
    05549                          &DoubleResult);
    05550
    05551     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    05552         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05553         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05554         goto TestFailed;
    05555     }
    05556
    05557     Subtest += 1;
    05558     DoubleOperand1.LowPart = 0x0;
    05559     DoubleOperand1.HighPart = 0x3ff00000;
    05560     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    05561     DoubleOperand2.HighPart = DOUBLE_SIGNAL_NAN;
    05562     Fsr.Data = AddDouble(ROUND_TO_NEAREST,
    05563                          &DoubleOperand1,
    05564                          &DoubleOperand2,
    05565                          &DoubleResult);
    05566
    05567     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    05568         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05569         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05570         goto TestFailed;
    05571     }
    05572
    05573     Subtest += 1;
    05574     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    05575     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    05576     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    05577     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    05578     try {
    05579         Fsr.Data = AddDouble(EV | ROUND_TO_NEAREST,
    05580                              &DoubleOperand1,
    05581                              &DoubleOperand2,
    05582                              &DoubleResult);
    05583
    05584     } except (EXCEPTION_EXECUTE_HANDLER) {
    05585         goto TestFailed;
    05586     }
    05587
    05588     if ((Fsr.Data != (EV | ROUND_TO_NEAREST)) ||
    05589         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05590         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05591         goto TestFailed;
    05592     }
    05593
    05594     Subtest += 1;
    05595     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    05596     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    05597     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    05598     DoubleOperand2.HighPart = DOUBLE_SIGNAL_NAN;
    05599     Count = 0;
    05600     try {
    05601         Fsr.Data = AddDouble(EV | ROUND_TO_NEAREST,
    05602                              &DoubleOperand1,
    05603                              &DoubleOperand2,
    05604                              &DoubleResult);
    05605
    05606     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    05607               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    05608         Count += 1;
    05609     }
    05610
    05611     if (Count != 1) {
    05612         goto TestFailed;
    05613     }
    05614
    05615     Subtest += 1;
    05616     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    05617     DoubleOperand1.HighPart = DOUBLE_SIGNAL_NAN;
    05618     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    05619     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    05620     Count = 0;
    05621     try {
    05622         Fsr.Data = AddDouble(EV | ROUND_TO_NEAREST,
    05623                              &DoubleOperand1,
    05624                              &DoubleOperand2,
    05625                              &DoubleResult);
    05626
    05627     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    05628               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    05629         Count += 1;
    05630     }
    05631
    05632     if (Count != 1) {
    05633         goto TestFailed;
    05634     }
    05635
    05636     Subtest += 1;
    05637     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05638     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05639     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05640     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05641     Count = 0;
    05642     try {
    05643         Fsr.Data = AddDouble(EV | ROUND_TO_NEAREST,
    05644                              &DoubleOperand1,
    05645                              &DoubleOperand2,
    05646                              &DoubleResult);
    05647
    05648     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    05649               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    05650         Count += 1;
    05651     }
    05652
    05653     if (Count != 1) {
    05654         goto TestFailed;
    05655     }
    05656
    05657     //
    05658     // End of test 16.
    05659     //
    05660
    05661     printf("succeeded\n");
    05662     return;
    05663
    05664     //
    05665     // Test 16 failed.
    05666     //
    05667
    05668 TestFailed:
    05669     printf(" subtest %d failed, fsr = %lx, result = %lx, %lx\n",
    05670            Subtest,
    05671            Fsr.Data,
    05672            DoubleResult.LowPart,
    05673            DoubleResult.HighPart);
    05674
    05675     return;
    05676 }
    05677
    05678 VOID
    05679 Test17 (
    05680     VOID
    05681     )
    05682
    05683 {
    05684
    05685     ULONG Count;
    05686     ULARGE_INTEGER DoubleOperand1;
    05687     ULARGE_INTEGER DoubleOperand2;
    05688     ULARGE_INTEGER DoubleResult;
    05689     FLOATING_STATUS Fsr;
    05690     ULONG Subtest;
    05691
    05692     //
    05693     // Test 17 - Multiply double test.
    05694     //
    05695
    05696     Subtest = 0;
    05697     printf("    Test 17 - multiply double ...");
    05698     Subtest += 1;
    05699     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05700     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05701     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05702     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05703     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05704                               &DoubleOperand1,
    05705                               &DoubleOperand2,
    05706                               &DoubleResult);
    05707
    05708     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05709         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05710         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    05711         goto TestFailed;
    05712     }
    05713
    05714     Subtest += 1;
    05715     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05716     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05717     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05718     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05719     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05720                               &DoubleOperand1,
    05721                               &DoubleOperand2,
    05722                               &DoubleResult);
    05723
    05724     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05725         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05726         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    05727         goto TestFailed;
    05728     }
    05729
    05730     Subtest += 1;
    05731     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05732     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05733     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05734     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05735     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05736                               &DoubleOperand1,
    05737                               &DoubleOperand2,
    05738                               &DoubleResult);
    05739
    05740     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05741         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05742         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    05743         goto TestFailed;
    05744     }
    05745
    05746     Subtest += 1;
    05747     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05748     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05749     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05750     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05751     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05752                               &DoubleOperand1,
    05753                               &DoubleOperand2,
    05754                               &DoubleResult);
    05755
    05756     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    05757         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    05758         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    05759         goto TestFailed;
    05760     }
    05761
    05762     Subtest += 1;
    05763     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05764     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05765     DoubleOperand2.LowPart = 0x0;
    05766     DoubleOperand2.HighPart = 0x0;
    05767     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05768                               &DoubleOperand1,
    05769                               &DoubleOperand2,
    05770                               &DoubleResult);
    05771
    05772     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    05773         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05774         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05775         goto TestFailed;
    05776     }
    05777
    05778     Subtest += 1;
    05779     DoubleOperand1.LowPart = 0x0;
    05780     DoubleOperand1.HighPart = 0x0;
    05781     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05782     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05783     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05784                               &DoubleOperand1,
    05785                               &DoubleOperand2,
    05786                               &DoubleResult);
    05787
    05788     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    05789         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05790         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05791         goto TestFailed;
    05792     }
    05793
    05794     Subtest += 1;
    05795     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05796     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05797     DoubleOperand2.LowPart = 0x0;
    05798     DoubleOperand2.HighPart = 0x0;
    05799     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05800                               &DoubleOperand1,
    05801                               &DoubleOperand2,
    05802                               &DoubleResult);
    05803
    05804     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    05805         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05806         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05807         goto TestFailed;
    05808     }
    05809
    05810     Subtest += 1;
    05811     DoubleOperand1.LowPart = 0x0;
    05812     DoubleOperand1.HighPart = 0x0;
    05813     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05814     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05815     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05816                               &DoubleOperand1,
    05817                               &DoubleOperand2,
    05818                               &DoubleResult);
    05819
    05820     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    05821         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05822         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05823         goto TestFailed;
    05824     }
    05825
    05826     Subtest += 1;
    05827     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05828     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05829     DoubleOperand2.LowPart = 0x0;
    05830     DoubleOperand2.HighPart = 0x0;
    05831     Count = 0;
    05832     try {
    05833         Fsr.Data = MultiplyDouble(EV | ROUND_TO_NEAREST,
    05834                                   &DoubleOperand1,
    05835                                   &DoubleOperand2,
    05836                                   &DoubleResult);
    05837
    05838     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    05839               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    05840         Count += 1;
    05841     }
    05842
    05843     if (Count == 0) {
    05844         goto TestFailed;
    05845     }
    05846
    05847     Subtest += 1;
    05848     DoubleOperand1.LowPart = 0x0;
    05849     DoubleOperand1.HighPart = 0x0;
    05850     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05851     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    05852     Count = 0;
    05853     try {
    05854         Fsr.Data = MultiplyDouble(EV | ROUND_TO_NEAREST,
    05855                                   &DoubleOperand1,
    05856                                   &DoubleOperand2,
    05857                                   &DoubleResult);
    05858
    05859     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    05860               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    05861         Count += 1;
    05862     }
    05863
    05864     if (Count == 0) {
    05865         goto TestFailed;
    05866     }
    05867
    05868     Subtest += 1;
    05869     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05870     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05871     DoubleOperand2.LowPart = 0x0;
    05872     DoubleOperand2.HighPart = 0x0;
    05873     Count = 0;
    05874     try {
    05875         Fsr.Data = MultiplyDouble(EV | ROUND_TO_NEAREST,
    05876                                   &DoubleOperand1,
    05877                                   &DoubleOperand2,
    05878                                   &DoubleResult);
    05879
    05880     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    05881               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    05882         Count += 1;
    05883     }
    05884
    05885     if (Count == 0) {
    05886         goto TestFailed;
    05887     }
    05888
    05889     Subtest += 1;
    05890     DoubleOperand1.LowPart = 0x0;
    05891     DoubleOperand1.HighPart = 0x0;
    05892     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    05893     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    05894     Count = 0;
    05895     try {
    05896         Fsr.Data = MultiplyDouble(EV | ROUND_TO_NEAREST,
    05897                                   &DoubleOperand1,
    05898                                   &DoubleOperand2,
    05899                                   &DoubleResult);
    05900
    05901     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    05902               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    05903         Count += 1;
    05904     }
    05905
    05906     if (Count == 0) {
    05907         goto TestFailed;
    05908     }
    05909
    05910     Subtest += 1;
    05911     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    05912     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    05913     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    05914     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    05915     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05916                               &DoubleOperand1,
    05917                               &DoubleOperand2,
    05918                               &DoubleResult);
    05919
    05920     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    05921         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05922         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05923         goto TestFailed;
    05924     }
    05925
    05926     Subtest += 1;
    05927     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    05928     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    05929     DoubleOperand2.LowPart = 0x0;
    05930     DoubleOperand2.HighPart = 0x3ff00000;
    05931     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05932                               &DoubleOperand1,
    05933                               &DoubleOperand2,
    05934                               &DoubleResult);
    05935
    05936     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    05937         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05938         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05939         goto TestFailed;
    05940     }
    05941
    05942     Subtest += 1;
    05943     DoubleOperand1.LowPart = 0x0;
    05944     DoubleOperand1.HighPart = 0x3ff00000;
    05945     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    05946     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    05947     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05948                               &DoubleOperand1,
    05949                               &DoubleOperand2,
    05950                               &DoubleResult);
    05951
    05952     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    05953         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05954         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05955         goto TestFailed;
    05956     }
    05957
    05958     Subtest += 1;
    05959     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    05960     DoubleOperand1.HighPart = DOUBLE_SIGNAL_NAN;
    05961     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    05962     DoubleOperand2.HighPart = DOUBLE_SIGNAL_NAN;
    05963     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05964                               &DoubleOperand1,
    05965                               &DoubleOperand2,
    05966                               &DoubleResult);
    05967
    05968     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    05969         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05970         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05971         goto TestFailed;
    05972     }
    05973
    05974     Subtest += 1;
    05975     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    05976     DoubleOperand1.HighPart = DOUBLE_SIGNAL_NAN;
    05977     DoubleOperand2.LowPart = 0x0;
    05978     DoubleOperand2.HighPart = 0x3ff00000;
    05979     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05980                               &DoubleOperand1,
    05981                               &DoubleOperand2,
    05982                               &DoubleResult);
    05983
    05984     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    05985         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    05986         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    05987         goto TestFailed;
    05988     }
    05989
    05990     Subtest += 1;
    05991     DoubleOperand1.LowPart = 0x0;
    05992     DoubleOperand1.HighPart = 0x3ff00000;
    05993     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    05994     DoubleOperand2.HighPart = DOUBLE_SIGNAL_NAN;
    05995     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    05996                               &DoubleOperand1,
    05997                               &DoubleOperand2,
    05998                               &DoubleResult);
    05999
    06000     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    06001         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    06002         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    06003         goto TestFailed;
    06004     }
    06005
    06006     Subtest += 1;
    06007     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    06008     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    06009     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    06010     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    06011     try {
    06012         Fsr.Data = MultiplyDouble(EV | ROUND_TO_NEAREST,
    06013                                   &DoubleOperand1,
    06014                                   &DoubleOperand2,
    06015                                   &DoubleResult);
    06016
    06017     } except (EXCEPTION_EXECUTE_HANDLER) {
    06018         goto TestFailed;
    06019     }
    06020
    06021     if ((Fsr.Data != (EV | ROUND_TO_NEAREST)) ||
    06022         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    06023         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    06024         goto TestFailed;
    06025     }
    06026
    06027     Subtest += 1;
    06028     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    06029     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    06030     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    06031     DoubleOperand2.HighPart = DOUBLE_SIGNAL_NAN;
    06032     Count = 0;
    06033     try {
    06034         Fsr.Data = MultiplyDouble(EV | ROUND_TO_NEAREST,
    06035                                   &DoubleOperand1,
    06036                                   &DoubleOperand2,
    06037                                   &DoubleResult);
    06038
    06039     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    06040               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06041         Count += 1;
    06042     }
    06043
    06044     if (Count != 1) {
    06045         goto TestFailed;
    06046     }
    06047
    06048     Subtest += 1;
    06049     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    06050     DoubleOperand1.HighPart = DOUBLE_SIGNAL_NAN;
    06051     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    06052     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    06053     Count = 0;
    06054     try {
    06055         Fsr.Data = MultiplyDouble(EV | ROUND_TO_NEAREST,
    06056                                   &DoubleOperand1,
    06057                                   &DoubleOperand2,
    06058                                   &DoubleResult);
    06059
    06060     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    06061               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06062         Count += 1;
    06063     }
    06064
    06065     if (Count != 1) {
    06066         goto TestFailed;
    06067     }
    06068
    06069     Subtest += 1;
    06070     DoubleOperand1.LowPart = 0x0;
    06071     DoubleOperand1.HighPart = 0x7fe00000;
    06072     DoubleOperand2.LowPart = 0x0;
    06073     DoubleOperand2.HighPart = 0x80000;
    06074     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    06075                               &DoubleOperand1,
    06076                               &DoubleOperand2,
    06077                               &DoubleResult);
    06078
    06079     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    06080         (DoubleResult.LowPart != 0x0) ||
    06081         (DoubleResult.HighPart != 0x3ff00000)) {
    06082         goto TestFailed;
    06083     }
    06084
    06085     Subtest += 1;
    06086     DoubleOperand1.LowPart = 0x0;
    06087     DoubleOperand1.HighPart = 0x80000;
    06088     DoubleOperand2.LowPart = 0x0;
    06089     DoubleOperand2.HighPart = 0x7fe00000;
    06090     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    06091                               &DoubleOperand1,
    06092                               &DoubleOperand2,
    06093                               &DoubleResult);
    06094
    06095     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    06096         (DoubleResult.LowPart != 0x0) ||
    06097         (DoubleResult.HighPart != 0x3ff00000)) {
    06098         goto TestFailed;
    06099     }
    06100
    06101     Subtest += 1;
    06102     DoubleOperand1.LowPart = 0x0;
    06103     DoubleOperand1.HighPart = 0x7fe00000;
    06104     DoubleOperand2.LowPart = 0x0;
    06105     DoubleOperand2.HighPart = SIGN | 0x80000;
    06106     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    06107                               &DoubleOperand1,
    06108                               &DoubleOperand2,
    06109                               &DoubleResult);
    06110
    06111     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    06112         (DoubleResult.LowPart != 0x0) ||
    06113         (DoubleResult.HighPart != (SIGN | 0x3ff00000))) {
    06114         goto TestFailed;
    06115     }
    06116
    06117     Subtest += 1;
    06118     DoubleOperand1.LowPart = 0x0;
    06119     DoubleOperand1.HighPart = 0x80000;
    06120     DoubleOperand2.LowPart = 0x0;
    06121     DoubleOperand2.HighPart = SIGN | 0x7fe00000;
    06122     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    06123                               &DoubleOperand1,
    06124                               &DoubleOperand2,
    06125                               &DoubleResult);
    06126
    06127     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    06128         (DoubleResult.LowPart != 0x0) ||
    06129         (DoubleResult.HighPart != (SIGN | 0x3ff00000))) {
    06130         goto TestFailed;
    06131     }
    06132
    06133     Subtest += 1;
    06134     DoubleOperand1.LowPart = 0x0;
    06135     DoubleOperand1.HighPart = 0x80008;
    06136     DoubleOperand2.LowPart = 0x0;
    06137     DoubleOperand2.HighPart = 0x7fe00001;
    06138     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    06139                               &DoubleOperand1,
    06140                               &DoubleOperand2,
    06141                               &DoubleResult);
    06142
    06143     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    06144         (DoubleResult.LowPart != 0x10000) ||
    06145         (DoubleResult.HighPart != 0x3ff00011)) {
    06146         goto TestFailed;
    06147     }
    06148
    06149     Subtest += 1;
    06150     DoubleOperand1.LowPart = 0x0;
    06151     DoubleOperand1.HighPart = 0x80008;
    06152     DoubleOperand2.LowPart = 0x0;
    06153     DoubleOperand2.HighPart = SIGN | 0x7fe00001;
    06154     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    06155                               &DoubleOperand1,
    06156                               &DoubleOperand2,
    06157                               &DoubleResult);
    06158
    06159     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    06160         (DoubleResult.LowPart != 0x10000) ||
    06161         (DoubleResult.HighPart != (SIGN | 0x3ff00011))) {
    06162         goto TestFailed;
    06163     }
    06164
    06165     Subtest += 1;
    06166     DoubleOperand1.LowPart = 0x0;
    06167     DoubleOperand1.HighPart = 0x80008;
    06168     DoubleOperand2.LowPart = 0x1;
    06169     DoubleOperand2.HighPart = 0x7fe00001;
    06170     Count = 0;
    06171     try {
    06172         Fsr.Data = MultiplyDouble(EI | ROUND_TO_NEAREST,
    06173                                   &DoubleOperand1,
    06174                                   &DoubleOperand2,
    06175                                   &DoubleResult);
    06176
    06177     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    06178               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06179         Count += 1;
    06180     }
    06181
    06182     if (Count != 1) {
    06183         goto TestFailed;
    06184     }
    06185
    06186     Subtest += 1;
    06187     DoubleOperand1.LowPart = 0x0;
    06188     DoubleOperand1.HighPart = 0x80008;
    06189     DoubleOperand2.LowPart = 0x1;
    06190     DoubleOperand2.HighPart = SIGN | 0x7fe00001;
    06191     Count = 0;
    06192     try {
    06193         Fsr.Data = MultiplyDouble(EI | ROUND_TO_NEAREST,
    06194                                   &DoubleOperand1,
    06195                                   &DoubleOperand2,
    06196                                   &DoubleResult);
    06197
    06198     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    06199               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06200         Count += 1;
    06201     }
    06202
    06203     if (Count != 1) {
    06204         goto TestFailed;
    06205     }
    06206
    06207     Subtest += 1;
    06208     DoubleOperand1.LowPart = 0x0;
    06209     DoubleOperand1.HighPart = 0x80000;
    06210     DoubleOperand2.LowPart = 0x0;
    06211     DoubleOperand2.HighPart = 0x80000;
    06212     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    06213                               &DoubleOperand1,
    06214                               &DoubleOperand2,
    06215                               &DoubleResult);
    06216
    06217     if ((Fsr.Data != (SU | SI | ROUND_TO_NEAREST)) ||
    06218         (DoubleResult.LowPart != 0x0) ||
    06219         (DoubleResult.HighPart != 0x0)) {
    06220         goto TestFailed;
    06221     }
    06222
    06223     Subtest += 1;
    06224     DoubleOperand1.LowPart = 0x0;
    06225     DoubleOperand1.HighPart = 0x80000;
    06226     DoubleOperand2.LowPart = 0x0;
    06227     DoubleOperand2.HighPart = SIGN | 0x80000;
    06228     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    06229                               &DoubleOperand1,
    06230                               &DoubleOperand2,
    06231                               &DoubleResult);
    06232
    06233     if ((Fsr.Data != (SU | SI | ROUND_TO_NEAREST)) ||
    06234         (DoubleResult.LowPart != 0x0) ||
    06235         (DoubleResult.HighPart != (SIGN | 0x0))) {
    06236         goto TestFailed;
    06237     }
    06238
    06239     Subtest += 1;
    06240     DoubleOperand1.LowPart = 0x0;
    06241     DoubleOperand1.HighPart = 0x80000;
    06242     DoubleOperand2.LowPart = 0x0;
    06243     DoubleOperand2.HighPart = 0x80000;
    06244     Count = 0;
    06245     try {
    06246         Fsr.Data = MultiplyDouble(EI | ROUND_TO_NEAREST,
    06247                                   &DoubleOperand1,
    06248                                   &DoubleOperand2,
    06249                                   &DoubleResult);
    06250
    06251     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    06252               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06253         Count += 1;
    06254     }
    06255
    06256     if (Count != 1) {
    06257         goto TestFailed;
    06258     }
    06259
    06260     Subtest += 1;
    06261     DoubleOperand1.LowPart = 0x0;
    06262     DoubleOperand1.HighPart = 0x80000;
    06263     DoubleOperand2.LowPart = 0x0;
    06264     DoubleOperand2.HighPart = SIGN | 0x80000;
    06265     Count = 0;
    06266     try {
    06267         Fsr.Data = MultiplyDouble(EI | ROUND_TO_NEAREST,
    06268                                   &DoubleOperand1,
    06269                                   &DoubleOperand2,
    06270                                   &DoubleResult);
    06271
    06272     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    06273               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06274         Count += 1;
    06275     }
    06276
    06277     if (Count != 1) {
    06278         goto TestFailed;
    06279     }
    06280
    06281     Subtest += 1;
    06282     DoubleOperand1.LowPart = 0x0;
    06283     DoubleOperand1.HighPart = 0x80000;
    06284     DoubleOperand2.LowPart = 0x0;
    06285     DoubleOperand2.HighPart = 0x80000;
    06286     Count = 0;
    06287     try {
    06288         Fsr.Data = MultiplyDouble(EU | ROUND_TO_NEAREST,
    06289                                   &DoubleOperand1,
    06290                                   &DoubleOperand2,
    06291                                   &DoubleResult);
    06292
    06293     } except ((GetExceptionCode() == STATUS_FLOAT_UNDERFLOW) ?
    06294               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06295         Count += 1;
    06296     }
    06297
    06298     if (Count != 1) {
    06299         goto TestFailed;
    06300     }
    06301
    06302     Subtest += 1;
    06303     DoubleOperand1.LowPart = 0x0;
    06304     DoubleOperand1.HighPart = 0x80000;
    06305     DoubleOperand2.LowPart = 0x0;
    06306     DoubleOperand2.HighPart = SIGN | 0x80000;
    06307     Count = 0;
    06308     try {
    06309         Fsr.Data = MultiplyDouble(EU | ROUND_TO_NEAREST,
    06310                                   &DoubleOperand1,
    06311                                   &DoubleOperand2,
    06312                                   &DoubleResult);
    06313
    06314     } except ((GetExceptionCode() == STATUS_FLOAT_UNDERFLOW) ?
    06315               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06316         Count += 1;
    06317     }
    06318
    06319     if (Count != 1) {
    06320         goto TestFailed;
    06321     }
    06322
    06323     Subtest += 1;
    06324     DoubleOperand1.LowPart = 0x0;
    06325     DoubleOperand1.HighPart = 0x80000;
    06326     DoubleOperand2.LowPart = 0x0;
    06327     DoubleOperand2.HighPart = 0x80000;
    06328     Count = 0;
    06329     try {
    06330         Fsr.Data = MultiplyDouble(EU | EI | ROUND_TO_NEAREST,
    06331                                   &DoubleOperand1,
    06332                                   &DoubleOperand2,
    06333                                   &DoubleResult);
    06334
    06335     } except ((GetExceptionCode() == STATUS_FLOAT_UNDERFLOW) ?
    06336               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06337         Count += 1;
    06338     }
    06339
    06340     if (Count != 1) {
    06341         goto TestFailed;
    06342     }
    06343
    06344     Subtest += 1;
    06345     DoubleOperand1.LowPart = 0x0;
    06346     DoubleOperand1.HighPart = 0x80000;
    06347     DoubleOperand2.LowPart = 0x0;
    06348     DoubleOperand2.HighPart = SIGN | 0x80000;
    06349     Count = 0;
    06350     try {
    06351         Fsr.Data = MultiplyDouble(EU | EI | ROUND_TO_NEAREST,
    06352                                   &DoubleOperand1,
    06353                                   &DoubleOperand2,
    06354                                   &DoubleResult);
    06355
    06356     } except ((GetExceptionCode() == STATUS_FLOAT_UNDERFLOW) ?
    06357               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06358         Count += 1;
    06359     }
    06360
    06361     if (Count != 1) {
    06362         goto TestFailed;
    06363     }
    06364
    06365     Subtest += 1;
    06366     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06367     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06368     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06369     DoubleOperand2.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06370     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    06371                               &DoubleOperand1,
    06372                               &DoubleOperand2,
    06373                               &DoubleResult);
    06374
    06375     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_NEAREST)) ||
    06376         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    06377         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    06378         goto TestFailed;
    06379     }
    06380
    06381     Subtest += 1;
    06382     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06383     DoubleOperand1.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06384     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06385     DoubleOperand2.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06386     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    06387                               &DoubleOperand1,
    06388                               &DoubleOperand2,
    06389                               &DoubleResult);
    06390
    06391     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_NEAREST)) ||
    06392         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    06393         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    06394         goto TestFailed;
    06395     }
    06396
    06397     Subtest += 1;
    06398     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06399     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06400     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06401     DoubleOperand2.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06402     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    06403                               &DoubleOperand1,
    06404                               &DoubleOperand2,
    06405                               &DoubleResult);
    06406
    06407     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_NEAREST)) ||
    06408         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    06409         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    06410         goto TestFailed;
    06411     }
    06412
    06413     Subtest += 1;
    06414     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06415     DoubleOperand1.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06416     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06417     DoubleOperand2.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06418     Fsr.Data = MultiplyDouble(ROUND_TO_NEAREST,
    06419                               &DoubleOperand1,
    06420                               &DoubleOperand2,
    06421                               &DoubleResult);
    06422
    06423     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_NEAREST)) ||
    06424         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    06425         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    06426         goto TestFailed;
    06427     }
    06428
    06429     Subtest += 1;
    06430     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06431     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06432     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06433     DoubleOperand2.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06434     Fsr.Data = MultiplyDouble(ROUND_TO_ZERO,
    06435                               &DoubleOperand1,
    06436                               &DoubleOperand2,
    06437                               &DoubleResult);
    06438
    06439     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_ZERO)) ||
    06440         (DoubleResult.LowPart != DOUBLE_MAXIMUM_VALUE_LOW) ||
    06441         (DoubleResult.HighPart != DOUBLE_MAXIMUM_VALUE_HIGH)) {
    06442         goto TestFailed;
    06443     }
    06444
    06445     Subtest += 1;
    06446     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06447     DoubleOperand1.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06448     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06449     DoubleOperand2.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06450     Fsr.Data = MultiplyDouble(ROUND_TO_ZERO,
    06451                               &DoubleOperand1,
    06452                               &DoubleOperand2,
    06453                               &DoubleResult);
    06454
    06455     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_ZERO)) ||
    06456         (DoubleResult.LowPart != DOUBLE_MAXIMUM_VALUE_LOW) ||
    06457         (DoubleResult.HighPart != (SIGN | DOUBLE_MAXIMUM_VALUE_HIGH))) {
    06458         goto TestFailed;
    06459     }
    06460
    06461     Subtest += 1;
    06462     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06463     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06464     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06465     DoubleOperand2.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06466     Fsr.Data = MultiplyDouble(ROUND_TO_ZERO,
    06467                               &DoubleOperand1,
    06468                               &DoubleOperand2,
    06469                               &DoubleResult);
    06470
    06471     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_ZERO)) ||
    06472         (DoubleResult.LowPart != DOUBLE_MAXIMUM_VALUE_LOW) ||
    06473         (DoubleResult.HighPart != (SIGN | DOUBLE_MAXIMUM_VALUE_HIGH))) {
    06474         goto TestFailed;
    06475     }
    06476
    06477     Subtest += 1;
    06478     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06479     DoubleOperand1.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06480     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06481     DoubleOperand2.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06482     Fsr.Data = MultiplyDouble(ROUND_TO_ZERO,
    06483                               &DoubleOperand1,
    06484                               &DoubleOperand2,
    06485                               &DoubleResult);
    06486
    06487     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_ZERO)) ||
    06488         (DoubleResult.LowPart != DOUBLE_MAXIMUM_VALUE_LOW) ||
    06489         (DoubleResult.HighPart != DOUBLE_MAXIMUM_VALUE_HIGH)) {
    06490         goto TestFailed;
    06491     }
    06492
    06493     Subtest += 1;
    06494     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06495     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06496     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06497     DoubleOperand2.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06498     Fsr.Data = MultiplyDouble(ROUND_TO_PLUS_INFINITY,
    06499                               &DoubleOperand1,
    06500                               &DoubleOperand2,
    06501                               &DoubleResult);
    06502
    06503     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_PLUS_INFINITY)) ||
    06504         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    06505         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    06506         goto TestFailed;
    06507     }
    06508
    06509     Subtest += 1;
    06510     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06511     DoubleOperand1.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06512     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06513     DoubleOperand2.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06514     Fsr.Data = MultiplyDouble(ROUND_TO_PLUS_INFINITY,
    06515                               &DoubleOperand1,
    06516                               &DoubleOperand2,
    06517                               &DoubleResult);
    06518
    06519     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_PLUS_INFINITY)) ||
    06520         (DoubleResult.LowPart != DOUBLE_MAXIMUM_VALUE_LOW) ||
    06521         (DoubleResult.HighPart != (SIGN | DOUBLE_MAXIMUM_VALUE_HIGH))) {
    06522         goto TestFailed;
    06523     }
    06524
    06525     Subtest += 1;
    06526     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06527     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06528     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06529     DoubleOperand2.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06530     Fsr.Data = MultiplyDouble(ROUND_TO_PLUS_INFINITY,
    06531                               &DoubleOperand1,
    06532                               &DoubleOperand2,
    06533                               &DoubleResult);
    06534
    06535     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_PLUS_INFINITY)) ||
    06536         (DoubleResult.LowPart != DOUBLE_MAXIMUM_VALUE_LOW) ||
    06537         (DoubleResult.HighPart != (SIGN | DOUBLE_MAXIMUM_VALUE_HIGH))) {
    06538         goto TestFailed;
    06539     }
    06540
    06541     Subtest += 1;
    06542     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06543     DoubleOperand1.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06544     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06545     DoubleOperand2.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06546     Fsr.Data = MultiplyDouble(ROUND_TO_PLUS_INFINITY,
    06547                               &DoubleOperand1,
    06548                               &DoubleOperand2,
    06549                               &DoubleResult);
    06550
    06551     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_PLUS_INFINITY)) ||
    06552         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    06553         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    06554         goto TestFailed;
    06555     }
    06556
    06557     Subtest += 1;
    06558     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06559     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06560     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06561     DoubleOperand2.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06562     Fsr.Data = MultiplyDouble(ROUND_TO_MINUS_INFINITY,
    06563                               &DoubleOperand1,
    06564                               &DoubleOperand2,
    06565                               &DoubleResult);
    06566
    06567     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_MINUS_INFINITY)) ||
    06568         (DoubleResult.LowPart != DOUBLE_MAXIMUM_VALUE_LOW) ||
    06569         (DoubleResult.HighPart != DOUBLE_MAXIMUM_VALUE_HIGH)) {
    06570         goto TestFailed;
    06571     }
    06572
    06573     Subtest += 1;
    06574     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06575     DoubleOperand1.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06576     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06577     DoubleOperand2.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06578     Fsr.Data = MultiplyDouble(ROUND_TO_MINUS_INFINITY,
    06579                               &DoubleOperand1,
    06580                               &DoubleOperand2,
    06581                               &DoubleResult);
    06582
    06583     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_MINUS_INFINITY)) ||
    06584         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    06585         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    06586         goto TestFailed;
    06587     }
    06588
    06589     Subtest += 1;
    06590     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06591     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06592     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06593     DoubleOperand2.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06594     Fsr.Data = MultiplyDouble(ROUND_TO_MINUS_INFINITY,
    06595                               &DoubleOperand1,
    06596                               &DoubleOperand2,
    06597                               &DoubleResult);
    06598
    06599     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_MINUS_INFINITY)) ||
    06600         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    06601         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    06602         goto TestFailed;
    06603     }
    06604
    06605     Subtest += 1;
    06606     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06607     DoubleOperand1.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06608     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06609     DoubleOperand2.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06610     Fsr.Data = MultiplyDouble(ROUND_TO_MINUS_INFINITY,
    06611                               &DoubleOperand1,
    06612                               &DoubleOperand2,
    06613                               &DoubleResult);
    06614
    06615     if ((Fsr.Data != (SO | SI | XO | XI | ROUND_TO_MINUS_INFINITY)) ||
    06616         (DoubleResult.LowPart != DOUBLE_MAXIMUM_VALUE_LOW) ||
    06617         (DoubleResult.HighPart != DOUBLE_MAXIMUM_VALUE_HIGH)) {
    06618         goto TestFailed;
    06619     }
    06620
    06621     Subtest += 1;
    06622     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06623     DoubleOperand1.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06624     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06625     DoubleOperand2.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06626     Count = 0;
    06627     try {
    06628         Fsr.Data = MultiplyDouble(EI | ROUND_TO_NEAREST,
    06629                                   &DoubleOperand1,
    06630                                   &DoubleOperand2,
    06631                                   &DoubleResult);
    06632
    06633     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    06634               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06635         Count += 1;
    06636     }
    06637
    06638     if (Count != 1) {
    06639         goto TestFailed;
    06640     }
    06641
    06642     Subtest += 1;
    06643     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06644     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06645     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06646     DoubleOperand2.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06647     Count = 0;
    06648     try {
    06649         Fsr.Data = MultiplyDouble(EI | ROUND_TO_NEAREST,
    06650                                   &DoubleOperand1,
    06651                                   &DoubleOperand2,
    06652                                   &DoubleResult);
    06653
    06654     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    06655               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06656         Count += 1;
    06657     }
    06658
    06659     if (Count != 1) {
    06660         goto TestFailed;
    06661     }
    06662
    06663     Subtest += 1;
    06664     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06665     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06666     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06667     DoubleOperand2.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06668     Count = 0;
    06669     try {
    06670         Fsr.Data = MultiplyDouble(EO | ROUND_TO_NEAREST,
    06671                                   &DoubleOperand1,
    06672                                   &DoubleOperand2,
    06673                                   &DoubleResult);
    06674
    06675     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    06676               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06677         Count += 1;
    06678     }
    06679
    06680     if (Count != 1) {
    06681         goto TestFailed;
    06682     }
    06683
    06684     Subtest += 1;
    06685     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06686     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06687     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06688     DoubleOperand2.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06689     Count = 0;
    06690     try {
    06691         Fsr.Data = MultiplyDouble(EO | ROUND_TO_NEAREST,
    06692                                   &DoubleOperand1,
    06693                                   &DoubleOperand2,
    06694                                   &DoubleResult);
    06695
    06696     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    06697               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06698         Count += 1;
    06699     }
    06700
    06701     if (Count != 1) {
    06702         goto TestFailed;
    06703     }
    06704
    06705     Subtest += 1;
    06706     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06707     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06708     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06709     DoubleOperand2.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06710     Count = 0;
    06711     try {
    06712         Fsr.Data = MultiplyDouble(EO | EI | ROUND_TO_NEAREST,
    06713                                   &DoubleOperand1,
    06714                                   &DoubleOperand2,
    06715                                   &DoubleResult);
    06716
    06717     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    06718               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06719         Count += 1;
    06720     }
    06721
    06722     if (Count != 1) {
    06723         goto TestFailed;
    06724     }
    06725
    06726     Subtest += 1;
    06727     DoubleOperand1.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06728     DoubleOperand1.HighPart = DOUBLE_MAXIMUM_VALUE_HIGH;
    06729     DoubleOperand2.LowPart = DOUBLE_MAXIMUM_VALUE_LOW;
    06730     DoubleOperand2.HighPart = SIGN | DOUBLE_MAXIMUM_VALUE_HIGH;
    06731     Count = 0;
    06732     try {
    06733         Fsr.Data = MultiplyDouble(EO | EI | ROUND_TO_NEAREST,
    06734                                   &DoubleOperand1,
    06735                                   &DoubleOperand2,
    06736                                   &DoubleResult);
    06737
    06738     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    06739               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06740         Count += 1;
    06741     }
    06742
    06743     if (Count != 1) {
    06744         goto TestFailed;
    06745     }
    06746
    06747     //
    06748     // End of test 17.
    06749     //
    06750
    06751     printf("succeeded\n");
    06752     return;
    06753
    06754     //
    06755     // Test 17 failed.
    06756     //
    06757
    06758 TestFailed:
    06759     printf(" subtest %d failed, fsr = %lx, result = %lx, %lx\n",
    06760            Subtest,
    06761            Fsr.Data,
    06762            DoubleResult.LowPart,
    06763            DoubleResult.HighPart);
    06764
    06765     return;
    06766 }
    06767
    06768 VOID
    06769 Test18 (
    06770     VOID
    06771     )
    06772
    06773 {
    06774
    06775     ULONG Count;
    06776     ULARGE_INTEGER DoubleOperand1;
    06777     ULARGE_INTEGER DoubleOperand2;
    06778     ULARGE_INTEGER DoubleResult;
    06779     FLOATING_STATUS Fsr;
    06780     ULONG Subtest;
    06781
    06782     //
    06783     // Test 18 - Divide double test.
    06784     //
    06785
    06786     Subtest = 0;
    06787     printf("    Test 18 - divide double ...");
    06788     Subtest += 1;
    06789     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    06790     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    06791     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    06792     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    06793     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    06794                             &DoubleOperand1,
    06795                             &DoubleOperand2,
    06796                             &DoubleResult);
    06797
    06798     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    06799         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    06800         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    06801         goto TestFailed;
    06802     }
    06803
    06804     Subtest += 1;
    06805     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    06806     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    06807     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    06808     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    06809     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    06810                             &DoubleOperand1,
    06811                             &DoubleOperand2,
    06812                             &DoubleResult);
    06813
    06814     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    06815         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    06816         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    06817         goto TestFailed;
    06818     }
    06819
    06820     Subtest += 1;
    06821     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    06822     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    06823     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    06824     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    06825     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    06826                             &DoubleOperand1,
    06827                             &DoubleOperand2,
    06828                             &DoubleResult);
    06829
    06830     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    06831         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    06832         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    06833         goto TestFailed;
    06834     }
    06835
    06836     Subtest += 1;
    06837     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    06838     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    06839     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    06840     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    06841     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    06842                             &DoubleOperand1,
    06843                             &DoubleOperand2,
    06844                             &DoubleResult);
    06845
    06846     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    06847         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    06848         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    06849         goto TestFailed;
    06850     }
    06851
    06852     Subtest += 1;
    06853     DoubleOperand1.LowPart = 0x0;
    06854     DoubleOperand1.HighPart = 0x0;
    06855     DoubleOperand2.LowPart = 0x0;
    06856     DoubleOperand2.HighPart = 0x0;
    06857     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    06858                             &DoubleOperand1,
    06859                             &DoubleOperand2,
    06860                             &DoubleResult);
    06861
    06862     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    06863         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    06864         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    06865         goto TestFailed;
    06866     }
    06867
    06868     Subtest += 1;
    06869     DoubleOperand1.LowPart = 0x0;
    06870     DoubleOperand1.HighPart = 0x0;
    06871     DoubleOperand2.LowPart = 0x0;
    06872     DoubleOperand2.HighPart = SIGN | 0x0;
    06873     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    06874                             &DoubleOperand1,
    06875                             &DoubleOperand2,
    06876                             &DoubleResult);
    06877
    06878     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    06879         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    06880         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    06881         goto TestFailed;
    06882     }
    06883
    06884     Subtest += 1;
    06885     DoubleOperand1.LowPart = 0x0;
    06886     DoubleOperand1.HighPart = SIGN | 0x0;
    06887     DoubleOperand2.LowPart = 0x0;
    06888     DoubleOperand2.HighPart = SIGN | 0x0;
    06889     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    06890                             &DoubleOperand1,
    06891                             &DoubleOperand2,
    06892                             &DoubleResult);
    06893
    06894     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    06895         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    06896         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    06897         goto TestFailed;
    06898     }
    06899
    06900     Subtest += 1;
    06901     DoubleOperand1.LowPart = 0x0;
    06902     DoubleOperand1.HighPart = SIGN | 0x0;
    06903     DoubleOperand2.LowPart = 0x0;
    06904     DoubleOperand2.HighPart = 0x0;
    06905     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    06906                             &DoubleOperand1,
    06907                             &DoubleOperand2,
    06908                             &DoubleResult);
    06909
    06910     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    06911         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    06912         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    06913         goto TestFailed;
    06914     }
    06915
    06916     Subtest += 1;
    06917     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    06918     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    06919     DoubleOperand2.LowPart = 0x0;
    06920     DoubleOperand2.HighPart = 0x0;
    06921     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    06922                             &DoubleOperand1,
    06923                             &DoubleOperand2,
    06924                             &DoubleResult);
    06925
    06926     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    06927         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    06928         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    06929         goto TestFailed;
    06930     }
    06931
    06932     Subtest += 1;
    06933     DoubleOperand1.LowPart = 0x0;
    06934     DoubleOperand1.HighPart = 0x3ff00000;
    06935     DoubleOperand2.LowPart = 0x0;
    06936     DoubleOperand2.HighPart = 0x0;
    06937     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    06938                             &DoubleOperand1,
    06939                             &DoubleOperand2,
    06940                             &DoubleResult);
    06941
    06942     if ((Fsr.Data != (SZ | XZ | ROUND_TO_NEAREST)) ||
    06943         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    06944         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    06945         goto TestFailed;
    06946     }
    06947
    06948
    06949     Subtest += 1;
    06950     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    06951     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    06952     DoubleOperand2.LowPart = 0x0;
    06953     DoubleOperand2.HighPart = 0x0;
    06954     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    06955                             &DoubleOperand1,
    06956                             &DoubleOperand2,
    06957                             &DoubleResult);
    06958
    06959     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    06960         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    06961         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    06962         goto TestFailed;
    06963     }
    06964
    06965     Subtest += 1;
    06966     DoubleOperand1.LowPart = 0x0;
    06967     DoubleOperand1.HighPart = SIGN | 0x3ff00000;
    06968     DoubleOperand2.LowPart = 0x0;
    06969     DoubleOperand2.HighPart = 0x0;
    06970     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    06971                             &DoubleOperand1,
    06972                             &DoubleOperand2,
    06973                             &DoubleResult);
    06974
    06975     if ((Fsr.Data != (SZ | XZ | ROUND_TO_NEAREST)) ||
    06976         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    06977         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    06978         goto TestFailed;
    06979     }
    06980
    06981     Subtest += 1;
    06982     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    06983     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    06984     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    06985     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    06986     Count = 0;
    06987     try {
    06988         Fsr.Data = DivideDouble(EV | ROUND_TO_NEAREST,
    06989                                 &DoubleOperand1,
    06990                                 &DoubleOperand2,
    06991                                 &DoubleResult);
    06992
    06993     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    06994               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    06995         Count += 1;
    06996     }
    06997
    06998     if (Count == 0) {
    06999         goto TestFailed;
    07000     }
    07001
    07002     Subtest += 1;
    07003     DoubleOperand1.LowPart = 0x0;
    07004     DoubleOperand1.HighPart = 0x0;
    07005     DoubleOperand2.LowPart = 0x0;
    07006     DoubleOperand2.HighPart = 0x0;
    07007     Count = 0;
    07008     try {
    07009         Fsr.Data = DivideDouble(EV | ROUND_TO_NEAREST,
    07010                                 &DoubleOperand1,
    07011                                 &DoubleOperand2,
    07012                                 &DoubleResult);
    07013
    07014     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    07015               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    07016         Count += 1;
    07017     }
    07018
    07019     if (Count == 0) {
    07020         goto TestFailed;
    07021     }
    07022
    07023     Subtest += 1;
    07024     DoubleOperand1.LowPart = 0x0;
    07025     DoubleOperand1.HighPart = 0x3ff00000;
    07026     DoubleOperand2.LowPart = 0x0;
    07027     DoubleOperand2.HighPart = 0x0;
    07028     Count = 0;
    07029     try {
    07030         Fsr.Data = DivideDouble(EZ | ROUND_TO_NEAREST,
    07031                                 &DoubleOperand1,
    07032                                 &DoubleOperand2,
    07033                                 &DoubleResult);
    07034
    07035     } except ((GetExceptionCode() == STATUS_FLOAT_DIVIDE_BY_ZERO) ?
    07036               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    07037         Count += 1;
    07038     }
    07039
    07040     if (Count == 0) {
    07041         goto TestFailed;
    07042     }
    07043
    07044     Subtest += 1;
    07045     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07046     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    07047     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    07048     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    07049     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07050                             &DoubleOperand1,
    07051                             &DoubleOperand2,
    07052                             &DoubleResult);
    07053
    07054     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    07055         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    07056         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    07057         goto TestFailed;
    07058     }
    07059
    07060     Subtest += 1;
    07061     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07062     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    07063     DoubleOperand2.LowPart = 0x0;
    07064     DoubleOperand2.HighPart = 0x3ff00000;
    07065     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07066                             &DoubleOperand1,
    07067                             &DoubleOperand2,
    07068                             &DoubleResult);
    07069
    07070     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    07071         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    07072         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    07073         goto TestFailed;
    07074     }
    07075
    07076     Subtest += 1;
    07077     DoubleOperand1.LowPart = 0x0;
    07078     DoubleOperand1.HighPart = 0x3ff00000;
    07079     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    07080     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    07081     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07082                             &DoubleOperand1,
    07083                             &DoubleOperand2,
    07084                             &DoubleResult);
    07085
    07086     if ((Fsr.Data != (ROUND_TO_NEAREST)) ||
    07087         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    07088         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    07089         goto TestFailed;
    07090     }
    07091
    07092     Subtest += 1;
    07093     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07094     DoubleOperand1.HighPart = DOUBLE_SIGNAL_NAN;
    07095     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    07096     DoubleOperand2.HighPart = DOUBLE_SIGNAL_NAN;
    07097     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07098                             &DoubleOperand1,
    07099                             &DoubleOperand2,
    07100                             &DoubleResult);
    07101
    07102     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    07103         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    07104         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    07105         goto TestFailed;
    07106     }
    07107
    07108     Subtest += 1;
    07109     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07110     DoubleOperand1.HighPart = DOUBLE_SIGNAL_NAN;
    07111     DoubleOperand2.LowPart = 0x0;
    07112     DoubleOperand2.HighPart = 0x3ff00000;
    07113     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07114                             &DoubleOperand1,
    07115                             &DoubleOperand2,
    07116                             &DoubleResult);
    07117
    07118     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    07119         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    07120         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    07121         goto TestFailed;
    07122     }
    07123
    07124     Subtest += 1;
    07125     DoubleOperand1.LowPart = 0x0;
    07126     DoubleOperand1.HighPart = 0x3ff00000;
    07127     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    07128     DoubleOperand2.HighPart = DOUBLE_SIGNAL_NAN;
    07129     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07130                             &DoubleOperand1,
    07131                             &DoubleOperand2,
    07132                             &DoubleResult);
    07133
    07134     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    07135         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    07136         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    07137         goto TestFailed;
    07138     }
    07139
    07140     Subtest += 1;
    07141     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07142     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    07143     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    07144     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    07145     try {
    07146         Fsr.Data = DivideDouble(EV | ROUND_TO_NEAREST,
    07147                                 &DoubleOperand1,
    07148                                 &DoubleOperand2,
    07149                                 &DoubleResult);
    07150
    07151     } except (EXCEPTION_EXECUTE_HANDLER) {
    07152         goto TestFailed;
    07153     }
    07154
    07155     if ((Fsr.Data != (EV | ROUND_TO_NEAREST)) ||
    07156         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    07157         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    07158         goto TestFailed;
    07159     }
    07160
    07161     Subtest += 1;
    07162     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07163     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    07164     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    07165     DoubleOperand2.HighPart = DOUBLE_SIGNAL_NAN;
    07166     Count = 0;
    07167     try {
    07168         Fsr.Data = DivideDouble(EV | ROUND_TO_NEAREST,
    07169                                 &DoubleOperand1,
    07170                                 &DoubleOperand2,
    07171                                 &DoubleResult);
    07172
    07173     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    07174               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    07175         Count += 1;
    07176     }
    07177
    07178     if (Count != 1) {
    07179         goto TestFailed;
    07180     }
    07181
    07182     Subtest += 1;
    07183     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07184     DoubleOperand1.HighPart = DOUBLE_SIGNAL_NAN;
    07185     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    07186     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    07187     Count = 0;
    07188     try {
    07189         Fsr.Data = DivideDouble(EV | ROUND_TO_NEAREST,
    07190                                 &DoubleOperand1,
    07191                                 &DoubleOperand2,
    07192                                 &DoubleResult);
    07193
    07194     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    07195               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    07196         Count += 1;
    07197     }
    07198
    07199     if (Count != 1) {
    07200         goto TestFailed;
    07201     }
    07202
    07203     Subtest += 1;
    07204     DoubleOperand1.LowPart = 0x0;
    07205     DoubleOperand1.HighPart = 0x80000;
    07206     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07207     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07208     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07209                             &DoubleOperand1,
    07210                             &DoubleOperand2,
    07211                             &DoubleResult);
    07212
    07213     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    07214         (DoubleResult.LowPart != 0x0) ||
    07215         (DoubleResult.HighPart != 0x0)) {
    07216         goto TestFailed;
    07217     }
    07218
    07219     Subtest += 1;
    07220     DoubleOperand1.LowPart = 0x0;
    07221     DoubleOperand1.HighPart = SIGN | 0x80000;
    07222     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07223     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07224     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07225                             &DoubleOperand1,
    07226                             &DoubleOperand2,
    07227                             &DoubleResult);
    07228
    07229     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    07230         (DoubleResult.LowPart != 0x0) ||
    07231         (DoubleResult.HighPart != (SIGN | 0x0))) {
    07232         goto TestFailed;
    07233     }
    07234
    07235     Subtest += 1;
    07236     DoubleOperand1.LowPart = 0x0;
    07237     DoubleOperand1.HighPart = 0x80000;
    07238     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07239     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    07240     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07241                             &DoubleOperand1,
    07242                             &DoubleOperand2,
    07243                             &DoubleResult);
    07244
    07245     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    07246         (DoubleResult.LowPart != 0x0) ||
    07247         (DoubleResult.HighPart != (SIGN | 0x0))) {
    07248         goto TestFailed;
    07249     }
    07250
    07251     Subtest += 1;
    07252     DoubleOperand1.LowPart = 0x0;
    07253     DoubleOperand1.HighPart = SIGN | 0x80000;
    07254     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07255     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    07256     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07257                             &DoubleOperand1,
    07258                             &DoubleOperand2,
    07259                             &DoubleResult);
    07260
    07261     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    07262         (DoubleResult.LowPart != 0x0) ||
    07263         (DoubleResult.HighPart != 0x0)) {
    07264         goto TestFailed;
    07265     }
    07266
    07267     Subtest += 1;
    07268     DoubleOperand1.LowPart = 0x0;
    07269     DoubleOperand1.HighPart = 0x80000;
    07270     DoubleOperand2.LowPart = 0x0;
    07271     DoubleOperand2.HighPart = 0x80000;
    07272     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07273                             &DoubleOperand1,
    07274                             &DoubleOperand2,
    07275                             &DoubleResult);
    07276
    07277     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    07278         (DoubleResult.LowPart != 0x0) ||
    07279         (DoubleResult.HighPart != 0x3ff00000)) {
    07280         goto TestFailed;
    07281     }
    07282
    07283     Subtest += 1;
    07284     DoubleOperand1.LowPart = 0x0;
    07285     DoubleOperand1.HighPart = SIGN | 0x80000;
    07286     DoubleOperand2.LowPart = 0x0;
    07287     DoubleOperand2.HighPart = 0x80000;
    07288     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07289                             &DoubleOperand1,
    07290                             &DoubleOperand2,
    07291                             &DoubleResult);
    07292
    07293     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    07294         (DoubleResult.LowPart != 0x0) ||
    07295         (DoubleResult.HighPart != (SIGN | 0x3ff00000))) {
    07296         goto TestFailed;
    07297     }
    07298
    07299     Subtest += 1;
    07300     DoubleOperand1.LowPart = 0x0;
    07301     DoubleOperand1.HighPart = 0x80000;
    07302     DoubleOperand2.LowPart = 0x0;
    07303     DoubleOperand2.HighPart = SIGN | 0x80000;
    07304     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07305                             &DoubleOperand1,
    07306                             &DoubleOperand2,
    07307                             &DoubleResult);
    07308
    07309     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    07310         (DoubleResult.LowPart != 0x0) ||
    07311         (DoubleResult.HighPart != (SIGN | 0x3ff00000))) {
    07312         goto TestFailed;
    07313     }
    07314
    07315     Subtest += 1;
    07316     DoubleOperand1.LowPart = 0x0;
    07317     DoubleOperand1.HighPart = SIGN | 0x80000;
    07318     DoubleOperand2.LowPart = 0x0;
    07319     DoubleOperand2.HighPart = SIGN | 0x80000;
    07320     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07321                             &DoubleOperand1,
    07322                             &DoubleOperand2,
    07323                             &DoubleResult);
    07324
    07325     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    07326         (DoubleResult.LowPart != 0x0) ||
    07327         (DoubleResult.HighPart != 0x3ff00000)) {
    07328         goto TestFailed;
    07329     }
    07330
    07331     Subtest += 1;
    07332     DoubleOperand1.LowPart = 0x0;
    07333     DoubleOperand1.HighPart = 0x3ff00000;
    07334     DoubleOperand2.LowPart = 0x0;
    07335     DoubleOperand2.HighPart = 0x80000;
    07336     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07337                             &DoubleOperand1,
    07338                             &DoubleOperand2,
    07339                             &DoubleResult);
    07340
    07341     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    07342         (DoubleResult.LowPart != 0x0) ||
    07343         (DoubleResult.HighPart != 0x7fe00000)) {
    07344         goto TestFailed;
    07345     }
    07346
    07347     Subtest += 1;
    07348     DoubleOperand1.LowPart = 0x0;
    07349     DoubleOperand1.HighPart = 0x40000000;
    07350     DoubleOperand2.LowPart = 0x0;
    07351     DoubleOperand2.HighPart = 0x80000;
    07352     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07353                             &DoubleOperand1,
    07354                             &DoubleOperand2,
    07355                             &DoubleResult);
    07356
    07357     if ((Fsr.Data != (SO | SI | ROUND_TO_NEAREST)) ||
    07358         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    07359         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    07360         goto TestFailed;
    07361     }
    07362
    07363     Subtest += 1;
    07364     DoubleOperand1.LowPart = 0xffffffff;
    07365     DoubleOperand1.HighPart = 0x3fffffff;
    07366     DoubleOperand2.LowPart = 0x0;
    07367     DoubleOperand2.HighPart = 0x80000;
    07368     Fsr.Data = DivideDouble(ROUND_TO_NEAREST,
    07369                             &DoubleOperand1,
    07370                             &DoubleOperand2,
    07371                             &DoubleResult);
    07372
    07373     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    07374         (DoubleResult.LowPart != 0xffffffff) ||
    07375         (DoubleResult.HighPart != 0x7fefffff)) {
    07376         goto TestFailed;
    07377     }
    07378
    07379     //
    07380     // End of test 18.
    07381     //
    07382
    07383     printf("succeeded\n");
    07384     return;
    07385
    07386     //
    07387     // Test 18 failed.
    07388     //
    07389
    07390 TestFailed:
    07391     printf(" subtest %d failed, fsr = %lx, result = %lx, %lx\n",
    07392            Subtest,
    07393            Fsr.Data,
    07394            DoubleResult.LowPart,
    07395            DoubleResult.HighPart);
    07396
    07397     return;
    07398 }
    07399
    07400 VOID
    07401 Test19 (
    07402     VOID
    07403     )
    07404
    07405 {
    07406
    07407     ULONG Count;
    07408     ULARGE_INTEGER DoubleOperand1;
    07409     ULARGE_INTEGER DoubleOperand2;
    07410     FLOATING_STATUS Fsr;
    07411     ULONG Subtest;
    07412
    07413     //
    07414     // Test 19 - Compare double test.
    07415     //
    07416
    07417     Subtest = 0;
    07418     printf("    Test 19 - compare double ...");
    07419
    07420 // ****** //
    07421
    07422     Subtest += 1;
    07423     DoubleOperand1.LowPart = 0x0;
    07424     DoubleOperand1.HighPart = 0x0;
    07425     DoubleOperand2.LowPart = 0x0;
    07426     DoubleOperand2.HighPart = 0x80000;
    07427     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07428                                &DoubleOperand1,
    07429                                &DoubleOperand2);
    07430
    07431     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07432         goto TestFailed;
    07433     }
    07434
    07435     Subtest += 1;
    07436     DoubleOperand1.LowPart = 0x0;
    07437     DoubleOperand1.HighPart = SIGN | 0x0;
    07438     DoubleOperand2.LowPart = 0x0;
    07439     DoubleOperand2.HighPart = 0x80000;
    07440     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07441                                &DoubleOperand1,
    07442                                &DoubleOperand2);
    07443
    07444     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07445         goto TestFailed;
    07446     }
    07447
    07448     Subtest += 1;
    07449     DoubleOperand1.LowPart = 0x0;
    07450     DoubleOperand1.HighPart = 0x80000;
    07451     DoubleOperand2.LowPart = 0x0;
    07452     DoubleOperand2.HighPart = 0x0;
    07453     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07454                                &DoubleOperand1,
    07455                                &DoubleOperand2);
    07456
    07457     if (Fsr.Data != ROUND_TO_NEAREST) {
    07458         goto TestFailed;
    07459     }
    07460
    07461     Subtest += 1;
    07462     DoubleOperand1.LowPart = 0x0;
    07463     DoubleOperand1.HighPart = 0x80000;
    07464     DoubleOperand2.LowPart = 0x0;
    07465     DoubleOperand2.HighPart = SIGN | 0x0;
    07466     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07467                                &DoubleOperand1,
    07468                                &DoubleOperand2);
    07469
    07470     if (Fsr.Data != ROUND_TO_NEAREST) {
    07471         goto TestFailed;
    07472     }
    07473
    07474 // ****** //
    07475
    07476     Subtest += 1;
    07477     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07478     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07479     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07480     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07481     Fsr.Data = CompareEqDouble(ROUND_TO_NEAREST,
    07482                                &DoubleOperand1,
    07483                                &DoubleOperand2);
    07484
    07485     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07486         goto TestFailed;
    07487     }
    07488
    07489     Subtest += 1;
    07490     DoubleOperand1.LowPart = 0x0;
    07491     DoubleOperand1.HighPart = 0x80000;
    07492     DoubleOperand2.LowPart = 0x0;
    07493     DoubleOperand2.HighPart = 0x80000;
    07494     Fsr.Data = CompareEqDouble(ROUND_TO_NEAREST,
    07495                                &DoubleOperand1,
    07496                                &DoubleOperand2);
    07497
    07498     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07499         goto TestFailed;
    07500     }
    07501
    07502     Subtest += 1;
    07503     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07504     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    07505     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07506     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07507     Fsr.Data = CompareEqDouble(ROUND_TO_NEAREST,
    07508                                &DoubleOperand1,
    07509                                &DoubleOperand2);
    07510
    07511     if (Fsr.Data != ROUND_TO_NEAREST) {
    07512         goto TestFailed;
    07513     }
    07514
    07515     Subtest += 1;
    07516     DoubleOperand1.LowPart = 0x0;
    07517     DoubleOperand1.HighPart = 0x80000;
    07518     DoubleOperand2.LowPart = 0x0;
    07519     DoubleOperand2.HighPart = SIGN | 0x80000;
    07520     Fsr.Data = CompareEqDouble(ROUND_TO_NEAREST,
    07521                                &DoubleOperand1,
    07522                                &DoubleOperand2);
    07523
    07524     if (Fsr.Data != ROUND_TO_NEAREST) {
    07525         goto TestFailed;
    07526     }
    07527
    07528     Subtest += 1;
    07529     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07530     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07531     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07532     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07533     Fsr.Data = CompareLeDouble(ROUND_TO_NEAREST,
    07534                                &DoubleOperand1,
    07535                                &DoubleOperand2);
    07536
    07537     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07538         goto TestFailed;
    07539     }
    07540
    07541     Subtest += 1;
    07542     DoubleOperand1.LowPart = 0x0;
    07543     DoubleOperand1.HighPart = 0x80000;
    07544     DoubleOperand2.LowPart = 0x0;
    07545     DoubleOperand2.HighPart = 0x80000;
    07546     Fsr.Data = CompareLeDouble(ROUND_TO_NEAREST,
    07547                                &DoubleOperand1,
    07548                                &DoubleOperand2);
    07549
    07550     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07551         goto TestFailed;
    07552     }
    07553
    07554     Subtest += 1;
    07555     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07556     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    07557     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07558     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07559     Fsr.Data = CompareLeDouble(ROUND_TO_NEAREST,
    07560                                &DoubleOperand1,
    07561                                &DoubleOperand2);
    07562
    07563     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07564         goto TestFailed;
    07565     }
    07566
    07567     Subtest += 1;
    07568     DoubleOperand1.LowPart = 0x0;
    07569     DoubleOperand1.HighPart = SIGN | 0x80000;
    07570     DoubleOperand2.LowPart = 0x0;
    07571     DoubleOperand2.HighPart = 0x80000;
    07572     Fsr.Data = CompareLeDouble(ROUND_TO_NEAREST,
    07573                                &DoubleOperand1,
    07574                                &DoubleOperand2);
    07575
    07576     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07577         goto TestFailed;
    07578     }
    07579
    07580     Subtest += 1;
    07581     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07582     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07583     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07584     DoubleOperand2.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    07585     Fsr.Data = CompareLeDouble(ROUND_TO_NEAREST,
    07586                                &DoubleOperand1,
    07587                                &DoubleOperand2);
    07588
    07589     if (Fsr.Data != ROUND_TO_NEAREST) {
    07590         goto TestFailed;
    07591     }
    07592
    07593     Subtest += 1;
    07594     DoubleOperand1.LowPart = 0x0;
    07595     DoubleOperand1.HighPart = 0x80000;
    07596     DoubleOperand2.LowPart = 0x0;
    07597     DoubleOperand2.HighPart = SIGN | 0x80000;
    07598     Fsr.Data = CompareLeDouble(ROUND_TO_NEAREST,
    07599                                &DoubleOperand1,
    07600                                &DoubleOperand2);
    07601
    07602     if (Fsr.Data != ROUND_TO_NEAREST) {
    07603         goto TestFailed;
    07604     }
    07605
    07606     Subtest += 1;
    07607     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07608     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07609     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07610     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07611     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07612                                &DoubleOperand1,
    07613                                &DoubleOperand2);
    07614
    07615     if (Fsr.Data != ROUND_TO_NEAREST) {
    07616         goto TestFailed;
    07617     }
    07618
    07619     Subtest += 1;
    07620     DoubleOperand1.LowPart = 0x0;
    07621     DoubleOperand1.HighPart = 0x80000;
    07622     DoubleOperand2.LowPart = 0x0;
    07623     DoubleOperand2.HighPart = 0x80000;
    07624     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07625                                &DoubleOperand1,
    07626                                &DoubleOperand2);
    07627
    07628     if (Fsr.Data != ROUND_TO_NEAREST) {
    07629         goto TestFailed;
    07630     }
    07631
    07632     Subtest += 1;
    07633     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07634     DoubleOperand1.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    07635     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07636     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07637     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07638                                &DoubleOperand1,
    07639                                &DoubleOperand2);
    07640
    07641     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07642         goto TestFailed;
    07643     }
    07644
    07645     Subtest += 1;
    07646     DoubleOperand1.LowPart = 0x0;
    07647     DoubleOperand1.HighPart = SIGN | 0x80000;
    07648     DoubleOperand2.LowPart = 0x0;
    07649     DoubleOperand2.HighPart = 0x80000;
    07650     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07651                                &DoubleOperand1,
    07652                                &DoubleOperand2);
    07653
    07654     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07655         goto TestFailed;
    07656     }
    07657
    07658     Subtest += 1;
    07659     DoubleOperand1.LowPart = 0x0;
    07660     DoubleOperand1.HighPart = 0x80000;
    07661     DoubleOperand2.LowPart = 0x1000;
    07662     DoubleOperand2.HighPart = 0x80000;
    07663     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07664                                &DoubleOperand1,
    07665                                &DoubleOperand2);
    07666
    07667     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07668         goto TestFailed;
    07669     }
    07670
    07671     Subtest += 1;
    07672     DoubleOperand1.LowPart = 0x0;
    07673     DoubleOperand1.HighPart = 0x80000;
    07674     DoubleOperand2.LowPart = 0x0;
    07675     DoubleOperand2.HighPart = 0x81000;
    07676     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07677                                &DoubleOperand1,
    07678                                &DoubleOperand2);
    07679
    07680     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07681         goto TestFailed;
    07682     }
    07683
    07684     Subtest += 1;
    07685     DoubleOperand1.LowPart = 0x0;
    07686     DoubleOperand1.HighPart = 0x40000;
    07687     DoubleOperand2.LowPart = 0x0;
    07688     DoubleOperand2.HighPart = 0x80000;
    07689     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07690                                &DoubleOperand1,
    07691                                &DoubleOperand2);
    07692
    07693     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07694         goto TestFailed;
    07695     }
    07696
    07697     Subtest += 1;
    07698     DoubleOperand1.LowPart = 0x0;
    07699     DoubleOperand1.HighPart = SIGN | 0x80000;
    07700     DoubleOperand2.LowPart = 0x0;
    07701     DoubleOperand2.HighPart = 0x80000;
    07702     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07703                                &DoubleOperand1,
    07704                                &DoubleOperand2);
    07705
    07706     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07707         goto TestFailed;
    07708     }
    07709
    07710     Subtest += 1;
    07711     DoubleOperand1.LowPart = 0x1000;
    07712     DoubleOperand1.HighPart = SIGN | 0x80000;
    07713     DoubleOperand2.LowPart = 0x0;
    07714     DoubleOperand2.HighPart = SIGN | 0x80000;
    07715     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07716                                &DoubleOperand1,
    07717                                &DoubleOperand2);
    07718
    07719     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07720         goto TestFailed;
    07721     }
    07722
    07723     Subtest += 1;
    07724     DoubleOperand1.LowPart = 0x0;
    07725     DoubleOperand1.HighPart = SIGN | 0x81000;
    07726     DoubleOperand2.LowPart = 0x0;
    07727     DoubleOperand2.HighPart = SIGN | 0x80000;
    07728     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07729                                &DoubleOperand1,
    07730                                &DoubleOperand2);
    07731
    07732     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07733         goto TestFailed;
    07734     }
    07735
    07736     Subtest += 1;
    07737     DoubleOperand1.LowPart = 0x0;
    07738     DoubleOperand1.HighPart = SIGN | 0x80000;
    07739     DoubleOperand2.LowPart = 0x0;
    07740     DoubleOperand2.HighPart = SIGN | 0x40000;
    07741     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07742                                &DoubleOperand1,
    07743                                &DoubleOperand2);
    07744
    07745     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07746         goto TestFailed;
    07747     }
    07748
    07749     Subtest += 1;
    07750     DoubleOperand1.LowPart = 0x0;
    07751     DoubleOperand1.HighPart = SIGN | 0x80000;
    07752     DoubleOperand2.LowPart = 0x0;
    07753     DoubleOperand2.HighPart = 0x80000;
    07754     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    07755                                &DoubleOperand1,
    07756                                &DoubleOperand2);
    07757
    07758     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07759         goto TestFailed;
    07760     }
    07761
    07762     Subtest += 1;
    07763     DoubleOperand1.LowPart = 0x0;
    07764     DoubleOperand1.HighPart = 0x80000;
    07765     DoubleOperand2.LowPart = 0x0;
    07766     DoubleOperand2.HighPart = 0x80000;
    07767     Fsr.Data = CompareFDouble(ROUND_TO_NEAREST,
    07768                               &DoubleOperand1,
    07769                               &DoubleOperand2);
    07770
    07771     if (Fsr.Data != ROUND_TO_NEAREST) {
    07772         goto TestFailed;
    07773     }
    07774
    07775     Subtest += 1;
    07776     DoubleOperand1.LowPart = 0x0;
    07777     DoubleOperand1.HighPart = 0x80000;
    07778     DoubleOperand2.LowPart = 0x0;
    07779     DoubleOperand2.HighPart = 0x80000;
    07780     Fsr.Data = CompareUnDouble(ROUND_TO_NEAREST,
    07781                                &DoubleOperand1,
    07782                                &DoubleOperand2);
    07783
    07784     if (Fsr.Data != ROUND_TO_NEAREST) {
    07785         goto TestFailed;
    07786     }
    07787
    07788     Subtest += 1;
    07789     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07790     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    07791     DoubleOperand2.LowPart = 0x0;
    07792     DoubleOperand2.HighPart = 0x80000;
    07793     Fsr.Data = CompareUnDouble(ROUND_TO_NEAREST,
    07794                                &DoubleOperand1,
    07795                                &DoubleOperand2);
    07796
    07797     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07798         goto TestFailed;
    07799     }
    07800
    07801     Subtest += 1;
    07802     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07803     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    07804     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07805     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07806     Fsr.Data = CompareEqDouble(ROUND_TO_NEAREST,
    07807                                &DoubleOperand1,
    07808                                &DoubleOperand2);
    07809
    07810     if (Fsr.Data != ROUND_TO_NEAREST) {
    07811         goto TestFailed;
    07812     }
    07813
    07814     Subtest += 1;
    07815     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07816     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07817     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07818     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07819     Fsr.Data = CompareEqDouble(ROUND_TO_NEAREST,
    07820                                &DoubleOperand1,
    07821                                &DoubleOperand2);
    07822
    07823     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07824         goto TestFailed;
    07825     }
    07826
    07827     Subtest += 1;
    07828     DoubleOperand1.LowPart = 0x0;
    07829     DoubleOperand1.HighPart = 0x80000;
    07830     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07831     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07832     Fsr.Data = CompareUeqDouble(ROUND_TO_NEAREST,
    07833                                 &DoubleOperand1,
    07834                                 &DoubleOperand2);
    07835
    07836     if (Fsr.Data != ROUND_TO_NEAREST) {
    07837         goto TestFailed;
    07838     }
    07839
    07840     Subtest += 1;
    07841     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07842     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    07843     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07844     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07845     Fsr.Data = CompareUeqDouble(ROUND_TO_NEAREST,
    07846                                 &DoubleOperand1,
    07847                                 &DoubleOperand2);
    07848
    07849     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07850         goto TestFailed;
    07851     }
    07852
    07853     Subtest += 1;
    07854     DoubleOperand1.LowPart = 0x0;
    07855     DoubleOperand1.HighPart = 0x80000;
    07856     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    07857     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    07858     Fsr.Data = CompareOltDouble(ROUND_TO_NEAREST,
    07859                                 &DoubleOperand1,
    07860                                 &DoubleOperand2);
    07861
    07862     if (Fsr.Data != ROUND_TO_NEAREST) {
    07863         goto TestFailed;
    07864     }
    07865
    07866     Subtest += 1;
    07867     DoubleOperand1.LowPart = 0x0;
    07868     DoubleOperand1.HighPart = 0x80000;
    07869     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07870     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07871     Fsr.Data = CompareOltDouble(ROUND_TO_NEAREST,
    07872                                 &DoubleOperand1,
    07873                                 &DoubleOperand2);
    07874
    07875     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07876         goto TestFailed;
    07877     }
    07878
    07879     Subtest += 1;
    07880     DoubleOperand1.LowPart = 0x0;
    07881     DoubleOperand1.HighPart = 0x80000;
    07882     DoubleOperand2.LowPart = 0x0;
    07883     DoubleOperand2.HighPart = 0x80000;
    07884     Fsr.Data = CompareUltDouble(ROUND_TO_NEAREST,
    07885                                 &DoubleOperand1,
    07886                                 &DoubleOperand2);
    07887
    07888     if (Fsr.Data != ROUND_TO_NEAREST) {
    07889         goto TestFailed;
    07890     }
    07891
    07892     Subtest += 1;
    07893     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07894     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    07895     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07896     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07897     Fsr.Data = CompareUltDouble(ROUND_TO_NEAREST,
    07898                                 &DoubleOperand1,
    07899                                 &DoubleOperand2);
    07900
    07901     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07902         goto TestFailed;
    07903     }
    07904
    07905     Subtest += 1;
    07906     DoubleOperand1.LowPart = 0x0;
    07907     DoubleOperand1.HighPart = 0x81000;
    07908     DoubleOperand2.LowPart = 0x0;
    07909     DoubleOperand2.HighPart = 0x80000;
    07910     Fsr.Data = CompareOleDouble(ROUND_TO_NEAREST,
    07911                                 &DoubleOperand1,
    07912                                 &DoubleOperand2);
    07913
    07914     if (Fsr.Data != ROUND_TO_NEAREST) {
    07915         goto TestFailed;
    07916     }
    07917
    07918     Subtest += 1;
    07919     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07920     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07921     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07922     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07923     Fsr.Data = CompareOleDouble(ROUND_TO_NEAREST,
    07924                                 &DoubleOperand1,
    07925                                 &DoubleOperand2);
    07926
    07927     if (Fsr.Data != (CC | ROUND_TO_NEAREST)) {
    07928         goto TestFailed;
    07929     }
    07930
    07931     Subtest += 1;
    07932     DoubleOperand1.LowPart = 0x0;
    07933     DoubleOperand1.HighPart = 0x81000;
    07934     DoubleOperand2.LowPart = 0x0;
    07935     DoubleOperand2.HighPart = 0x80000;
    07936     Fsr.Data = CompareSfDouble(ROUND_TO_NEAREST,
    07937                                &DoubleOperand1,
    07938                                &DoubleOperand2);
    07939
    07940     if (Fsr.Data != ROUND_TO_NEAREST) {
    07941         goto TestFailed;
    07942     }
    07943
    07944     Subtest += 1;
    07945     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07946     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07947     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    07948     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    07949     Fsr.Data = CompareSfDouble(ROUND_TO_NEAREST,
    07950                                &DoubleOperand1,
    07951                                &DoubleOperand2);
    07952
    07953     if (Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) {
    07954         goto TestFailed;
    07955     }
    07956
    07957     Subtest += 1;
    07958     DoubleOperand1.LowPart = 0x0;
    07959     DoubleOperand1.HighPart = 0x81000;
    07960     DoubleOperand2.LowPart = 0x0;
    07961     DoubleOperand2.HighPart = 0x80000;
    07962     Fsr.Data = CompareNgleDouble(ROUND_TO_NEAREST,
    07963                                  &DoubleOperand1,
    07964                                  &DoubleOperand2);
    07965
    07966     if (Fsr.Data != ROUND_TO_NEAREST) {
    07967         goto TestFailed;
    07968     }
    07969
    07970     Subtest += 1;
    07971     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07972     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    07973     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    07974     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    07975     Fsr.Data = CompareNgleDouble(ROUND_TO_NEAREST,
    07976                                  &DoubleOperand1,
    07977                                  &DoubleOperand2);
    07978
    07979     if (Fsr.Data != (CC | SV | XV | ROUND_TO_NEAREST)) {
    07980         goto TestFailed;
    07981     }
    07982
    07983     Subtest += 1;
    07984     DoubleOperand1.LowPart = 0x0;
    07985     DoubleOperand1.HighPart = 0x81000;
    07986     DoubleOperand2.LowPart = 0x0;
    07987     DoubleOperand2.HighPart = 0x80000;
    07988     Fsr.Data = CompareSeqDouble(ROUND_TO_NEAREST,
    07989                                 &DoubleOperand1,
    07990                                 &DoubleOperand2);
    07991
    07992     if (Fsr.Data != ROUND_TO_NEAREST) {
    07993         goto TestFailed;
    07994     }
    07995
    07996     Subtest += 1;
    07997     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    07998     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    07999     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08000     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08001     Fsr.Data = CompareSeqDouble(ROUND_TO_NEAREST,
    08002                                 &DoubleOperand1,
    08003                                 &DoubleOperand2);
    08004
    08005     if (Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) {
    08006         goto TestFailed;
    08007     }
    08008
    08009     Subtest += 1;
    08010     DoubleOperand1.LowPart = 0x0;
    08011     DoubleOperand1.HighPart = 0x81000;
    08012     DoubleOperand2.LowPart = 0x0;
    08013     DoubleOperand2.HighPart = 0x80000;
    08014     Fsr.Data = CompareNglDouble(ROUND_TO_NEAREST,
    08015                                 &DoubleOperand1,
    08016                                 &DoubleOperand2);
    08017
    08018     if (Fsr.Data != ROUND_TO_NEAREST) {
    08019         goto TestFailed;
    08020     }
    08021
    08022     Subtest += 1;
    08023     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08024     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    08025     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08026     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08027     Fsr.Data = CompareNglDouble(ROUND_TO_NEAREST,
    08028                                 &DoubleOperand1,
    08029                                 &DoubleOperand2);
    08030
    08031     if (Fsr.Data != (CC | SV | XV | ROUND_TO_NEAREST)) {
    08032         goto TestFailed;
    08033     }
    08034
    08035     Subtest += 1;
    08036     DoubleOperand1.LowPart = 0x0;
    08037     DoubleOperand1.HighPart = 0x81000;
    08038     DoubleOperand2.LowPart = 0x0;
    08039     DoubleOperand2.HighPart = 0x80000;
    08040     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    08041                                &DoubleOperand1,
    08042                                &DoubleOperand2);
    08043
    08044     if (Fsr.Data != ROUND_TO_NEAREST) {
    08045         goto TestFailed;
    08046     }
    08047
    08048     Subtest += 1;
    08049     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08050     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    08051     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08052     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08053     Fsr.Data = CompareLtDouble(ROUND_TO_NEAREST,
    08054                                &DoubleOperand1,
    08055                                &DoubleOperand2);
    08056
    08057     if (Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) {
    08058         goto TestFailed;
    08059     }
    08060
    08061     Subtest += 1;
    08062     DoubleOperand1.LowPart = 0x0;
    08063     DoubleOperand1.HighPart = 0x81000;
    08064     DoubleOperand2.LowPart = 0x0;
    08065     DoubleOperand2.HighPart = 0x80000;
    08066     Fsr.Data = CompareNgeDouble(ROUND_TO_NEAREST,
    08067                                 &DoubleOperand1,
    08068                                 &DoubleOperand2);
    08069
    08070     if (Fsr.Data != ROUND_TO_NEAREST) {
    08071         goto TestFailed;
    08072     }
    08073
    08074     Subtest += 1;
    08075     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08076     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    08077     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08078     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08079     Fsr.Data = CompareNgeDouble(ROUND_TO_NEAREST,
    08080                                 &DoubleOperand1,
    08081                                 &DoubleOperand2);
    08082
    08083     if (Fsr.Data != (CC | SV | XV | ROUND_TO_NEAREST)) {
    08084         goto TestFailed;
    08085     }
    08086
    08087     Subtest += 1;
    08088     DoubleOperand1.LowPart = 0x0;
    08089     DoubleOperand1.HighPart = 0x81000;
    08090     DoubleOperand2.LowPart = 0x0;
    08091     DoubleOperand2.HighPart = 0x80000;
    08092     Fsr.Data = CompareLeDouble(ROUND_TO_NEAREST,
    08093                                &DoubleOperand1,
    08094                                &DoubleOperand2);
    08095
    08096     if (Fsr.Data != ROUND_TO_NEAREST) {
    08097         goto TestFailed;
    08098     }
    08099
    08100     Subtest += 1;
    08101     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08102     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    08103     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08104     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08105     Fsr.Data = CompareLeDouble(ROUND_TO_NEAREST,
    08106                                &DoubleOperand1,
    08107                                &DoubleOperand2);
    08108
    08109     if (Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) {
    08110         goto TestFailed;
    08111     }
    08112
    08113     Subtest += 1;
    08114     DoubleOperand1.LowPart = 0x0;
    08115     DoubleOperand1.HighPart = 0x81000;
    08116     DoubleOperand2.LowPart = 0x0;
    08117     DoubleOperand2.HighPart = 0x80000;
    08118     Fsr.Data = CompareNgtDouble(ROUND_TO_NEAREST,
    08119                                 &DoubleOperand1,
    08120                                 &DoubleOperand2);
    08121
    08122     if (Fsr.Data != ROUND_TO_NEAREST) {
    08123         goto TestFailed;
    08124     }
    08125
    08126     Subtest += 1;
    08127     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08128     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    08129     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08130     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08131     Fsr.Data = CompareNgtDouble(ROUND_TO_NEAREST,
    08132                                 &DoubleOperand1,
    08133                                 &DoubleOperand2);
    08134
    08135     if (Fsr.Data != (CC | SV | XV | ROUND_TO_NEAREST)) {
    08136         goto TestFailed;
    08137     }
    08138
    08139     Subtest += 1;
    08140     DoubleOperand1.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08141     DoubleOperand1.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08142     DoubleOperand2.LowPart = DOUBLE_NAN_LOW;
    08143     DoubleOperand2.HighPart = DOUBLE_QUIET_NAN;
    08144     Count = 0;
    08145     try {
    08146         Fsr.Data = CompareSfDouble(EV | ROUND_TO_NEAREST,
    08147                                    &DoubleOperand1,
    08148                                    &DoubleOperand2);
    08149
    08150     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    08151               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    08152         Count += 1;
    08153     }
    08154
    08155     if (Count == 0) {
    08156         goto TestFailed;
    08157     }
    08158
    08159     Subtest += 1;
    08160     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08161     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    08162     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08163     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08164     Count = 0;
    08165     try {
    08166         Fsr.Data = CompareNgleDouble(EV | ROUND_TO_NEAREST,
    08167                                      &DoubleOperand1,
    08168                                      &DoubleOperand2);
    08169
    08170     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    08171               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    08172         Count += 1;
    08173     }
    08174
    08175     if (Count == 0) {
    08176         goto TestFailed;
    08177     }
    08178
    08179     Subtest += 1;
    08180     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08181     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    08182     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08183     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08184     Count = 0;
    08185     try {
    08186         Fsr.Data = CompareSeqDouble(EV | ROUND_TO_NEAREST,
    08187                                     &DoubleOperand1,
    08188                                     &DoubleOperand2);
    08189
    08190     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    08191               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    08192         Count += 1;
    08193     }
    08194
    08195     if (Count == 0) {
    08196         goto TestFailed;
    08197     }
    08198
    08199     Subtest += 1;
    08200     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08201     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    08202     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08203     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08204     Count = 0;
    08205     try {
    08206         Fsr.Data = CompareNglDouble(EV | ROUND_TO_NEAREST,
    08207                                     &DoubleOperand1,
    08208                                     &DoubleOperand2);
    08209
    08210     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    08211               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    08212         Count += 1;
    08213     }
    08214
    08215     if (Count == 0) {
    08216         goto TestFailed;
    08217     }
    08218
    08219     Subtest += 1;
    08220     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08221     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    08222     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08223     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08224     Count = 0;
    08225     try {
    08226         Fsr.Data = CompareLtDouble(EV | ROUND_TO_NEAREST,
    08227                                    &DoubleOperand1,
    08228                                    &DoubleOperand2);
    08229
    08230     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    08231               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    08232         Count += 1;
    08233     }
    08234
    08235     if (Count == 0) {
    08236         goto TestFailed;
    08237     }
    08238
    08239     Subtest += 1;
    08240     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08241     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    08242     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08243     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08244     Count = 0;
    08245     try {
    08246         Fsr.Data = CompareNgeDouble(EV | ROUND_TO_NEAREST,
    08247                                     &DoubleOperand1,
    08248                                     &DoubleOperand2);
    08249
    08250     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    08251               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    08252         Count += 1;
    08253     }
    08254
    08255     if (Count == 0) {
    08256         goto TestFailed;
    08257     }
    08258
    08259     Subtest += 1;
    08260     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08261     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    08262     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08263     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08264     Count = 0;
    08265     try {
    08266         Fsr.Data = CompareLeDouble(EV | ROUND_TO_NEAREST,
    08267                                    &DoubleOperand1,
    08268                                    &DoubleOperand2);
    08269
    08270     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    08271               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    08272         Count += 1;
    08273     }
    08274
    08275     if (Count == 0) {
    08276         goto TestFailed;
    08277     }
    08278
    08279     Subtest += 1;
    08280     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08281     DoubleOperand1.HighPart = DOUBLE_QUIET_NAN;
    08282     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08283     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08284     Count = 0;
    08285     try {
    08286         Fsr.Data = CompareNgtDouble(EV | ROUND_TO_NEAREST,
    08287                                     &DoubleOperand1,
    08288                                     &DoubleOperand2);
    08289
    08290     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    08291               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    08292         Count += 1;
    08293     }
    08294
    08295     if (Count == 0) {
    08296         goto TestFailed;
    08297     }
    08298
    08299     Subtest += 1;
    08300     DoubleOperand1.LowPart = DOUBLE_NAN_LOW;
    08301     DoubleOperand1.HighPart = DOUBLE_SIGNAL_NAN;
    08302     DoubleOperand2.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    08303     DoubleOperand2.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    08304     Count = 0;
    08305     try {
    08306         Fsr.Data = CompareEqDouble(EV | ROUND_TO_NEAREST,
    08307                                    &DoubleOperand1,
    08308                                    &DoubleOperand2);
    08309
    08310     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    08311               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    08312         Count += 1;
    08313     }
    08314
    08315     if (Count == 0) {
    08316         goto TestFailed;
    08317     }
    08318
    08319     //
    08320     // End of test 19.
    08321     //
    08322
    08323     printf("succeeded\n");
    08324     return;
    08325
    08326     //
    08327     // Test 19 failed.
    08328     //
    08329
    08330 TestFailed:
    08331     printf(" subtest %d failed, fsr = %lx\n", Subtest, Fsr.Data);
    08332     return;
    08333 }