test: flpt.h File Reference

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

# flpt.h File Reference

`#include "stdio.h"`
`#include "string.h"`
`#include "ntos.h"`

Go to the source code of this file.

## Classes

union | _FLOATING_STATUS

## Defines

#define | SI (1 << 2)
#define | SU (1 << 3)
#define | SO (1 << 4)
#define | SZ (1 << 5)
#define | SV (1 << 6)
#define | EI (1 << 7)
#define | EU (1 << 8)
#define | EO (1 << 9)
#define | EZ (1 << 10)
#define | EV (1 << 11)
#define | XI (1 << 12)
#define | XU (1 << 13)
#define | XO (1 << 14)
#define | XZ (1 << 15)
#define | XV (1 << 16)
#define | CC (1 << 23)
#define | FS (1 << 24)
#define | MINUS_DOUBLE_INFINITY_VALUE (DOUBLE_INFINITY_VALUE_HIGH | (1 << 31))
#define | MINUS_SINGLE_INFINITY_VALUE (SINGLE_INFINITY_VALUE | (1 << 31))
#define | DOUBLE_SIGNAL_NAN_PREFIX 0x7ff80000
#define | SINGLE_SIGNAL_NAN_PREFIX 0x7fc00000
#define | SIGN (1 << 31)

## Typedefs

typedef _FLOATING_STATUS | FLOATING_STATUS
typedef _FLOATING_STATUS * | PFLOATING_STATUS

## Functions

ULONG | AddDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Addend1, IN PULARGE_INTEGER Addend2, OUT PULARGE_INTEGER Result)
ULONG | DivideDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Dividend, IN PULARGE_INTEGER Divisor, OUT PULARGE_INTEGER Result)
ULONG | MultiplyDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Multiplicand, IN PULARGE_INTEGER Multiplier, OUT PULARGE_INTEGER Result)
ULONG | SubtractDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Subtrahend, IN PULARGE_INTEGER Minuend, OUT PULARGE_INTEGER Result)
ULONG | AddSingle (IN ULONG RoundingMode, IN ULONG Addend1, IN ULONG Addend2, OUT PULONG Result)
ULONG | DivideSingle (IN ULONG RoundingMode, IN ULONG Dividend, IN ULONG Divisor, OUT PULONG Result)
ULONG | MultiplySingle (IN ULONG RoundingMode, IN ULONG Multiplicand, IN ULONG Multiplier, OUT PULONG Result)
ULONG | SubtractSingle (IN ULONG RoundingMode, IN ULONG Subtrahend, IN ULONG Minuend, OUT PULONG Result)
ULONG | AbsoluteDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Operand, OUT PULARGE_INTEGER Result)
ULONG | CeilToLongwordFromDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Source, OUT PULONG Result)
ULONG | CeilToLongwordFromSingle (IN ULONG RoundingMode, IN ULONG Source, OUT PULONG Result)
ULONG | ConvertToDoubleFromSingle (IN ULONG RoundingMode, IN ULONG Source, OUT PULARGE_INTEGER Result)
ULONG | ConvertToLongwordFromDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Source, OUT PULONG Result)
ULONG | ConvertToLongwordFromSingle (IN ULONG RoundingMode, IN ULONG Source, OUT PULONG Result)
ULONG | ConvertToSingleFromDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Source, OUT PULONG Result)
ULONG | CompareFDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareUnDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareEqDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareUeqDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareOltDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareUltDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareOleDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareUleDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareSfDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareNgleDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareSeqDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareNglDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareLtDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareNgeDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareLeDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareNgtDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Comparand1, IN PULARGE_INTEGER Comparand2)
ULONG | CompareFSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareUnSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareEqSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareUeqSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareOltSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareUltSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareOleSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareUleSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareSfSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareNgleSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareSeqSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareNglSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareLtSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareNgeSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareLeSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | CompareNgtSingle (IN ULONG RoundingMode, IN ULONG Comparand1, IN ULONG Comparand2)
ULONG | FloorToLongwordFromDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Source, OUT PULONG Result)
ULONG | FloorToLongwordFromSingle (IN ULONG RoundingMode, IN ULONG Source, OUT PULONG Result)
ULONG | MoveDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Operand, OUT PULARGE_INTEGER Result)
ULONG | NegateDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Operand, OUT PULARGE_INTEGER Result)
ULONG | AbsoluteSingle (IN ULONG RoundingMode, IN ULONG Operand, OUT PULONG Result)
ULONG | MoveSingle (IN ULONG RoundingMode, IN ULONG Operand, OUT PULONG Result)
ULONG | NegateSingle (IN ULONG RoundingMode, IN ULONG Operand, OUT PULONG Result)
ULONG | RoundToLongwordFromDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Source, OUT PULONG Result)
ULONG | RoundToLongwordFromSingle (IN ULONG RoundingMode, IN ULONG Source, OUT PULONG Result)
ULONG | TruncateToLongwordFromDouble (IN ULONG RoundingMode, IN PULARGE_INTEGER Source, OUT PULONG Result)
ULONG | TruncateToLongwordFromSingle (IN ULONG RoundingMode, IN ULONG Source, OUT PULONG Result)
VOID | Test1 (VOID)
VOID | Test2 (VOID)
VOID | Test3 (VOID)
VOID | Test4 (VOID)
VOID | Test5 (VOID)
VOID | Test6 (VOID)
VOID | Test7 (VOID)
VOID | Test8 (VOID)
VOID | Test9 (VOID)
VOID | Test10 (VOID)
VOID | Test11 (VOID)
VOID | Test12 (VOID)
VOID | Test13 (VOID)
VOID | Test14 (VOID)
VOID | Test15 (VOID)
VOID | Test16 (VOID)
VOID | Test17 (VOID)
VOID | Test18 (VOID)
VOID | Test19 (VOID)
VOID | Test20 (VOID)
VOID | Test21 (VOID)
VOID | Test22 (VOID)
VOID | Test23 (VOID)
VOID | Test24 (VOID)
VOID | Test25 (VOID)
VOID | Test26 (VOID)

## Define Documentation

#define CC (1 << 23)

| Definition at line 52 of file flpt.h. Referenced by Test19(), and Test9().

#define DOUBLE_SIGNAL_NAN_PREFIX 0x7ff80000

| Definition at line 67 of file flpt.h. Referenced by Test16().

#define EI (1 << 7)

| Definition at line 40 of file flpt.h. Referenced by Test1(), Test11(), Test12(), Test13(), Test14(), Test15(), Test17(), Test2(), Test21(), Test23(), Test24(), Test3(), Test4(), Test5(), and Test7().

#define EO (1 << 9)

| Definition at line 42 of file flpt.h. Referenced by Test1(), Test11(), Test17(), Test21(), and Test7().

#define EU (1 << 8)

| Definition at line 41 of file flpt.h. Referenced by Test17(), Test21(), and Test7().

#define EV (1 << 11)

| Definition at line 44 of file flpt.h. Referenced by Test10(), Test16(), Test17(), Test18(), Test19(), Test20(), Test21(), Test22(), Test23(), Test24(), Test25(), Test26(), Test6(), Test7(), Test8(), and Test9().

#define EZ (1 << 10)

| Definition at line 43 of file flpt.h. Referenced by Test18(), and Test8().

#define FS (1 << 24)

| Definition at line 54 of file flpt.h. Referenced by Test16(), and Test6().

#define MINUS_DOUBLE_INFINITY_VALUE (DOUBLE_INFINITY_VALUE_HIGH | (1 << 31))

| Definition at line 60 of file flpt.h. Referenced by Test16(), Test17(), Test18(), Test19(), Test21(), Test22(), Test24(), and Test25().

#define MINUS_SINGLE_INFINITY_VALUE (SINGLE_INFINITY_VALUE | (1 << 31))

| Definition at line 61 of file flpt.h. Referenced by Test21(), Test22(), Test23(), Test26(), Test6(), Test7(), Test8(), and Test9().

#define SI (1 << 2)

| Definition at line 34 of file flpt.h. Referenced by Test11(), Test12(), Test13(), Test14(), Test15(), Test17(), Test18(), Test2(), Test21(), Test23(), Test24(), Test25(), Test26(), Test3(), Test4(), Test5(), Test7(), and Test8().

#define SIGN (1 << 31)

| Definition at line 74 of file flpt.h. Referenced by Test1(), Test10(), Test11(), Test14(), Test15(), Test16(), Test17(), Test18(), Test19(), Test20(), Test21(), Test22(), Test23(), Test24(), Test25(), Test26(), Test4(), Test5(), Test6(), Test7(), Test8(), and Test9().

#define SINGLE_SIGNAL_NAN_PREFIX 0x7fc00000

| Definition at line 68 of file flpt.h. Referenced by Test6().

#define SO (1 << 4)

| Definition at line 36 of file flpt.h. Referenced by Test17(), Test18(), Test21(), Test7(), and Test8().

#define SU (1 << 3)

| Definition at line 35 of file flpt.h. Referenced by Test17(), Test21(), Test25(), Test26(), and Test7().

#define SV (1 << 6)

| Definition at line 38 of file flpt.h. Referenced by Test10(), Test16(), Test17(), Test18(), Test19(), Test20(), Test21(), Test22(), Test23(), Test24(), Test25(), Test26(), Test6(), Test7(), Test8(), and Test9().

#define SZ (1 << 5)

| Definition at line 37 of file flpt.h. Referenced by Test18(), and Test8().

#define XI (1 << 12)

| Definition at line 46 of file flpt.h. Referenced by Test17(), Test21(), and Test7().

#define XO (1 << 14)

| Definition at line 48 of file flpt.h. Referenced by Test17(), Test21(), and Test7().

#define XU (1 << 13)

| Definition at line 47 of file flpt.h.

#define XV (1 << 16)

| Definition at line 50 of file flpt.h. Referenced by Test10(), Test16(), Test17(), Test18(), Test19(), Test20(), Test21(), Test22(), Test25(), Test26(), Test6(), Test7(), Test8(), and Test9().

#define XZ (1 << 15)

| Definition at line 49 of file flpt.h. Referenced by Test18(), and Test8().

## Typedef Documentation

typedef union _FLOATING_STATUS FLOATING_STATUS

| Referenced by Test1().

typedef union _FLOATING_STATUS * PFLOATING_STATUS

## Function Documentation

ULONG AbsoluteDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Operand,
|  | OUT PULARGE_INTEGER | Result
| ) |

| Referenced by Test20().

ULONG AbsoluteSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Operand,
|  | OUT PULONG | Result
| ) |

| Referenced by Test10().

ULONG AddDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Addend1,
|  | IN PULARGE_INTEGER | Addend2,
|  | OUT PULARGE_INTEGER | Result
| ) |

| Referenced by Test11(), Test12(), Test13(), Test14(), Test15(), and Test16().

ULONG AddSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Addend1,
|  | IN ULONG | Addend2,
|  | OUT PULONG | Result
| ) |

| Referenced by Test1(), Test2(), Test3(), Test4(), Test5(), and Test6().

ULONG CeilToLongwordFromDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Source,
|  | OUT PULONG | Result
| ) |

ULONG CeilToLongwordFromSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Source,
|  | OUT PULONG | Result
| ) |

ULONG CompareEqDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareEqSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareFDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareFSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareLeDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareLeSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareLtDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareLtSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareNgeDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareNgeSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareNglDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareNgleDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareNgleSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareNglSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareNgtDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareNgtSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareOleDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareOleSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareOltDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareOltSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareSeqDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareSeqSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareSfDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareSfSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareUeqDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareUeqSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareUleDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

ULONG CompareUleSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

ULONG CompareUltDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareUltSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG CompareUnDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Comparand1,
|  | IN PULARGE_INTEGER | Comparand2
| ) |

| Referenced by Test19().

ULONG CompareUnSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Comparand1,
|  | IN ULONG | Comparand2
| ) |

| Referenced by Test9().

ULONG ConvertToDoubleFromSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Source,
|  | OUT PULARGE_INTEGER | Result
| ) |

| Referenced by Test22().

