C++ (Cpp) TestHex Exemples

Exemple #1

Fichier : twlocale_t.cpp Projet : jiangzhw/tripwire-open-source

void TestTWLocale()
{
#ifdef DOESNTWORK
    TestHex();
    TestAtoi();
    TestItoa();    
    TestFlags();
    TestRoundtrip();
#endif//NOTDONE
}

Exemple #2

Fichier : main.c Projet : mmaloney007/Old_CS_Code

main()
{
    /* Alpha/OSF (at least) requires us to request that SIGFPE be ignored */

    signal(SIGFPE, SIG_IGN);
	
    /* First, some easy ones */

    printf("\nEasy Ones\n");

    TestDouble(1.0, 2.0);

    TestDouble(5.0, 2.0);

    TestHex(0x4010000000000000L, 0x400000000000001EL);

    TestHex(0x4030000000000000L, 0x400E200000000000L);

    /* How about negative inputs? */

    printf("\nNegative Inputs\n");

    TestDouble(3.0, -1.0);

    TestHex(0x430000000000000FL, 0xC00E000000000000L);

    TestHex(0xC00E00000000000FL, 0x430000000000000FL);

    TestDouble(-1.0, -2.0);

    TestHex(0xC30000000000000FL, 0x400E000000000000L);

    /* How about normalization? */

    printf("\nNormalization\n");

    TestDouble(1.0, 1.0);

    TestHex(0x400000000000000FL, 0xC000000000000000L);

    /* How about rounding? */

    printf("\nRounding - 1 bit\n");

    TestHex(0x4010000000000000L, 0x4000000000000000L);    /* 1 bit shift */

    TestHex(0x4010000000000000L, 0x4000000000000001L);

    TestHex(0x4010000000000001L, 0x4000000000000000L);

    TestHex(0x4010000000000001L, 0x4000000000000001L);

    printf("\nRounding - 2 bit\n");

    TestHex(0x4020000000000000L, 0x4000000000000000L);    /* 2 bit shift */

    TestHex(0x4020000000000000L, 0x4000000000000001L);

    TestHex(0x4020000000000000L, 0x4000000000000002L);

    TestHex(0x4020000000000000L, 0x4000000000000003L);

    TestHex(0x4020000000000001L, 0x4000000000000000L);

    TestHex(0x4020000000000001L, 0x4000000000000001L);

    TestHex(0x4020000000000001L, 0x4000000000000002L);

    TestHex(0x4020000000000001L, 0x4000000000000003L);

    printf("\nRounding - 3 bit\n");

    TestHex(0x4030000000000000L, 0x4000000000000000L);    /* 3 bit shift */

    TestHex(0x4030000000000000L, 0x4000000000000001L);

    TestHex(0x4030000000000000L, 0x4000000000000002L);

    TestHex(0x4030000000000000L, 0x4000000000000003L);

    TestHex(0x4030000000000000L, 0x4000000000000004L);

    TestHex(0x4030000000000000L, 0x4000000000000005L);

    TestHex(0x4030000000000000L, 0x4000000000000006L);

    TestHex(0x4030000000000000L, 0x4000000000000007L);

    TestHex(0x4030000000000001L, 0x4000000000000000L);

    TestHex(0x4030000000000001L, 0x4000000000000001L);

    TestHex(0x4030000000000001L, 0x4000000000000002L);

    TestHex(0x4030000000000001L, 0x4000000000000003L);

    TestHex(0x4030000000000001L, 0x4000000000000004L);

    TestHex(0x4030000000000001L, 0x4000000000000005L);

    TestHex(0x4030000000000001L, 0x4000000000000006L);

    TestHex(0x4030000000000001L, 0x4000000000000007L);

    printf("\nRounding - 4 bit\n");

    TestHex(0x4040000000000000L, 0x4000000000000000L);    /* 4 bit shift */

    TestHex(0x4040000000000000L, 0x4000000000000001L);

    TestHex(0x4040000000000000L, 0x4000000000000002L);

    TestHex(0x4040000000000000L, 0x4000000000000003L);

    TestHex(0x4040000000000000L, 0x4000000000000004L);

    TestHex(0x4040000000000000L, 0x4000000000000005L);

    TestHex(0x4040000000000000L, 0x4000000000000006L);

    TestHex(0x4040000000000000L, 0x4000000000000007L);

    TestHex(0x4040000000000000L, 0x4000000000000008L);

    TestHex(0x4040000000000000L, 0x4000000000000009L);

    TestHex(0x4040000000000000L, 0x400000000000000AL);

    TestHex(0x4040000000000000L, 0x400000000000000BL);

    TestHex(0x4040000000000000L, 0x400000000000000CL);

    TestHex(0x4040000000000000L, 0x400000000000000DL);

    TestHex(0x4040000000000000L, 0x400000000000000EL);

    TestHex(0x4040000000000000L, 0x400000000000000FL);

    TestHex(0x4040000000000001L, 0x4000000000000000L);

    TestHex(0x4040000000000001L, 0x4000000000000001L);

    TestHex(0x4040000000000001L, 0x4000000000000002L);

    TestHex(0x4040000000000001L, 0x4000000000000003L);

    TestHex(0x4040000000000001L, 0x4000000000000004L);

    TestHex(0x4040000000000001L, 0x4000000000000005L);

    TestHex(0x4040000000000001L, 0x4000000000000006L);

    TestHex(0x4040000000000001L, 0x4000000000000007L);

    TestHex(0x4040000000000001L, 0x4000000000000008L);

    TestHex(0x4040000000000001L, 0x4000000000000009L);

    TestHex(0x4040000000000001L, 0x400000000000000AL);

    TestHex(0x4040000000000001L, 0x400000000000000BL);

    TestHex(0x4040000000000001L, 0x400000000000000CL);

    TestHex(0x4040000000000001L, 0x400000000000000DL);

    TestHex(0x4040000000000001L, 0x400000000000000EL);

    TestHex(0x4040000000000001L, 0x400000000000000FL);

    printf("\nRounding - sticky bit, etc\n");

    TestHex(0x40A0000000000000L, 0x4000000000000201L);   /* test sticky bit */

    TestHex(0x4007FFFFFFFFFFFFL, 0x4340000000000000L);   /* again */

    TestHex(0x4040000000000001L, 0x4000000000000005L);   /* subtract w/sticky */

    TestHex(0x40AFF80000000000L, 0x400FFFFFFFFFFFFFL);   /* rounding causes 
                                                            re-normalization */

    TestHex(0x40AC000000000000L, 0x4004000000000005L);   /* round or normalize
                                                            result first? */

    /* How about zero, NaN, infinity? */

    printf("\nSpecial Cases - overflow\n");

    TestHex(0x7FE0000000000000L, 0x7FE0000000000000L);   /* overflow to
                                                            +infinity */

    TestHex(0xFFE0000000000000L, 0xFFE0000000000000L);   /* overflow to
                                                            -infinity */

    printf("\nSpecial Cases - NaN in\n");

    TestHex(0x7FF0000000000001L, 0x3FF0000000000000L);   /* NaN plus 1 */

    TestHex(0x3FF0000000000000L, 0x7FF1000000000000L);   /* 1 plus NaN */

    printf("\nSpecial Cases - NaN out\n");

    TestHex(0x7FF0000000000000L, 0xFFF0000000000000L);   /* +Infinity plus
                                                            -Infinity */

    printf("\nSpecial Cases - Infinity in\n");

    TestHex(0x7FF0000000000000L, 0x3FF0000000000000L);   /* +Infinity plus 1 */

    TestHex(0x7FF0000000000000L, 0xBFF0000000000000L);   /* +Infinity plus -1 */
    
    TestHex(0xFFF0000000000000L, 0x3FF0000000000000L);   /* -Infinity plus 1 */
    
    TestHex(0xFFF0000000000000L, 0xBFF0000000000000L);   /* -Infinity plus -1 */

    printf("\nSpecial Cases - zero\n");

    TestDouble(0.0, 1.0);

    TestDouble(1.0, -1.0);

    printf("\nDone.\n");
}