ULONG ConvertToLongwordFromDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Source,
|  | OUT PULONG | Result
| ) |

| Referenced by Test24().

ULONG ConvertToLongwordFromSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Source,
|  | OUT PULONG | Result
| ) |

| Referenced by Test23().

ULONG ConvertToSingleFromDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Source,
|  | OUT PULONG | Result
| ) |

| Referenced by Test21().

ULONG DivideDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Dividend,
|  | IN PULARGE_INTEGER | Divisor,
|  | OUT PULARGE_INTEGER | Result
| ) |

| Referenced by Test18().

ULONG DivideSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Dividend,
|  | IN ULONG | Divisor,
|  | OUT PULONG | Result
| ) |

| Referenced by Test8().

ULONG FloorToLongwordFromDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Source,
|  | OUT PULONG | Result
| ) |

ULONG FloorToLongwordFromSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Source,
|  | OUT PULONG | Result
| ) |

ULONG MoveDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Operand,
|  | OUT PULARGE_INTEGER | Result
| ) |

| Referenced by Test20().

ULONG MoveSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Operand,
|  | OUT PULONG | Result
| ) |

| Referenced by Test10().

ULONG MultiplyDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Multiplicand,
|  | IN PULARGE_INTEGER | Multiplier,
|  | OUT PULARGE_INTEGER | Result
| ) |

| Referenced by Test17().

ULONG MultiplySingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Multiplicand,
|  | IN ULONG | Multiplier,
|  | OUT PULONG | Result
| ) |

| Referenced by Test7().

ULONG NegateDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Operand,
|  | OUT PULARGE_INTEGER | Result
| ) |

| Referenced by Test20().

ULONG NegateSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Operand,
|  | OUT PULONG | Result
| ) |

| Referenced by Test10().

ULONG RoundToLongwordFromDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Source,
|  | OUT PULONG | Result
| ) |

| Referenced by Test24().

ULONG RoundToLongwordFromSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Source,
|  | OUT PULONG | Result
| ) |

| Referenced by Test23().

ULONG SubtractDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Subtrahend,
|  | IN PULARGE_INTEGER | Minuend,
|  | OUT PULARGE_INTEGER | Result
| ) |

| Referenced by Test11().

ULONG SubtractSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Subtrahend,
|  | IN ULONG | Minuend,
|  | OUT PULONG | Result
| ) |

| Referenced by Test1().

VOID Test1 | ( | VOID |  | ) |

Definition at line 75 of file flpt.c.

References AddSingle(), Count, _FLOATING_STATUS::Data, EI, EO, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, FLOATING_STATUS, SIGN, and SubtractSingle().

Referenced by main().

    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 }

VOID Test10 | ( | VOID |  | ) |

Definition at line 3440 of file flpt.c.

References AbsoluteSingle(), Count, _FLOATING_STATUS::Data, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, MoveSingle(), NegateSingle(), SIGN, SV, and XV.

Referenced by main().

    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 }

VOID Test11 | ( | VOID |  | ) |

Definition at line 3640 of file flpt.c.

References AddDouble(), Count, _FLOATING_STATUS::Data, EI, EO, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, SI, SIGN, and SubtractDouble().

Referenced by main().

    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 }

VOID Test12 | ( | VOID |  | ) |

Definition at line 4201 of file flpt.c.

References AddDouble(), Count, _FLOATING_STATUS::Data, EI, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, and SI.

Referenced by main().

    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 }

VOID Test13 | ( | VOID |  | ) |

Definition at line 4391 of file flpt.c.

References AddDouble(), Count, _FLOATING_STATUS::Data, EI, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, and SI.

Referenced by main().

    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 }

VOID Test14 | ( | VOID |  | ) |

Definition at line 4581 of file flpt.c.

References AddDouble(), Count, _FLOATING_STATUS::Data, EI, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, SI, and SIGN.

Referenced by main().

    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 }

VOID Test15 | ( | VOID |  | ) |

Definition at line 4899 of file flpt.c.

References AddDouble(), Count, _FLOATING_STATUS::Data, EI, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, SI, and SIGN.

Referenced by main().

    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 }

VOID Test16 | ( | VOID |  | ) |

Definition at line 5217 of file flpt.c.

References AddDouble(), Count, _FLOATING_STATUS::Data, DOUBLE_SIGNAL_NAN_PREFIX, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, FS, MINUS_DOUBLE_INFINITY_VALUE, SIGN, SV, and XV.

Referenced by main().

    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 }

VOID Test17 | ( | VOID |  | ) |

Definition at line 5679 of file flpt.c.

References Count, _FLOATING_STATUS::Data, EI, EO, EU, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, MINUS_DOUBLE_INFINITY_VALUE, MultiplyDouble(), SI, SIGN, SO, SU, SV, XI, XO, and XV.

Referenced by main().

    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 }

VOID Test18 | ( | VOID |  | ) |

Definition at line 6769 of file flpt.c.

References Count, _FLOATING_STATUS::Data, DivideDouble(), EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, EZ, MINUS_DOUBLE_INFINITY_VALUE, SI, SIGN, SO, SV, SZ, XV, and XZ.

Referenced by main().

    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 }

VOID Test19 | ( | VOID |  | ) |

Definition at line 7401 of file flpt.c.

References CC, CompareEqDouble(), CompareFDouble(), CompareLeDouble(), CompareLtDouble(), CompareNgeDouble(), CompareNglDouble(), CompareNgleDouble(), CompareNgtDouble(), CompareOleDouble(), CompareOltDouble(), CompareSeqDouble(), CompareSfDouble(), CompareUeqDouble(), CompareUltDouble(), CompareUnDouble(), Count, _FLOATING_STATUS::Data, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, MINUS_DOUBLE_INFINITY_VALUE, SIGN, SV, and XV.

Referenced by main().

    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 }

VOID Test2 | ( | VOID |  | ) |

Definition at line 425 of file flpt.c.

References AddSingle(), Count, _FLOATING_STATUS::Data, EI, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, and SI.

Referenced by main().

    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 }

VOID Test20 | ( | VOID |  | ) |

Definition at line 28 of file flpt2.c.

References AbsoluteDouble(), Count, _FLOATING_STATUS::Data, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, MoveDouble(), NegateDouble(), SIGN, SV, and XV.

Referenced by main().

    00032 {
    00033
    00034     ULONG Count;
    00035     FLOATING_STATUS Fsr;
    00036     ULARGE_INTEGER DoubleOperand;
    00037     ULARGE_INTEGER DoubleResult;
    00038     ULONG Subtest;
    00039
    00040     //
    00041     // Test 20 - Absolute, move, and negate double test.
    00042     //
    00043
    00044     Subtest = 0;
    00045     printf("    Test 20 - absolute, move, and negate double ...");
    00046     Subtest += 1;
    00047     DoubleOperand.LowPart = 0x0;
    00048     DoubleOperand.HighPart = 0x80000;
    00049     Fsr.Data = AbsoluteDouble(ROUND_TO_NEAREST,
    00050                               &DoubleOperand,
    00051                               &DoubleResult);
    00052
    00053     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00054         (DoubleResult.LowPart != 0x0) ||
    00055         (DoubleResult.HighPart != 0x80000)) {
    00056         goto TestFailed;
    00057     }
    00058
    00059     Subtest += 1;
    00060     DoubleOperand.LowPart = 0x0;
    00061     DoubleOperand.HighPart = SIGN | 0x80000;
    00062     Fsr.Data = AbsoluteDouble(ROUND_TO_NEAREST,
    00063                               &DoubleOperand,
    00064                               &DoubleResult);
    00065
    00066     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00067         (DoubleResult.LowPart != 0x0) ||
    00068         (DoubleResult.HighPart != 0x80000)) {
    00069         goto TestFailed;
    00070     }
    00071
    00072     Subtest += 1;
    00073     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    00074     DoubleOperand.HighPart = DOUBLE_QUIET_NAN;
    00075     Fsr.Data = AbsoluteDouble(ROUND_TO_NEAREST,
    00076                               &DoubleOperand,
    00077                               &DoubleResult);
    00078
    00079     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00080         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    00081         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    00082         goto TestFailed;
    00083     }
    00084
    00085     Subtest += 1;
    00086     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    00087     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    00088     Fsr.Data = AbsoluteDouble(ROUND_TO_NEAREST,
    00089                               &DoubleOperand,
    00090                               &DoubleResult);
    00091
    00092     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    00093         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    00094         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    00095         goto TestFailed;
    00096     }
    00097
    00098     Subtest += 1;
    00099     Count = 0;
    00100     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    00101     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    00102     try {
    00103         Fsr.Data = AbsoluteDouble(EV | ROUND_TO_NEAREST,
    00104                                   &DoubleOperand,
    00105                                   &DoubleResult);
    00106
    00107     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    00108               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00109         Count += 1;
    00110     }
    00111
    00112     if (Count == 0) {
    00113         goto TestFailed;
    00114     }
    00115
    00116     Subtest += 1;
    00117     DoubleOperand.LowPart = 0x0;
    00118     DoubleOperand.HighPart = 0x80000;
    00119     Fsr.Data = MoveDouble(ROUND_TO_NEAREST,
    00120                           &DoubleOperand,
    00121                           &DoubleResult);
    00122
    00123     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00124         (DoubleResult.LowPart != 0x0) ||
    00125         (DoubleResult.HighPart != 0x80000)) {
    00126         goto TestFailed;
    00127     }
    00128
    00129     Subtest += 1;
    00130     DoubleOperand.LowPart = 0x0;
    00131     DoubleOperand.HighPart = SIGN | 0x80000;
    00132     Fsr.Data = MoveDouble(ROUND_TO_NEAREST,
    00133                           &DoubleOperand,
    00134                           &DoubleResult);
    00135
    00136     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00137         (DoubleResult.LowPart != 0x0) ||
    00138         (DoubleResult.HighPart != (SIGN | 0x80000))) {
    00139         goto TestFailed;
    00140     }
    00141
    00142     Subtest += 1;
    00143     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    00144     DoubleOperand.HighPart = DOUBLE_QUIET_NAN;
    00145     Fsr.Data = MoveDouble(ROUND_TO_NEAREST,
    00146                           &DoubleOperand,
    00147                           &DoubleResult);
    00148
    00149     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00150         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    00151         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    00152         goto TestFailed;
    00153     }
    00154
    00155     Subtest += 1;
    00156     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    00157     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    00158     Fsr.Data = MoveDouble(ROUND_TO_NEAREST,
    00159                           &DoubleOperand,
    00160                           &DoubleResult);
    00161
    00162     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00163         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    00164         (DoubleResult.HighPart != DOUBLE_SIGNAL_NAN)) {
    00165         goto TestFailed;
    00166     }
    00167
    00168     Subtest += 1;
    00169     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    00170     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    00171     Fsr.Data = MoveDouble(EV | ROUND_TO_NEAREST,
    00172                           &DoubleOperand,
    00173                           &DoubleResult);
    00174
    00175     if ((Fsr.Data != (EV | ROUND_TO_NEAREST)) ||
    00176         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    00177         (DoubleResult.HighPart != DOUBLE_SIGNAL_NAN)) {
    00178         goto TestFailed;
    00179     }
    00180
    00181     Subtest += 1;
    00182     DoubleOperand.LowPart = 0x0;
    00183     DoubleOperand.HighPart = 0x80000;
    00184     Fsr.Data = NegateDouble(ROUND_TO_NEAREST,
    00185                             &DoubleOperand,
    00186                             &DoubleResult);
    00187
    00188     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00189         (DoubleResult.LowPart != 0x0) ||
    00190         (DoubleResult.HighPart != (SIGN | 0x80000))) {
    00191         goto TestFailed;
    00192     }
    00193
    00194     Subtest += 1;
    00195     DoubleOperand.LowPart = 0x0;
    00196     DoubleOperand.HighPart = SIGN | 0x80000;
    00197     Fsr.Data = NegateDouble(ROUND_TO_NEAREST,
    00198                             &DoubleOperand,
    00199                             &DoubleResult);
    00200
    00201     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00202         (DoubleResult.LowPart != 0x0) ||
    00203         (DoubleResult.HighPart != 0x80000)) {
    00204         goto TestFailed;
    00205     }
    00206
    00207     Subtest += 1;
    00208     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    00209     DoubleOperand.HighPart = DOUBLE_QUIET_NAN;
    00210     Fsr.Data = NegateDouble(ROUND_TO_NEAREST,
    00211                             &DoubleOperand,
    00212                             &DoubleResult);
    00213
    00214     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00215         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    00216         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    00217         goto TestFailed;
    00218     }
    00219
    00220     Subtest += 1;
    00221     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    00222     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    00223     Fsr.Data = NegateDouble(ROUND_TO_NEAREST,
    00224                             &DoubleOperand,
    00225                             &DoubleResult);
    00226
    00227     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    00228         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    00229         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    00230         goto TestFailed;
    00231     }
    00232
    00233     Subtest += 1;
    00234     Count = 0;
    00235     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    00236     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    00237     try {
    00238         Fsr.Data = NegateDouble(EV | ROUND_TO_NEAREST,
    00239                                 &DoubleOperand,
    00240                                 &DoubleResult);
    00241
    00242     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    00243               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00244         Count += 1;
    00245     }
    00246
    00247     if (Count == 0) {
    00248         goto TestFailed;
    00249     }
    00250
    00251     //
    00252     // End of test 20.
    00253     //
    00254
    00255     printf("succeeded\n");
    00256     return;
    00257
    00258     //
    00259     // Test 20 failed.
    00260     //
    00261
    00262 TestFailed:
    00263     printf(" subtest %d failed, fsr = %lx, result = %lx, %lx\n",
    00264            Subtest,
    00265            Fsr.Data,
    00266            DoubleResult.LowPart,
    00267            DoubleResult.HighPart);
    00268
    00269     return;
    00270 }

VOID Test21 | ( | VOID |  | ) |

Definition at line 273 of file flpt2.c.

References ConvertToSingleFromDouble(), Count, _FLOATING_STATUS::Data, EI, EO, EU, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, MINUS_DOUBLE_INFINITY_VALUE, MINUS_SINGLE_INFINITY_VALUE, SI, SIGN, SO, SU, SV, XI, XO, and XV.

Referenced by main().

    00277 {
    00278
    00279     ULONG Count;
    00280     FLOATING_STATUS Fsr;
    00281     ULARGE_INTEGER DoubleOperand;
    00282     ULONG SingleResult;
    00283     ULONG Subtest;
    00284
    00285     //
    00286     // Test 21 - Convert to single.
    00287     //
    00288
    00289     Subtest = 0;
    00290     printf("    Test 21 - convert to single ...");
    00291     Subtest += 1;
    00292     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    00293     DoubleOperand.HighPart = DOUBLE_QUIET_NAN;
    00294     Fsr.Data = ConvertToSingleFromDouble(ROUND_TO_NEAREST,
    00295                                          &DoubleOperand,
    00296                                          &SingleResult);
    00297
    00298     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00299         (SingleResult != SINGLE_QUIET_NAN)) {
    00300         goto TestFailed;
    00301     }
    00302
    00303     Subtest += 1;
    00304     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    00305     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    00306     Fsr.Data = ConvertToSingleFromDouble(ROUND_TO_NEAREST,
    00307                                          &DoubleOperand,
    00308                                          &SingleResult);
    00309
    00310     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    00311         (SingleResult != SINGLE_QUIET_NAN)) {
    00312         goto TestFailed;
    00313     }
    00314
    00315     Subtest += 1;
    00316     DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    00317     DoubleOperand.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    00318     Fsr.Data = ConvertToSingleFromDouble(ROUND_TO_NEAREST,
    00319                                          &DoubleOperand,
    00320                                          &SingleResult);
    00321
    00322     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00323         (SingleResult != SINGLE_INFINITY_VALUE)) {
    00324         goto TestFailed;
    00325     }
    00326
    00327     Subtest += 1;
    00328     DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    00329     DoubleOperand.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    00330     Fsr.Data = ConvertToSingleFromDouble(ROUND_TO_NEAREST,
    00331                                          &DoubleOperand,
    00332                                          &SingleResult);
    00333
    00334     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00335         (SingleResult != MINUS_SINGLE_INFINITY_VALUE)) {
    00336         goto TestFailed;
    00337     }
    00338
    00339     Subtest += 1;
    00340     Count = 0;
    00341     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    00342     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    00343     try {
    00344         Fsr.Data = ConvertToSingleFromDouble(EV | ROUND_TO_NEAREST,
    00345                                              &DoubleOperand,
    00346                                              &SingleResult);
    00347
    00348     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    00349               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00350         Count += 1;
    00351     }
    00352
    00353     if (Count == 0) {
    00354         goto TestFailed;
    00355     }
    00356
    00357     Subtest += 1;
    00358     DoubleOperand.LowPart = 0x0;
    00359     DoubleOperand.HighPart =
    00360         ((DOUBLE_EXPONENT_BIAS - SINGLE_EXPONENT_BIAS) << (52 - 32)) | 0xfffff;
    00361     Fsr.Data = ConvertToSingleFromDouble(ROUND_TO_ZERO,
    00362                                          &DoubleOperand,
    00363                                          &SingleResult);
    00364
    00365     if ((Fsr.Data != ROUND_TO_ZERO) ||
    00366         (SingleResult != 0x7ffffc)) {
    00367         goto TestFailed;
    00368     }
    00369
    00370     Subtest += 1;
    00371     DoubleOperand.LowPart = 0x0;
    00372     DoubleOperand.HighPart = SIGN |
    00373         ((DOUBLE_EXPONENT_BIAS - SINGLE_EXPONENT_BIAS) << (52 - 32)) | 0xfffff;
    00374     Fsr.Data = ConvertToSingleFromDouble(ROUND_TO_ZERO,
    00375                                          &DoubleOperand,
    00376                                          &SingleResult);
    00377
    00378     if ((Fsr.Data != ROUND_TO_ZERO) ||
    00379         (SingleResult != (SIGN | 0x7ffffc))) {
    00380         goto TestFailed;
    00381     }
    00382
    00383     Subtest += 1;
    00384     DoubleOperand.LowPart = 0xf0000000;
    00385     DoubleOperand.HighPart =
    00386         ((DOUBLE_EXPONENT_BIAS - SINGLE_EXPONENT_BIAS) << (52 - 32)) | 0xfffff;
    00387     Fsr.Data = ConvertToSingleFromDouble(ROUND_TO_ZERO,
    00388                                          &DoubleOperand,
    00389                                          &SingleResult);
    00390
    00391     if ((Fsr.Data != (SI | SU | ROUND_TO_ZERO)) ||
    00392         (SingleResult != 0x7fffff)) {
    00393         goto TestFailed;
    00394     }
    00395
    00396     Subtest += 1;
    00397     DoubleOperand.LowPart = 0xf0000000;
    00398     DoubleOperand.HighPart = SIGN |
    00399         ((DOUBLE_EXPONENT_BIAS - SINGLE_EXPONENT_BIAS) << (52 - 32)) | 0xfffff;
    00400     Fsr.Data = ConvertToSingleFromDouble(ROUND_TO_ZERO,
    00401                                          &DoubleOperand,
    00402                                          &SingleResult);
    00403
    00404     if ((Fsr.Data != (SI | SU | ROUND_TO_ZERO)) ||
    00405         (SingleResult != (SIGN | 0x7fffff))) {
    00406         goto TestFailed;
    00407     }
    00408
    00409     Subtest += 1;
    00410     Count = 0;
    00411     DoubleOperand.LowPart = 0xf0000000;
    00412     DoubleOperand.HighPart = SIGN |
    00413         ((DOUBLE_EXPONENT_BIAS - SINGLE_EXPONENT_BIAS) << (52 - 32)) | 0xfffff;
    00414     try {
    00415         Fsr.Data = ConvertToSingleFromDouble(EU | ROUND_TO_ZERO,
    00416                                              &DoubleOperand,
    00417                                              &SingleResult);
    00418
    00419     } except ((GetExceptionCode() == STATUS_FLOAT_UNDERFLOW) ?
    00420               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00421         Count += 1;
    00422     }
    00423
    00424     if (Count == 0) {
    00425         goto TestFailed;
    00426     }
    00427
    00428     Subtest += 1;
    00429     Count = 0;
    00430     DoubleOperand.LowPart = 0xf0000000;
    00431     DoubleOperand.HighPart = SIGN |
    00432         ((DOUBLE_EXPONENT_BIAS - SINGLE_EXPONENT_BIAS) << (52 - 32)) | 0xfffff;
    00433     try {
    00434         Fsr.Data = ConvertToSingleFromDouble(EI | ROUND_TO_ZERO,
    00435                                              &DoubleOperand,
    00436                                              &SingleResult);
    00437
    00438     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    00439               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00440         Count += 1;
    00441     }
    00442
    00443     if (Count == 0) {
    00444         goto TestFailed;
    00445     }
    00446
    00447     Subtest += 1;
    00448     DoubleOperand.LowPart = 0x0;
    00449     DoubleOperand.HighPart = 0xfffff;
    00450     Fsr.Data = ConvertToSingleFromDouble(ROUND_TO_ZERO,
    00451                                          &DoubleOperand,
    00452                                          &SingleResult);
    00453
    00454     if ((Fsr.Data != (SI | SU | ROUND_TO_ZERO)) ||
    00455         (SingleResult != 0x0)) {
    00456         goto TestFailed;
    00457     }
    00458
    00459     Subtest += 1;
    00460     DoubleOperand.LowPart = 0x0;
    00461     DoubleOperand.HighPart = SIGN | 0xfffff;
    00462     Fsr.Data = ConvertToSingleFromDouble(ROUND_TO_ZERO,
    00463                                          &DoubleOperand,
    00464                                          &SingleResult);
    00465
    00466     if ((Fsr.Data != (SI | SU | ROUND_TO_ZERO)) ||
    00467         (SingleResult != (SIGN | 0x0))) {
    00468         goto TestFailed;
    00469     }
    00470
    00471     Subtest += 1;
    00472     Count = 0;
    00473     DoubleOperand.LowPart = 0x0;
    00474     DoubleOperand.HighPart = 0xfffff;
    00475     try {
    00476         Fsr.Data = ConvertToSingleFromDouble(EU | ROUND_TO_ZERO,
    00477                                              &DoubleOperand,
    00478                                              &SingleResult);
    00479
    00480     } except ((GetExceptionCode() == STATUS_FLOAT_UNDERFLOW) ?
    00481               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00482         Count += 1;
    00483     }
    00484
    00485     if (Count == 0) {
    00486         goto TestFailed;
    00487     }
    00488
    00489     Subtest += 1;
    00490     Count = 0;
    00491     DoubleOperand.LowPart = 0x0;
    00492     DoubleOperand.HighPart = 0xfffff;
    00493     try {
    00494         Fsr.Data = ConvertToSingleFromDouble(EI | ROUND_TO_ZERO,
    00495                                              &DoubleOperand,
    00496                                              &SingleResult);
    00497
    00498     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    00499               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00500         Count += 1;
    00501     }
    00502
    00503     if (Count == 0) {
    00504         goto TestFailed;
    00505     }
    00506
    00507     Subtest += 1;
    00508     DoubleOperand.LowPart = 0x0;
    00509     DoubleOperand.HighPart = ((DOUBLE_EXPONENT_BIAS +
    00510                             SINGLE_EXPONENT_BIAS + 1) << (52 - 32)) | 0xfffff;
    00511     Fsr.Data = ConvertToSingleFromDouble(ROUND_TO_ZERO,
    00512                                          &DoubleOperand,
    00513                                          &SingleResult);
    00514
    00515     if ((Fsr.Data != (SI | SO | XI | XO | ROUND_TO_ZERO)) ||
    00516         (SingleResult != SINGLE_MAXIMUM_VALUE)) {
    00517         goto TestFailed;
    00518     }
    00519
    00520     Subtest += 1;
    00521     DoubleOperand.LowPart = 0x0;
    00522     DoubleOperand.HighPart = SIGN | ((DOUBLE_EXPONENT_BIAS +
    00523                             SINGLE_EXPONENT_BIAS + 1) << (52 - 32)) | 0xfffff;
    00524     Fsr.Data = ConvertToSingleFromDouble(ROUND_TO_ZERO,
    00525                                          &DoubleOperand,
    00526                                          &SingleResult);
    00527
    00528     if ((Fsr.Data != (SI | SO | XI | XO | ROUND_TO_ZERO)) ||
    00529         (SingleResult != (SIGN | SINGLE_MAXIMUM_VALUE))) {
    00530         goto TestFailed;
    00531     }
    00532
    00533     Subtest += 1;
    00534     Count = 0;
    00535     DoubleOperand.LowPart = 0x0;
    00536     DoubleOperand.HighPart = ((DOUBLE_EXPONENT_BIAS +
    00537                             SINGLE_EXPONENT_BIAS + 1) << (52 - 32)) | 0xfffff;
    00538     try {
    00539         Fsr.Data = ConvertToSingleFromDouble(EO | ROUND_TO_ZERO,
    00540                                              &DoubleOperand,
    00541                                              &SingleResult);
    00542
    00543     } except ((GetExceptionCode() == STATUS_FLOAT_OVERFLOW) ?
    00544               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00545         Count += 1;
    00546     }
    00547
    00548     if (Count == 0) {
    00549         goto TestFailed;
    00550     }
    00551
    00552     Subtest += 1;
    00553     Count = 0;
    00554     DoubleOperand.LowPart = 0x0;
    00555     DoubleOperand.HighPart = ((DOUBLE_EXPONENT_BIAS +
    00556                             SINGLE_EXPONENT_BIAS + 1) << (52 - 32)) | 0xfffff;
    00557     try {
    00558         Fsr.Data = ConvertToSingleFromDouble(EI | ROUND_TO_ZERO,
    00559                                              &DoubleOperand,
    00560                                              &SingleResult);
    00561
    00562     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    00563               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00564         Count += 1;
    00565     }
    00566
    00567     if (Count == 0) {
    00568         goto TestFailed;
    00569     }
    00570
    00571     //
    00572     // End of test 21.
    00573     //
    00574
    00575     printf("succeeded\n");
    00576     return;
    00577
    00578     //
    00579     // Test 21 failed.
    00580     //
    00581
    00582 TestFailed:
    00583     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    00584            Subtest,
    00585            Fsr.Data,
    00586            SingleResult);
    00587
    00588     return;
    00589 }

VOID Test22 | ( | VOID |  | ) |

Definition at line 592 of file flpt2.c.

References ConvertToDoubleFromSingle(), Count, _FLOATING_STATUS::Data, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, MINUS_DOUBLE_INFINITY_VALUE, MINUS_SINGLE_INFINITY_VALUE, SIGN, SV, and XV.

Referenced by main().

    00596 {
    00597
    00598     ULONG Count;
    00599     FLOATING_STATUS Fsr;
    00600     ULARGE_INTEGER DoubleResult;
    00601     ULONG SingleOperand;
    00602     ULONG Subtest;
    00603
    00604     //
    00605     // Test 22 - Convert to double.
    00606     //
    00607
    00608     Subtest = 0;
    00609     printf("    Test 22 - convert to double ...");
    00610     Subtest += 1;
    00611     SingleOperand = SINGLE_QUIET_NAN;
    00612     Fsr.Data = ConvertToDoubleFromSingle(ROUND_TO_NEAREST,
    00613                                          SingleOperand,
    00614                                          &DoubleResult);
    00615
    00616     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00617         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    00618         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    00619         goto TestFailed;
    00620     }
    00621
    00622     Subtest += 1;
    00623     SingleOperand = SINGLE_SIGNAL_NAN;
    00624     Fsr.Data = ConvertToDoubleFromSingle(ROUND_TO_NEAREST,
    00625                                          SingleOperand,
    00626                                          &DoubleResult);
    00627
    00628     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    00629         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    00630         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    00631         goto TestFailed;
    00632     }
    00633
    00634     Subtest += 1;
    00635     SingleOperand = SINGLE_INFINITY_VALUE;
    00636     Fsr.Data = ConvertToDoubleFromSingle(ROUND_TO_NEAREST,
    00637                                          SingleOperand,
    00638                                          &DoubleResult);
    00639
    00640     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00641         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    00642         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    00643         goto TestFailed;
    00644     }
    00645
    00646     Subtest += 1;
    00647     SingleOperand = MINUS_SINGLE_INFINITY_VALUE;
    00648     Fsr.Data = ConvertToDoubleFromSingle(ROUND_TO_NEAREST,
    00649                                          SingleOperand,
    00650                                          &DoubleResult);
    00651
    00652     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00653         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    00654         (DoubleResult.HighPart != MINUS_DOUBLE_INFINITY_VALUE)) {
    00655         goto TestFailed;
    00656     }
    00657
    00658     Subtest += 1;
    00659     Count = 0;
    00660     SingleOperand = SINGLE_SIGNAL_NAN;
    00661     try {
    00662         Fsr.Data = ConvertToDoubleFromSingle(EV | ROUND_TO_NEAREST,
    00663                                              SingleOperand,
    00664                                              &DoubleResult);
    00665
    00666     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    00667               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00668         Count += 1;
    00669     }
    00670
    00671     if (Count == 0) {
    00672         goto TestFailed;
    00673     }
    00674
    00675     Subtest += 1;
    00676     SingleOperand = 0x400000;
    00677     Fsr.Data = ConvertToDoubleFromSingle(ROUND_TO_ZERO,
    00678                                          SingleOperand,
    00679                                          &DoubleResult);
    00680
    00681     if ((Fsr.Data != ROUND_TO_ZERO) ||
    00682         (DoubleResult.LowPart != 0x0) ||
    00683         (DoubleResult.HighPart != 0x38000000)) {
    00684         goto TestFailed;
    00685     }
    00686
    00687     Subtest += 1;
    00688     SingleOperand = SIGN | 0x400000;
    00689     Fsr.Data = ConvertToDoubleFromSingle(ROUND_TO_ZERO,
    00690                                          SingleOperand,
    00691                                          &DoubleResult);
    00692
    00693     if ((Fsr.Data != ROUND_TO_ZERO) ||
    00694         (DoubleResult.LowPart != 0x0) ||
    00695         (DoubleResult.HighPart != (SIGN | 0x38000000))) {
    00696         goto TestFailed;
    00697     }
    00698
    00699     Subtest += 1;
    00700     SingleOperand = 0x440000;
    00701     Fsr.Data = ConvertToDoubleFromSingle(ROUND_TO_ZERO,
    00702                                          SingleOperand,
    00703                                          &DoubleResult);
    00704
    00705     if ((Fsr.Data != ROUND_TO_ZERO) ||
    00706         (DoubleResult.LowPart != 0x0) ||
    00707         (DoubleResult.HighPart != 0x38010000)) {
    00708         goto TestFailed;
    00709     }
    00710
    00711     Subtest += 1;
    00712     SingleOperand = SIGN | 0x440000;
    00713     Fsr.Data = ConvertToDoubleFromSingle(ROUND_TO_ZERO,
    00714                                          SingleOperand,
    00715                                          &DoubleResult);
    00716
    00717     if ((Fsr.Data != ROUND_TO_ZERO) ||
    00718         (DoubleResult.LowPart != 0x0) ||
    00719         (DoubleResult.HighPart != (SIGN | 0x38010000))) {
    00720         goto TestFailed;
    00721     }
    00722
    00723     //
    00724     // End of test 22.
    00725     //
    00726
    00727     printf("succeeded\n");
    00728     return;
    00729
    00730     //
    00731     // Test 22 failed.
    00732     //
    00733
    00734 TestFailed:
    00735     printf(" subtest %d failed, fsr = %lx, result = %lx, %lx\n",
    00736            Subtest,
    00737            Fsr.Data,
    00738            DoubleResult.LowPart,
    00739            DoubleResult.HighPart);
    00740
    00741     return;
    00742 }

VOID Test23 | ( | VOID |  | ) |

Definition at line 745 of file flpt2.c.

References ConvertToLongwordFromSingle(), Count, _FLOATING_STATUS::Data, EI, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, MINUS_SINGLE_INFINITY_VALUE, RoundToLongwordFromSingle(), SI, SIGN, and SV.

Referenced by main().

    00749 {
    00750
    00751     ULONG Count;
    00752     FLOATING_STATUS Fsr;
    00753     ULONG LongwordResult;
    00754     ULONG SingleOperand;
    00755     ULONG Subtest;
    00756
    00757     //
    00758     // Test 23 - Convert to longword from single.
    00759     //
    00760
    00761     Subtest = 0;
    00762     printf("    Test 23 - convert to longword from single ...");
    00763     Subtest += 1;
    00764     SingleOperand = SINGLE_QUIET_NAN;
    00765     Fsr.Data = ConvertToLongwordFromSingle(ROUND_TO_NEAREST,
    00766                                            SingleOperand,
    00767                                            &LongwordResult);
    00768
    00769     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    00770         (LongwordResult != INTEGER_NAN)) {
    00771         goto TestFailed;
    00772     }
    00773
    00774     Subtest += 1;
    00775     SingleOperand = SINGLE_SIGNAL_NAN;
    00776     Fsr.Data = ConvertToLongwordFromSingle(ROUND_TO_NEAREST,
    00777                                            SingleOperand,
    00778                                            &LongwordResult);
    00779
    00780     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    00781         (LongwordResult != INTEGER_NAN)) {
    00782         goto TestFailed;
    00783     }
    00784
    00785     Subtest += 1;
    00786     SingleOperand = SINGLE_INFINITY_VALUE;
    00787     Fsr.Data = ConvertToLongwordFromSingle(ROUND_TO_NEAREST,
    00788                                            SingleOperand,
    00789                                            &LongwordResult);
    00790
    00791     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    00792         (LongwordResult != 0x7fffffff)) {
    00793         goto TestFailed;
    00794     }
    00795
    00796     Subtest += 1;
    00797     SingleOperand = MINUS_SINGLE_INFINITY_VALUE;
    00798     Fsr.Data = ConvertToLongwordFromSingle(ROUND_TO_NEAREST,
    00799                                            SingleOperand,
    00800                                            &LongwordResult);
    00801
    00802     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    00803         (LongwordResult != 0x80000000)) {
    00804         goto TestFailed;
    00805     }
    00806
    00807     Subtest += 1;
    00808     Count = 0;
    00809     SingleOperand = SINGLE_QUIET_NAN;
    00810     try {
    00811         Fsr.Data = ConvertToLongwordFromSingle(EV | ROUND_TO_NEAREST,
    00812                                                SingleOperand,
    00813                                                &LongwordResult);
    00814
    00815     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    00816               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00817         Count += 1;
    00818     }
    00819
    00820     if (Count == 0) {
    00821         goto TestFailed;
    00822     }
    00823
    00824     Subtest += 1;
    00825     Count = 0;
    00826     SingleOperand = SINGLE_SIGNAL_NAN;
    00827     try {
    00828         Fsr.Data = ConvertToLongwordFromSingle(EV | ROUND_TO_NEAREST,
    00829                                                SingleOperand,
    00830                                                &LongwordResult);
    00831
    00832     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    00833               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00834         Count += 1;
    00835     }
    00836
    00837     if (Count == 0) {
    00838         goto TestFailed;
    00839     }
    00840
    00841     Subtest += 1;
    00842     Count = 0;
    00843     SingleOperand = SINGLE_INFINITY_VALUE;
    00844     try {
    00845         Fsr.Data = ConvertToLongwordFromSingle(EV | ROUND_TO_NEAREST,
    00846                                                SingleOperand,
    00847                                                &LongwordResult);
    00848
    00849     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    00850               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00851         Count += 1;
    00852     }
    00853
    00854     if (Count == 0) {
    00855         goto TestFailed;
    00856     }
    00857
    00858     Subtest += 1;
    00859     Count = 0;
    00860     SingleOperand = MINUS_SINGLE_INFINITY_VALUE;
    00861     try {
    00862         Fsr.Data = ConvertToLongwordFromSingle(EV | ROUND_TO_NEAREST,
    00863                                                SingleOperand,
    00864                                                &LongwordResult);
    00865
    00866     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    00867               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00868         Count += 1;
    00869     }
    00870
    00871     if (Count == 0) {
    00872         goto TestFailed;
    00873     }
    00874
    00875     Subtest += 1;
    00876     SingleOperand = 0x400000;
    00877     Fsr.Data = ConvertToLongwordFromSingle(ROUND_TO_NEAREST,
    00878                                            SingleOperand,
    00879                                            &LongwordResult);
    00880
    00881     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    00882         (LongwordResult != 0x0)) {
    00883         goto TestFailed;
    00884     }
    00885
    00886     Subtest += 1;
    00887     SingleOperand = 0x1;
    00888     Fsr.Data = ConvertToLongwordFromSingle(ROUND_TO_NEAREST,
    00889                                            SingleOperand,
    00890                                            &LongwordResult);
    00891
    00892     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    00893         (LongwordResult != 0x0)) {
    00894         goto TestFailed;
    00895     }
    00896
    00897     Subtest += 1;
    00898     Count = 0;
    00899     SingleOperand = 0x400000;
    00900     try {
    00901         Fsr.Data = ConvertToLongwordFromSingle(EI | ROUND_TO_NEAREST,
    00902                                                SingleOperand,
    00903                                                &LongwordResult);
    00904
    00905     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    00906               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00907         Count += 1;
    00908     }
    00909
    00910     if (Count == 0) {
    00911         goto TestFailed;
    00912     }
    00913
    00914     Subtest += 1;
    00915     SingleOperand = ((SINGLE_EXPONENT_BIAS + 32) << 23);
    00916     Fsr.Data = ConvertToLongwordFromSingle(ROUND_TO_NEAREST,
    00917                                            SingleOperand,
    00918                                            &LongwordResult);
    00919
    00920     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    00921         (LongwordResult != INTEGER_NAN)) {
    00922         goto TestFailed;
    00923     }
    00924
    00925     Subtest += 1;
    00926     SingleOperand = ((SINGLE_EXPONENT_BIAS + 31) << 23);
    00927     Fsr.Data = ConvertToLongwordFromSingle(ROUND_TO_NEAREST,
    00928                                            SingleOperand,
    00929                                            &LongwordResult);
    00930
    00931     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    00932         (LongwordResult != INTEGER_NAN)) {
    00933         goto TestFailed;
    00934     }
    00935
    00936     Subtest += 1;
    00937     SingleOperand = SIGN | ((SINGLE_EXPONENT_BIAS + 31) << 23);
    00938     Fsr.Data = ConvertToLongwordFromSingle(ROUND_TO_NEAREST,
    00939                                            SingleOperand,
    00940                                            &LongwordResult);
    00941
    00942     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    00943         (LongwordResult != 0x80000000)) {
    00944         goto TestFailed;
    00945     }
    00946
    00947     Subtest += 1;
    00948     SingleOperand = SIGN | ((SINGLE_EXPONENT_BIAS + 31) << 23) | 0x1;
    00949     Fsr.Data = ConvertToLongwordFromSingle(ROUND_TO_NEAREST,
    00950                                            SingleOperand,
    00951                                            &LongwordResult);
    00952
    00953     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    00954         (LongwordResult != INTEGER_NAN)) {
    00955         goto TestFailed;
    00956     }
    00957
    00958     Subtest += 1;
    00959     Count = 0;
    00960     SingleOperand = ((SINGLE_EXPONENT_BIAS + 31) << 23);
    00961     try {
    00962         Fsr.Data = ConvertToLongwordFromSingle(EV | ROUND_TO_NEAREST,
    00963                                                SingleOperand,
    00964                                                &LongwordResult);
    00965
    00966     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    00967               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    00968         Count += 1;
    00969     }
    00970
    00971     if (Count == 0) {
    00972         goto TestFailed;
    00973     }
    00974
    00975     Subtest += 1;
    00976     SingleOperand = SINGLE_QUIET_NAN;
    00977     Fsr.Data = RoundToLongwordFromSingle(ROUND_TO_NEAREST,
    00978                                          SingleOperand,
    00979                                          &LongwordResult);
    00980
    00981     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    00982         (LongwordResult != INTEGER_NAN)) {
    00983         goto TestFailed;
    00984     }
    00985
    00986     Subtest += 1;
    00987     SingleOperand = SINGLE_SIGNAL_NAN;
    00988     Fsr.Data = RoundToLongwordFromSingle(ROUND_TO_NEAREST,
    00989                                          SingleOperand,
    00990                                          &LongwordResult);
    00991
    00992     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    00993         (LongwordResult != INTEGER_NAN)) {
    00994         goto TestFailed;
    00995     }
    00996
    00997     Subtest += 1;
    00998     SingleOperand = SINGLE_INFINITY_VALUE;
    00999     Fsr.Data = RoundToLongwordFromSingle(ROUND_TO_NEAREST,
    01000                                          SingleOperand,
    01001                                          &LongwordResult);
    01002
    01003     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01004         (LongwordResult != 0x7fffffff)) {
    01005         goto TestFailed;
    01006     }
    01007
    01008     Subtest += 1;
    01009     SingleOperand = MINUS_SINGLE_INFINITY_VALUE;
    01010     Fsr.Data = RoundToLongwordFromSingle(ROUND_TO_NEAREST,
    01011                                          SingleOperand,
    01012                                          &LongwordResult);
    01013
    01014     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01015         (LongwordResult != 0x80000000)) {
    01016         goto TestFailed;
    01017     }
    01018
    01019     Subtest += 1;
    01020     Count = 0;
    01021     SingleOperand = SINGLE_QUIET_NAN;
    01022     try {
    01023         Fsr.Data = RoundToLongwordFromSingle(EV | ROUND_TO_NEAREST,
    01024                                              SingleOperand,
    01025                                              &LongwordResult);
    01026
    01027     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01028               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01029         Count += 1;
    01030     }
    01031
    01032     if (Count == 0) {
    01033         goto TestFailed;
    01034     }
    01035
    01036     Subtest += 1;
    01037     Count = 0;
    01038     SingleOperand = SINGLE_SIGNAL_NAN;
    01039     try {
    01040         Fsr.Data = RoundToLongwordFromSingle(EV | ROUND_TO_NEAREST,
    01041                                              SingleOperand,
    01042                                              &LongwordResult);
    01043
    01044     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01045               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01046         Count += 1;
    01047     }
    01048
    01049     if (Count == 0) {
    01050         goto TestFailed;
    01051     }
    01052
    01053     Subtest += 1;
    01054     Count = 0;
    01055     SingleOperand = SINGLE_INFINITY_VALUE;
    01056     try {
    01057         Fsr.Data = RoundToLongwordFromSingle(EV | ROUND_TO_NEAREST,
    01058                                              SingleOperand,
    01059                                              &LongwordResult);
    01060
    01061     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01062               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01063         Count += 1;
    01064     }
    01065
    01066     if (Count == 0) {
    01067         goto TestFailed;
    01068     }
    01069
    01070     Subtest += 1;
    01071     Count = 0;
    01072     SingleOperand = MINUS_SINGLE_INFINITY_VALUE;
    01073     try {
    01074         Fsr.Data = RoundToLongwordFromSingle(EV | ROUND_TO_NEAREST,
    01075                                              SingleOperand,
    01076                                              &LongwordResult);
    01077
    01078     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01079               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01080         Count += 1;
    01081     }
    01082
    01083     if (Count == 0) {
    01084         goto TestFailed;
    01085     }
    01086
    01087     Subtest += 1;
    01088     SingleOperand = 0x400000;
    01089     Fsr.Data = RoundToLongwordFromSingle(ROUND_TO_NEAREST,
    01090                                          SingleOperand,
    01091                                          &LongwordResult);
    01092
    01093     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    01094         (LongwordResult != 0x0)) {
    01095         goto TestFailed;
    01096     }
    01097
    01098     Subtest += 1;
    01099     SingleOperand = 0x1;
    01100     Fsr.Data = RoundToLongwordFromSingle(ROUND_TO_NEAREST,
    01101                                          SingleOperand,
    01102                                          &LongwordResult);
    01103
    01104     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    01105         (LongwordResult != 0x0)) {
    01106         goto TestFailed;
    01107     }
    01108
    01109     Subtest += 1;
    01110     Count = 0;
    01111     SingleOperand = 0x400000;
    01112     try {
    01113         Fsr.Data = RoundToLongwordFromSingle(EI | ROUND_TO_NEAREST,
    01114                                              SingleOperand,
    01115                                              &LongwordResult);
    01116
    01117     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    01118               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01119         Count += 1;
    01120     }
    01121
    01122     if (Count == 0) {
    01123         goto TestFailed;
    01124     }
    01125
    01126     Subtest += 1;
    01127     SingleOperand = ((SINGLE_EXPONENT_BIAS + 32) << 23);
    01128     Fsr.Data = RoundToLongwordFromSingle(ROUND_TO_NEAREST,
    01129                                          SingleOperand,
    01130                                          &LongwordResult);
    01131
    01132     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01133         (LongwordResult != INTEGER_NAN)) {
    01134         goto TestFailed;
    01135     }
    01136
    01137     Subtest += 1;
    01138     SingleOperand = ((SINGLE_EXPONENT_BIAS + 31) << 23);
    01139     Fsr.Data = RoundToLongwordFromSingle(ROUND_TO_NEAREST,
    01140                                          SingleOperand,
    01141                                          &LongwordResult);
    01142
    01143     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01144         (LongwordResult != INTEGER_NAN)) {
    01145         goto TestFailed;
    01146     }
    01147
    01148     Subtest += 1;
    01149     SingleOperand = SIGN | ((SINGLE_EXPONENT_BIAS + 31) << 23);
    01150     Fsr.Data = RoundToLongwordFromSingle(ROUND_TO_NEAREST,
    01151                                          SingleOperand,
    01152                                          &LongwordResult);
    01153
    01154     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01155         (LongwordResult != 0x80000000)) {
    01156         goto TestFailed;
    01157     }
    01158
    01159     Subtest += 1;
    01160     SingleOperand = SIGN | ((SINGLE_EXPONENT_BIAS + 31) << 23) | 0x1;
    01161     Fsr.Data = RoundToLongwordFromSingle(ROUND_TO_NEAREST,
    01162                                          SingleOperand,
    01163                                          &LongwordResult);
    01164
    01165     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01166         (LongwordResult != INTEGER_NAN)) {
    01167         goto TestFailed;
    01168     }
    01169
    01170     Subtest += 1;
    01171     Count = 0;
    01172     SingleOperand = ((SINGLE_EXPONENT_BIAS + 31) << 23);
    01173     try {
    01174         Fsr.Data = RoundToLongwordFromSingle(EV | ROUND_TO_NEAREST,
    01175                                              SingleOperand,
    01176                                              &LongwordResult);
    01177
    01178     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01179               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01180         Count += 1;
    01181     }
    01182
    01183     if (Count == 0) {
    01184         goto TestFailed;
    01185     }
    01186
    01187     //
    01188     // End of test 23.
    01189     //
    01190
    01191     printf("succeeded\n");
    01192     return;
    01193
    01194     //
    01195     // Test 23 failed.
    01196     //
    01197
    01198 TestFailed:
    01199     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    01200            Subtest,
    01201            Fsr.Data,
    01202            LongwordResult);
    01203
    01204     return;
    01205 }

VOID Test24 | ( | VOID |  | ) |

Definition at line 1208 of file flpt2.c.

References ConvertToLongwordFromDouble(), Count, _FLOATING_STATUS::Data, EI, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, MINUS_DOUBLE_INFINITY_VALUE, RoundToLongwordFromDouble(), SI, SIGN, SV, and TruncateToLongwordFromDouble().

Referenced by main().

    01212 {
    01213
    01214     ULONG Count;
    01215     FLOATING_STATUS Fsr;
    01216     ULARGE_INTEGER DoubleOperand;
    01217     ULONG LongwordResult;
    01218     ULONG Subtest;
    01219
    01220     //
    01221     // Test 24 - Convert to longword from double.
    01222     //
    01223
    01224     Subtest = 0;
    01225     printf("    Test 24 - convert to longword from double ...");
    01226     Subtest += 1;
    01227     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    01228     DoubleOperand.HighPart = DOUBLE_QUIET_NAN;
    01229     Fsr.Data = ConvertToLongwordFromDouble(ROUND_TO_NEAREST,
    01230                                            &DoubleOperand,
    01231                                            &LongwordResult);
    01232
    01233     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01234         (LongwordResult != INTEGER_NAN)) {
    01235         goto TestFailed;
    01236     }
    01237
    01238     Subtest += 1;
    01239     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    01240     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    01241     Fsr.Data = ConvertToLongwordFromDouble(ROUND_TO_NEAREST,
    01242                                            &DoubleOperand,
    01243                                            &LongwordResult);
    01244
    01245     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01246         (LongwordResult != INTEGER_NAN)) {
    01247         goto TestFailed;
    01248     }
    01249
    01250     Subtest += 1;
    01251     DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    01252     DoubleOperand.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    01253     Fsr.Data = ConvertToLongwordFromDouble(ROUND_TO_NEAREST,
    01254                                            &DoubleOperand,
    01255                                            &LongwordResult);
    01256
    01257     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01258         (LongwordResult != 0x7fffffff)) {
    01259         goto TestFailed;
    01260     }
    01261
    01262     Subtest += 1;
    01263     DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    01264     DoubleOperand.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    01265     Fsr.Data = ConvertToLongwordFromDouble(ROUND_TO_NEAREST,
    01266                                            &DoubleOperand,
    01267                                            &LongwordResult);
    01268
    01269     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01270         (LongwordResult != 0x80000000)) {
    01271         goto TestFailed;
    01272     }
    01273
    01274     Subtest += 1;
    01275     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    01276     DoubleOperand.HighPart = DOUBLE_QUIET_NAN;
    01277     Fsr.Data = RoundToLongwordFromDouble(ROUND_TO_NEAREST,
    01278                                          &DoubleOperand,
    01279                                          &LongwordResult);
    01280
    01281     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01282         (LongwordResult != INTEGER_NAN)) {
    01283         goto TestFailed;
    01284     }
    01285
    01286     Subtest += 1;
    01287     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    01288     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    01289     Fsr.Data = RoundToLongwordFromDouble(ROUND_TO_NEAREST,
    01290                                          &DoubleOperand,
    01291                                          &LongwordResult);
    01292
    01293     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01294         (LongwordResult != INTEGER_NAN)) {
    01295         goto TestFailed;
    01296     }
    01297
    01298     Subtest += 1;
    01299     DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    01300     DoubleOperand.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    01301     Fsr.Data = RoundToLongwordFromDouble(ROUND_TO_NEAREST,
    01302                                          &DoubleOperand,
    01303                                          &LongwordResult);
    01304
    01305     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01306         (LongwordResult != 0x7fffffff)) {
    01307         goto TestFailed;
    01308     }
    01309
    01310     Subtest += 1;
    01311     DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    01312     DoubleOperand.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    01313     Fsr.Data = RoundToLongwordFromDouble(ROUND_TO_NEAREST,
    01314                                          &DoubleOperand,
    01315                                          &LongwordResult);
    01316
    01317     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01318         (LongwordResult != 0x80000000)) {
    01319         goto TestFailed;
    01320     }
    01321
    01322     Subtest += 1;
    01323     Count = 0;
    01324     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    01325     DoubleOperand.HighPart = DOUBLE_QUIET_NAN;
    01326     try {
    01327         Fsr.Data = ConvertToLongwordFromDouble(EV | ROUND_TO_ZERO,
    01328                                                &DoubleOperand,
    01329                                                &LongwordResult);
    01330
    01331     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01332               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01333         Count += 1;
    01334     }
    01335
    01336     if (Count == 0) {
    01337         goto TestFailed;
    01338     }
    01339
    01340     Subtest += 1;
    01341     Count = 0;
    01342     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    01343     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    01344     try {
    01345         Fsr.Data = ConvertToLongwordFromDouble(EV | ROUND_TO_ZERO,
    01346                                                &DoubleOperand,
    01347                                                &LongwordResult);
    01348
    01349     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01350               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01351         Count += 1;
    01352     }
    01353
    01354     if (Count == 0) {
    01355         goto TestFailed;
    01356     }
    01357
    01358     Subtest += 1;
    01359     Count = 0;
    01360     DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    01361     DoubleOperand.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    01362     try {
    01363         Fsr.Data = ConvertToLongwordFromDouble(EV | ROUND_TO_ZERO,
    01364                                                &DoubleOperand,
    01365                                                &LongwordResult);
    01366
    01367     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01368               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01369         Count += 1;
    01370     }
    01371
    01372     if (Count == 0) {
    01373         goto TestFailed;
    01374     }
    01375
    01376     Subtest += 1;
    01377     Count = 0;
    01378     DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    01379     DoubleOperand.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    01380     try {
    01381         Fsr.Data = ConvertToLongwordFromDouble(EV | ROUND_TO_ZERO,
    01382                                                &DoubleOperand,
    01383                                                &LongwordResult);
    01384
    01385     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01386               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01387         Count += 1;
    01388     }
    01389
    01390     if (Count == 0) {
    01391         goto TestFailed;
    01392     }
    01393
    01394     Subtest += 1;
    01395     Count = 0;
    01396     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    01397     DoubleOperand.HighPart = DOUBLE_QUIET_NAN;
    01398     try {
    01399         Fsr.Data = TruncateToLongwordFromDouble(EV | ROUND_TO_ZERO,
    01400                                                 &DoubleOperand,
    01401                                                 &LongwordResult);
    01402
    01403     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01404               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01405         Count += 1;
    01406     }
    01407
    01408     if (Count == 0) {
    01409         goto TestFailed;
    01410     }
    01411
    01412     Subtest += 1;
    01413     Count = 0;
    01414     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    01415     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    01416     try {
    01417         Fsr.Data = TruncateToLongwordFromDouble(EV | ROUND_TO_ZERO,
    01418                                                 &DoubleOperand,
    01419                                                 &LongwordResult);
    01420
    01421     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01422               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01423         Count += 1;
    01424     }
    01425
    01426     if (Count == 0) {
    01427         goto TestFailed;
    01428     }
    01429
    01430     Subtest += 1;
    01431     Count = 0;
    01432     DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    01433     DoubleOperand.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    01434     try {
    01435         Fsr.Data = TruncateToLongwordFromDouble(EV | ROUND_TO_ZERO,
    01436                                                 &DoubleOperand,
    01437                                                 &LongwordResult);
    01438
    01439     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01440               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01441         Count += 1;
    01442     }
    01443
    01444     if (Count == 0) {
    01445         goto TestFailed;
    01446     }
    01447
    01448     Subtest += 1;
    01449     Count = 0;
    01450     DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    01451     DoubleOperand.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    01452     try {
    01453         Fsr.Data = TruncateToLongwordFromDouble(EV | ROUND_TO_ZERO,
    01454                                                 &DoubleOperand,
    01455                                                 &LongwordResult);
    01456
    01457     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01458               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01459         Count += 1;
    01460     }
    01461
    01462     if (Count == 0) {
    01463         goto TestFailed;
    01464     }
    01465
    01466     Subtest += 1;
    01467     DoubleOperand.LowPart = 0x0;
    01468     DoubleOperand.HighPart = 0x80000;
    01469     Fsr.Data = ConvertToLongwordFromDouble(ROUND_TO_NEAREST,
    01470                                            &DoubleOperand,
    01471                                            &LongwordResult);
    01472
    01473     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    01474         (LongwordResult != 0x0)) {
    01475         goto TestFailed;
    01476     }
    01477
    01478     Subtest += 1;
    01479     DoubleOperand.LowPart = 0x1;
    01480     DoubleOperand.HighPart = 0x0;
    01481     Fsr.Data = ConvertToLongwordFromDouble(ROUND_TO_NEAREST,
    01482                                            &DoubleOperand,
    01483                                            &LongwordResult);
    01484
    01485     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    01486         (LongwordResult != 0x0)) {
    01487         goto TestFailed;
    01488     }
    01489
    01490     Subtest += 1;
    01491     DoubleOperand.LowPart = 0x0;
    01492     DoubleOperand.HighPart = 0x80000;
    01493     Fsr.Data = RoundToLongwordFromDouble(ROUND_TO_NEAREST,
    01494                                          &DoubleOperand,
    01495                                          &LongwordResult);
    01496
    01497     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    01498         (LongwordResult != 0x0)) {
    01499         goto TestFailed;
    01500     }
    01501
    01502     Subtest += 1;
    01503     DoubleOperand.LowPart = 0x1;
    01504     DoubleOperand.HighPart = 0x0;
    01505     Fsr.Data = RoundToLongwordFromDouble(ROUND_TO_NEAREST,
    01506                                          &DoubleOperand,
    01507                                          &LongwordResult);
    01508
    01509     if ((Fsr.Data != (SI | ROUND_TO_NEAREST)) ||
    01510         (LongwordResult != 0x0)) {
    01511         goto TestFailed;
    01512     }
    01513
    01514     Subtest += 1;
    01515     Count = 0;
    01516     DoubleOperand.LowPart = 0x0;
    01517     DoubleOperand.HighPart = 0x80000;
    01518     try {
    01519         Fsr.Data = ConvertToLongwordFromDouble(EI | ROUND_TO_ZERO,
    01520                                                &DoubleOperand,
    01521                                                &LongwordResult);
    01522
    01523     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    01524               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01525         Count += 1;
    01526     }
    01527
    01528     if (Count == 0) {
    01529         goto TestFailed;
    01530     }
    01531
    01532     Subtest += 1;
    01533     Count = 0;
    01534     DoubleOperand.LowPart = 0x0;
    01535     DoubleOperand.HighPart = 0x80000;
    01536     try {
    01537         Fsr.Data = TruncateToLongwordFromDouble(EI | ROUND_TO_ZERO,
    01538                                                 &DoubleOperand,
    01539                                                 &LongwordResult);
    01540
    01541     } except ((GetExceptionCode() == STATUS_FLOAT_INEXACT_RESULT) ?
    01542               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01543         Count += 1;
    01544     }
    01545
    01546     if (Count == 0) {
    01547         goto TestFailed;
    01548     }
    01549
    01550     Subtest += 1;
    01551     DoubleOperand.LowPart = 0x0;
    01552     DoubleOperand.HighPart = ((DOUBLE_EXPONENT_BIAS + 32) << 20);
    01553     Fsr.Data = ConvertToLongwordFromDouble(ROUND_TO_NEAREST,
    01554                                            &DoubleOperand,
    01555                                            &LongwordResult);
    01556
    01557     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01558         (LongwordResult != INTEGER_NAN)) {
    01559         goto TestFailed;
    01560     }
    01561
    01562     Subtest += 1;
    01563     DoubleOperand.LowPart = 0x0;
    01564     DoubleOperand.HighPart = ((DOUBLE_EXPONENT_BIAS + 31) << 20);
    01565     Fsr.Data = ConvertToLongwordFromDouble(ROUND_TO_NEAREST,
    01566                                            &DoubleOperand,
    01567                                            &LongwordResult);
    01568
    01569     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01570         (LongwordResult != INTEGER_NAN)) {
    01571         goto TestFailed;
    01572     }
    01573
    01574     Subtest += 1;
    01575     DoubleOperand.LowPart = 0x0;
    01576     DoubleOperand.HighPart = SIGN | ((DOUBLE_EXPONENT_BIAS + 31) << 20);
    01577     Fsr.Data = ConvertToLongwordFromDouble(ROUND_TO_NEAREST,
    01578                                            &DoubleOperand,
    01579                                            &LongwordResult);
    01580
    01581     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01582         (LongwordResult != 0x80000000)) {
    01583         goto TestFailed;
    01584     }
    01585
    01586     Subtest += 1;
    01587     DoubleOperand.LowPart = 0x0;
    01588     DoubleOperand.HighPart = SIGN | ((DOUBLE_EXPONENT_BIAS + 31) << 20) | 0x1;
    01589     Fsr.Data = ConvertToLongwordFromDouble(ROUND_TO_NEAREST,
    01590                                            &DoubleOperand,
    01591                                            &LongwordResult);
    01592
    01593     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01594         (LongwordResult != INTEGER_NAN)) {
    01595         goto TestFailed;
    01596     }
    01597
    01598     Subtest += 1;
    01599     DoubleOperand.LowPart = 0x0;
    01600     DoubleOperand.HighPart = ((DOUBLE_EXPONENT_BIAS + 32) << 20);
    01601     Fsr.Data = RoundToLongwordFromDouble(ROUND_TO_NEAREST,
    01602                                          &DoubleOperand,
    01603                                          &LongwordResult);
    01604
    01605     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01606         (LongwordResult != INTEGER_NAN)) {
    01607         goto TestFailed;
    01608     }
    01609
    01610     Subtest += 1;
    01611     DoubleOperand.LowPart = 0x0;
    01612     DoubleOperand.HighPart = ((DOUBLE_EXPONENT_BIAS + 31) << 20);
    01613     Fsr.Data = RoundToLongwordFromDouble(ROUND_TO_NEAREST,
    01614                                          &DoubleOperand,
    01615                                          &LongwordResult);
    01616
    01617     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01618         (LongwordResult != INTEGER_NAN)) {
    01619         goto TestFailed;
    01620     }
    01621
    01622     Subtest += 1;
    01623     DoubleOperand.LowPart = 0x0;
    01624     DoubleOperand.HighPart = SIGN | ((DOUBLE_EXPONENT_BIAS + 31) << 20);
    01625     Fsr.Data = RoundToLongwordFromDouble(ROUND_TO_NEAREST,
    01626                                          &DoubleOperand,
    01627                                          &LongwordResult);
    01628
    01629     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01630         (LongwordResult != 0x80000000)) {
    01631         goto TestFailed;
    01632     }
    01633
    01634     Subtest += 1;
    01635     DoubleOperand.LowPart = 0x0;
    01636     DoubleOperand.HighPart = SIGN | ((DOUBLE_EXPONENT_BIAS + 31) << 20) | 0x1;
    01637     Fsr.Data = RoundToLongwordFromDouble(ROUND_TO_NEAREST,
    01638                                          &DoubleOperand,
    01639                                          &LongwordResult);
    01640
    01641     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01642         (LongwordResult != INTEGER_NAN)) {
    01643         goto TestFailed;
    01644     }
    01645
    01646     Subtest += 1;
    01647     Count = 0;
    01648     DoubleOperand.LowPart = 0x0;
    01649     DoubleOperand.HighPart = SIGN | ((DOUBLE_EXPONENT_BIAS + 31) << 20) | 0x1;
    01650     try {
    01651         Fsr.Data = ConvertToLongwordFromDouble(EV | ROUND_TO_ZERO,
    01652                                                &DoubleOperand,
    01653                                                &LongwordResult);
    01654
    01655     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01656               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01657         Count += 1;
    01658     }
    01659
    01660     if (Count == 0) {
    01661         goto TestFailed;
    01662     }
    01663
    01664     Subtest += 1;
    01665     Count = 0;
    01666     DoubleOperand.LowPart = 0x0;
    01667     DoubleOperand.HighPart = SIGN | ((DOUBLE_EXPONENT_BIAS + 31) << 20) | 0x1;
    01668     try {
    01669         Fsr.Data = TruncateToLongwordFromDouble(EV | ROUND_TO_ZERO,
    01670                                                 &DoubleOperand,
    01671                                                 &LongwordResult);
    01672
    01673     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01674               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01675         Count += 1;
    01676     }
    01677
    01678     if (Count == 0) {
    01679         goto TestFailed;
    01680     }
    01681
    01682     Subtest += 1;
    01683     DoubleOperand.LowPart = 0xfff00000;
    01684     DoubleOperand.HighPart = ((DOUBLE_EXPONENT_BIAS + 30) << 20) | 0xfffff;
    01685     Fsr.Data = ConvertToLongwordFromDouble(ROUND_TO_NEAREST,
    01686                                            &DoubleOperand,
    01687                                            &LongwordResult);
    01688
    01689     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01690         (LongwordResult != INTEGER_NAN)) {
    01691         goto TestFailed;
    01692     }
    01693
    01694     Subtest += 1;
    01695     Count = 0;
    01696     DoubleOperand.LowPart = 0xfff00000;
    01697     DoubleOperand.HighPart = ((DOUBLE_EXPONENT_BIAS + 30) << 20) | 0xfffff;
    01698     try {
    01699         Fsr.Data = ConvertToLongwordFromDouble(EV | ROUND_TO_NEAREST,
    01700                                                &DoubleOperand,
    01701                                                &LongwordResult);
    01702
    01703     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01704               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01705         Count += 1;
    01706     }
    01707
    01708     if (Count == 0) {
    01709         goto TestFailed;
    01710     }
    01711
    01712     Subtest += 1;
    01713     DoubleOperand.LowPart = 0xfff00000;
    01714     DoubleOperand.HighPart = ((DOUBLE_EXPONENT_BIAS + 30) << 20) | 0xfffff;
    01715     Fsr.Data = RoundToLongwordFromDouble(ROUND_TO_NEAREST,
    01716                                          &DoubleOperand,
    01717                                          &LongwordResult);
    01718
    01719     if ((Fsr.Data != (SV | ROUND_TO_NEAREST)) ||
    01720         (LongwordResult != INTEGER_NAN)) {
    01721         goto TestFailed;
    01722     }
    01723
    01724     Subtest += 1;
    01725     Count = 0;
    01726     DoubleOperand.LowPart = 0xfff00000;
    01727     DoubleOperand.HighPart = ((DOUBLE_EXPONENT_BIAS + 30) << 20) | 0xfffff;
    01728     try {
    01729         Fsr.Data = RoundToLongwordFromDouble(EV | ROUND_TO_NEAREST,
    01730                                              &DoubleOperand,
    01731                                              &LongwordResult);
    01732
    01733     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01734               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01735         Count += 1;
    01736     }
    01737
    01738     if (Count == 0) {
    01739         goto TestFailed;
    01740     }
    01741
    01742     //
    01743     // End of test 24.
    01744     //
    01745
    01746     printf("succeeded\n");
    01747     return;
    01748
    01749     //
    01750     // Test 24 failed.
    01751     //
    01752
    01753 TestFailed:
    01754     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    01755            Subtest,
    01756            Fsr.Data,
    01757            LongwordResult);
    01758
    01759     return;
    01760 }

VOID Test25 | ( | VOID |  | ) |

Definition at line 1763 of file flpt2.c.

References Count, _FLOATING_STATUS::Data, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, MINUS_DOUBLE_INFINITY_VALUE, SI, SIGN, SU, SV, and XV.

Referenced by main().

    01767 {
    01768
    01769     ULONG Count;
    01770     FLOATING_STATUS Fsr;
    01771     ULARGE_INTEGER DoubleOperand;
    01772     ULARGE_INTEGER DoubleResult;
    01773     ULONG Subtest;
    01774
    01775     //
    01776     // Test 25 - Square root double test.
    01777     //
    01778
    01779     Subtest = 0;
    01780     printf("    Test 25 - square root double ...");
    01781     Subtest += 1;
    01782     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    01783     DoubleOperand.HighPart = DOUBLE_QUIET_NAN;
    01784     Fsr.Data = SquareRootDouble(ROUND_TO_NEAREST,
    01785                                 &DoubleOperand,
    01786                                 &DoubleResult);
    01787
    01788     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01789         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    01790         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    01791         goto TestFailed;
    01792     }
    01793
    01794     Subtest += 1;
    01795     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    01796     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    01797     Fsr.Data = SquareRootDouble(ROUND_TO_NEAREST,
    01798                                 &DoubleOperand,
    01799                                 &DoubleResult);
    01800
    01801     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01802         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    01803         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    01804         goto TestFailed;
    01805     }
    01806
    01807     Subtest += 1;
    01808     Count = 0;
    01809     DoubleOperand.LowPart = DOUBLE_NAN_LOW;
    01810     DoubleOperand.HighPart = DOUBLE_SIGNAL_NAN;
    01811     try {
    01812         Fsr.Data = SquareRootDouble(EV | ROUND_TO_NEAREST,
    01813                                     &DoubleOperand,
    01814                                     &DoubleResult);
    01815
    01816     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01817               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01818         Count += 1;
    01819     }
    01820
    01821     if (Count == 0) {
    01822         goto TestFailed;
    01823     }
    01824
    01825     Subtest += 1;
    01826     DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    01827     DoubleOperand.HighPart = DOUBLE_INFINITY_VALUE_HIGH;
    01828     Fsr.Data = SquareRootDouble(ROUND_TO_NEAREST,
    01829                                 &DoubleOperand,
    01830                                 &DoubleResult);
    01831
    01832     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01833         (DoubleResult.LowPart != DOUBLE_INFINITY_VALUE_LOW) ||
    01834         (DoubleResult.HighPart != DOUBLE_INFINITY_VALUE_HIGH)) {
    01835         goto TestFailed;
    01836     }
    01837
    01838     Subtest += 1;
    01839     DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    01840     DoubleOperand.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    01841     Fsr.Data = SquareRootDouble(ROUND_TO_NEAREST,
    01842                                 &DoubleOperand,
    01843                                 &DoubleResult);
    01844
    01845     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    01846         (DoubleResult.LowPart != DOUBLE_NAN_LOW) ||
    01847         (DoubleResult.HighPart != DOUBLE_QUIET_NAN)) {
    01848         goto TestFailed;
    01849     }
    01850
    01851 //    Subtest += 1;
    01852 //    Count = 0;
    01853 //    DoubleOperand.LowPart = DOUBLE_INFINITY_VALUE_LOW;
    01854 //    DoubleOperand.HighPart = MINUS_DOUBLE_INFINITY_VALUE;
    01855 //    try {
    01856 //        Fsr.Data = SquareRootDouble(EV | ROUND_TO_NEAREST,
    01857 //                                    &DoubleOperand,
    01858 //                                    &DoubleResult);
    01859 //
    01860 //    } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    01861 //              EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    01862 //        Count += 1;
    01863 //    }
    01864 //
    01865 //    if (Count == 0) {
    01866 //        goto TestFailed;
    01867 //    }
    01868
    01869     Subtest += 1;
    01870     DoubleOperand.LowPart = 0;
    01871     DoubleOperand.HighPart = 0;
    01872     Fsr.Data = SquareRootDouble(ROUND_TO_NEAREST,
    01873                                 &DoubleOperand,
    01874                                 &DoubleResult);
    01875
    01876     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01877         (DoubleResult.LowPart != 0) ||
    01878         (DoubleResult.HighPart != 0)) {
    01879         goto TestFailed;
    01880     }
    01881
    01882     Subtest += 1;
    01883     DoubleOperand.LowPart = 0;
    01884     DoubleOperand.HighPart = 0 | SIGN;
    01885     Fsr.Data = SquareRootDouble(ROUND_TO_NEAREST,
    01886                                 &DoubleOperand,
    01887                                 &DoubleResult);
    01888
    01889     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01890         (DoubleResult.LowPart != 0) ||
    01891         (DoubleResult.HighPart != (0 | SIGN))) {
    01892         goto TestFailed;
    01893     }
    01894
    01895 // ****** //
    01896
    01897     Subtest += 1;
    01898     DoubleOperand.LowPart = 0x0;
    01899     DoubleOperand.HighPart = 0x40000;
    01900     Fsr.Data = SquareRootDouble(ROUND_TO_NEAREST,
    01901                                 &DoubleOperand,
    01902                                 &DoubleResult);
    01903
    01904     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01905         (DoubleResult.LowPart != 0x0) ||
    01906         (DoubleResult.HighPart != 0x80000)) {
    01907         goto TestFailed;
    01908     }
    01909
    01910     Subtest += 1;
    01911     DoubleOperand.LowPart = 0x0;
    01912     DoubleOperand.HighPart = 0x10000;
    01913     Fsr.Data = SquareRootDouble(ROUND_TO_NEAREST,
    01914                                 &DoubleOperand,
    01915                                 &DoubleResult);
    01916
    01917     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01918         (DoubleResult.LowPart != 0x0) ||
    01919         (DoubleResult.HighPart != 0x40000)) {
    01920         goto TestFailed;
    01921     }
    01922
    01923     Subtest += 1;
    01924     DoubleOperand.LowPart = 0x0;
    01925     DoubleOperand.HighPart = 0x4000;
    01926     Fsr.Data = SquareRootDouble(ROUND_TO_NEAREST,
    01927                                 &DoubleOperand,
    01928                                 &DoubleResult);
    01929
    01930     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01931         (DoubleResult.LowPart != 0x0) ||
    01932         (DoubleResult.HighPart != 0x20000)) {
    01933         goto TestFailed;
    01934     }
    01935
    01936     Subtest += 1;
    01937     DoubleOperand.LowPart = 0x0;
    01938     DoubleOperand.HighPart = 0x1000;
    01939     Fsr.Data = SquareRootDouble(ROUND_TO_NEAREST,
    01940                                 &DoubleOperand,
    01941                                 &DoubleResult);
    01942
    01943     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    01944         (DoubleResult.LowPart != 0x0) ||
    01945         (DoubleResult.HighPart != 0x10000)) {
    01946         goto TestFailed;
    01947     }
    01948
    01949     Subtest += 1;
    01950     DoubleOperand.LowPart = 0x0;
    01951     DoubleOperand.HighPart = 0x80000;
    01952     Fsr.Data = SquareRootDouble(ROUND_TO_NEAREST,
    01953                                 &DoubleOperand,
    01954                                 &DoubleResult);
    01955
    01956     if ((Fsr.Data != (SU | SI | ROUND_TO_NEAREST)) ||
    01957         (DoubleResult.LowPart != 0x333f9de6) ||
    01958         (DoubleResult.HighPart != 0xb504f)) {
    01959         goto TestFailed;
    01960     }
    01961
    01962 // ****** //
    01963
    01964     //
    01965     // End of test 25.
    01966     //
    01967
    01968     printf("succeeded\n");
    01969     return;
    01970
    01971     //
    01972     // Test 25 failed.
    01973     //
    01974
    01975 TestFailed:
    01976     printf(" subtest %d failed, fsr = %lx, result = %lx, %lx\n",
    01977            Subtest,
    01978            Fsr.Data,
    01979            DoubleResult.LowPart,
    01980            DoubleResult.HighPart);
    01981
    01982     return;
    01983 }

VOID Test26 | ( | VOID |  | ) |

Definition at line 1986 of file flpt2.c.

References Count, _FLOATING_STATUS::Data, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, MINUS_SINGLE_INFINITY_VALUE, SI, SIGN, SU, SV, and XV.

Referenced by main().

    01990 {
    01991
    01992     ULONG Count;
    01993     FLOATING_STATUS Fsr;
    01994     ULONG Subtest;
    01995     ULONG SingleResult;
    01996
    01997     //
    01998     // Test 26 - Square root single test.
    01999     //
    02000
    02001     Subtest = 0;
    02002     printf("    Test 26 - square root single ...");
    02003     Subtest += 1;
    02004     Fsr.Data = SquareRootSingle(ROUND_TO_NEAREST,
    02005                                SINGLE_QUIET_NAN,
    02006                                &SingleResult);
    02007
    02008     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02009         (SingleResult != SINGLE_QUIET_NAN)) {
    02010         goto TestFailed;
    02011     }
    02012
    02013     Subtest += 1;
    02014     Fsr.Data = SquareRootSingle(ROUND_TO_NEAREST,
    02015                                SINGLE_SIGNAL_NAN,
    02016                                &SingleResult);
    02017
    02018     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02019         (SingleResult != SINGLE_QUIET_NAN)) {
    02020         goto TestFailed;
    02021     }
    02022
    02023     Subtest += 1;
    02024     Count = 0;
    02025     try {
    02026         Fsr.Data = SquareRootSingle(EV | ROUND_TO_NEAREST,
    02027                                    SINGLE_SIGNAL_NAN,
    02028                                    &SingleResult);
    02029
    02030     } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    02031               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02032         Count += 1;
    02033     }
    02034
    02035     if (Count == 0) {
    02036         goto TestFailed;
    02037     }
    02038
    02039     Subtest += 1;
    02040     Fsr.Data = SquareRootSingle(ROUND_TO_NEAREST,
    02041                                 SINGLE_INFINITY_VALUE,
    02042                                 &SingleResult);
    02043
    02044     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02045         (SingleResult != SINGLE_INFINITY_VALUE)) {
    02046         goto TestFailed;
    02047     }
    02048
    02049     Subtest += 1;
    02050     Fsr.Data = SquareRootSingle(ROUND_TO_NEAREST,
    02051                                 MINUS_SINGLE_INFINITY_VALUE,
    02052                                 &SingleResult);
    02053
    02054     if ((Fsr.Data != (SV | XV | ROUND_TO_NEAREST)) ||
    02055         (SingleResult != SINGLE_QUIET_NAN)) {
    02056         goto TestFailed;
    02057     }
    02058
    02059 //    Subtest += 1;
    02060 //    Count = 0;
    02061 //    try {
    02062 //        Fsr.Data = SquareRootSingle(EV | ROUND_TO_NEAREST,
    02063 //                                   MINUS_SINGLE_INFINITY_VALUE,
    02064 //                                   &SingleResult);
    02065 //
    02066 //    } except ((GetExceptionCode() == STATUS_FLOAT_INVALID_OPERATION) ?
    02067 //              EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
    02068 //        Count += 1;
    02069 //    }
    02070 //
    02071 //    if (Count == 0) {
    02072 //        goto TestFailed;
    02073 //    }
    02074
    02075     Subtest += 1;
    02076     Fsr.Data = SquareRootSingle(ROUND_TO_NEAREST,
    02077                                 0,
    02078                                 &SingleResult);
    02079
    02080     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02081         (SingleResult != 0)) {
    02082         goto TestFailed;
    02083     }
    02084
    02085     Subtest += 1;
    02086     Fsr.Data = SquareRootSingle(ROUND_TO_NEAREST,
    02087                                 0 | SIGN,
    02088                                 &SingleResult);
    02089
    02090     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02091         (SingleResult != (0 | SIGN))) {
    02092         goto TestFailed;
    02093     }
    02094
    02095 // ****** //
    02096
    02097     Subtest += 1;
    02098     Fsr.Data = SquareRootSingle(ROUND_TO_NEAREST,
    02099                                 0x200000,
    02100                                 &SingleResult);
    02101
    02102     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02103         (SingleResult != 0x400000)) {
    02104         goto TestFailed;
    02105     }
    02106
    02107     Subtest += 1;
    02108     Fsr.Data = SquareRootSingle(ROUND_TO_NEAREST,
    02109                                 0x80000,
    02110                                 &SingleResult);
    02111
    02112     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02113         (SingleResult != 0x200000)) {
    02114         goto TestFailed;
    02115     }
    02116
    02117     Subtest += 1;
    02118     Fsr.Data = SquareRootSingle(ROUND_TO_NEAREST,
    02119                                 0x20000,
    02120                                 &SingleResult);
    02121
    02122     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02123         (SingleResult != 0x100000)) {
    02124         goto TestFailed;
    02125     }
    02126
    02127     Subtest += 1;
    02128     Fsr.Data = SquareRootSingle(ROUND_TO_NEAREST,
    02129                                 0x8000,
    02130                                 &SingleResult);
    02131
    02132     if ((Fsr.Data != ROUND_TO_NEAREST) ||
    02133         (SingleResult != 0x80000)) {
    02134         goto TestFailed;
    02135     }
    02136
    02137     Subtest += 1;
    02138     Fsr.Data = SquareRootSingle(ROUND_TO_NEAREST,
    02139                                 0x400000,
    02140                                 &SingleResult);
    02141
    02142     if ((Fsr.Data != (SU | SI | ROUND_TO_NEAREST)) ||
    02143         (SingleResult != 0x5a8279)) {
    02144         goto TestFailed;
    02145     }
    02146
    02147 // ****** //
    02148
    02149     //
    02150     // End of test 26.
    02151     //
    02152
    02153     printf("succeeded\n");
    02154     return;
    02155
    02156     //
    02157     // Test 26 failed.
    02158     //
    02159
    02160 TestFailed:
    02161     printf(" subtest %d failed, fsr = %lx, result = %lx\n",
    02162            Subtest,
    02163            Fsr.Data,
    02164            SingleResult);
    02165
    02166     return;
    02167 }

VOID Test3 | ( | VOID |  | ) |

Definition at line 568 of file flpt.c.

References AddSingle(), Count, _FLOATING_STATUS::Data, EI, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, and SI.

Referenced by main().

    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 }

VOID Test4 | ( | VOID |  | ) |

Definition at line 711 of file flpt.c.

References AddSingle(), Count, _FLOATING_STATUS::Data, EI, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, SI, and SIGN.

Referenced by main().

    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 }

VOID Test5 | ( | VOID |  | ) |

Definition at line 942 of file flpt.c.

References AddSingle(), Count, _FLOATING_STATUS::Data, EI, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, SI, and SIGN.

Referenced by main().

    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 }

VOID Test6 | ( | VOID |  | ) |

Definition at line 1173 of file flpt.c.

References AddSingle(), Count, _FLOATING_STATUS::Data, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, FS, MINUS_SINGLE_INFINITY_VALUE, SIGN, SINGLE_SIGNAL_NAN_PREFIX, SV, and XV.

Referenced by main().

    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 }

VOID Test7 | ( | VOID |  | ) |

Definition at line 1510 of file flpt.c.

References Count, _FLOATING_STATUS::Data, EI, EO, EU, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, MINUS_SINGLE_INFINITY_VALUE, MultiplySingle(), SI, SIGN, SO, SU, SV, XI, XO, and XV.

Referenced by main().

    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 }

VOID Test8 | ( | VOID |  | ) |

Definition at line 2322 of file flpt.c.

References Count, _FLOATING_STATUS::Data, DivideSingle(), EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, EZ, MINUS_SINGLE_INFINITY_VALUE, SI, SIGN, SO, SV, SZ, XV, and XZ.

Referenced by main().

    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 }

VOID Test9 | ( | VOID |  | ) |

Definition at line 2781 of file flpt.c.

References CC, CompareEqSingle(), CompareFSingle(), CompareLeSingle(), CompareLtSingle(), CompareNgeSingle(), CompareNgleSingle(), CompareNglSingle(), CompareNgtSingle(), CompareOleSingle(), CompareOltSingle(), CompareSeqSingle(), CompareSfSingle(), CompareUeqSingle(), CompareUltSingle(), CompareUnSingle(), Count, _FLOATING_STATUS::Data, EV, EXCEPTION_CONTINUE_SEARCH, EXCEPTION_EXECUTE_HANDLER, MINUS_SINGLE_INFINITY_VALUE, SIGN, SV, and XV.

Referenced by main().

    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 }

ULONG TruncateToLongwordFromDouble | ( | IN ULONG | RoundingMode,
|  | IN PULARGE_INTEGER | Source,
|  | OUT PULONG | Result
| ) |

| Referenced by Test24().

ULONG TruncateToLongwordFromSingle | ( | IN ULONG | RoundingMode,
|  | IN ULONG | Source,
|  | OUT PULONG | Result
| ) |