__rt_div.c File Reference

#include <apitest.h>

Include dependency graph for __rt_div.c:

Go to the source code of this file.

Classes
struct	_SDIV_TEST_DATA
struct	_UDIV_TEST_DATA
struct	_SDIV64_TEST_DATA
struct	_UDIV64_TEST_DATA

Typedefs
typedef struct _SDIV_TEST_DATA	SDIV_TEST_DATA
typedef struct _UDIV_TEST_DATA	UDIV_TEST_DATA
typedef struct _SDIV64_TEST_DATA	SDIV64_TEST_DATA
typedef struct _UDIV64_TEST_DATA	UDIV64_TEST_DATA

Functions
	START_TEST (__rt_div)

Typedef Documentation

SDIV64_TEST_DATA

typedef struct _SDIV64_TEST_DATA SDIV64_TEST_DATA

SDIV_TEST_DATA

typedef struct _SDIV_TEST_DATA SDIV_TEST_DATA

UDIV64_TEST_DATA

typedef struct _UDIV64_TEST_DATA UDIV64_TEST_DATA

UDIV_TEST_DATA

typedef struct _UDIV_TEST_DATA UDIV_TEST_DATA

Function Documentation

START_TEST()

START_TEST

(

__rt_div

)

Definition at line 42 of file __rt_div.c.

{
    SDIV_TEST_DATA sdiv[] =
    {
        /* Dividend is larger than divisor */
        { 3425, 400, 8, 225 },
        { -3425, 400, -8, -225 },
        { 3425, -400, -8, 225 },
        { -3425, -400, 8, -225 },
        /* Divisor is larger than dividend */
        { 12, 42, 0, 12 },
        { -12, 42, 0, -12 },
        { 12, -42, 0, 12 },
        { -12, -42, 0, -12 },
        /* Division without remainder */
        { 16777216, 65536, 256, 0 },
        { -16777216, 65536, -256, 0 },
        { 16777216, -65536, -256, 0 },
        { -16777216, -65536, 256, 0 },
    };
    UDIV_TEST_DATA udiv[] =
    {
        /* Dividend is larger than divisor */
        { 3425, 400, 8, 225 },
        /* Divisor is larger than dividend */
        { 12, 42, 0, 12 },
        /* Division without remainder */
        { 16777216, 65536, 256, 0 },
    };
    SDIV64_TEST_DATA sdiv64[] =
    {
        /* Dividend is larger than divisor */
        { 34918215, 7, 4988316, 3 },
        { -34918215, 7, -4988316, -3 },
        { 34918215, -7, -4988316, 3 },
        { -34918215, -7, 4988316, -3 },
        /* Divisor is larger than dividend */
        { 12, 42, 0, 12 },
        { -12, 42, 0, -12 },
        { 12, -42, 0, 12 },
        { -12, -42, 0, -12 },
        /* Division without remainder */
        { 16777216, 65536, 256, 0 },
        { -16777216, 65536, -256, 0 },
        { 16777216, -65536, -256, 0 },
        { -16777216, -65536, 256, 0 },
 
        /* Big 64-bit numbers */
 
        /* Dividend is larger than divisor */
        { 0x2AFFFFFFFLL * 100, 400, 2885681151LL, 300 },
        { -0x2AFFFFFFFLL * 100, 400, -2885681151LL, -300 },
        { 0x2AFFFFFFFLL * 100, -400, -2885681151LL, 300 },
        { -0x2AFFFFFFFLL * 100, -400, 2885681151LL, -300 },
        /* Divisor is larger than dividend */
        { 0x2AFFFFFFFLL * 50, 0x2AFFFFFFFLL * 100, 0, 0x2AFFFFFFFLL * 50 },
        { -0x2AFFFFFFFLL * 50, 0x2AFFFFFFFLL * 100, 0, -0x2AFFFFFFFLL * 50 },
        { 0x2AFFFFFFFLL * 50, -0x2AFFFFFFFLL * 100, 0, 0x2AFFFFFFFLL * 50 },
        { -0x2AFFFFFFFLL * 50, -0x2AFFFFFFFLL * 100, 0, -0x2AFFFFFFFLL * 50 },
        /* Division without remainder */
        { 0x2AFFFFFFFLL * 100, 100, 0x2AFFFFFFFLL, 0 },
        { -0x2AFFFFFFFLL * 100, 100, -0x2AFFFFFFFLL, 0 },
        { 0x2AFFFFFFFLL * 100, -100, -0x2AFFFFFFFLL, 0 },
        { -0x2AFFFFFFFLL * 100, -100, 0x2AFFFFFFFLL, 0 },
    };
    UDIV64_TEST_DATA udiv64[] =
    {
        /* Dividend is larger than divisor */
        { 34918215, 7, 4988316, 3 },
        /* Divisor is larger than dividend */
        { 12, 42, 0, 12 },
        /* Division without remainder */
        { 16777216, 65536, 256, 0 },
 
        /* Big 64-bit numbers */
 
        /* Dividend is larger than divisor */
        { 0x2AFFFFFFFULL * 100, 400, 2885681151ULL, 300 },
        /* Divisor is larger than dividend */
        { 0x2AFFFFFFFULL * 50, 0x2AFFFFFFFULL * 100, 0, 0x2AFFFFFFFULL * 50 },
        /* Division without remainder */
        { 0x2AFFFFFFFULL * 100, 100, 0x2AFFFFFFFULL, 0 },
    };
    INT i;
 
    for (i = 0; i < _countof(sdiv); i++)
    {
        LONG test_div, test_mod;
 
        test_div = sdiv[i].dividend / sdiv[i].divisor;
        test_mod = sdiv[i].dividend % sdiv[i].divisor;
        ok(test_div == sdiv[i].expected_div, "(sdiv) %d: Expected %ld, got %ld / %ld = %ld\n",
           i, sdiv[i].expected_div, sdiv[i].dividend, sdiv[i].divisor, test_div);
        ok(test_mod == sdiv[i].expected_mod, "(sdiv) %d: Expected %ld, got %ld %% %ld = %ld\n",
           i, sdiv[i].expected_mod, sdiv[i].dividend, sdiv[i].divisor, test_mod);
    }
 
    for (i = 0; i < _countof(udiv); i++)
    {
        ULONG test_div, test_mod;
 
        test_div = udiv[i].dividend / udiv[i].divisor;
        test_mod = udiv[i].dividend % udiv[i].divisor;
        ok(test_div == udiv[i].expected_div, "(udiv) %d: Expected %lu, got %lu / %lu = %lu\n",
           i, udiv[i].expected_div, udiv[i].dividend, udiv[i].divisor, test_div);
        ok(test_mod == udiv[i].expected_mod, "(udiv) %d: Expected %lu, got %lu %% %lu = %lu\n",
           i, udiv[i].expected_mod, udiv[i].dividend, udiv[i].divisor, test_mod);
    }
 
    for (i = 0; i < _countof(sdiv64); i++)
    {
        LONGLONG test_div, test_mod;
 
        test_div = sdiv64[i].dividend / sdiv64[i].divisor;
        test_mod = sdiv64[i].dividend % sdiv64[i].divisor;
        ok(test_div == sdiv64[i].expected_div, "(sdiv64) %d: Expected %lld, got %lld / %lld = %lld\n",
           i, sdiv64[i].expected_div, sdiv64[i].dividend, sdiv64[i].divisor, test_div);
        ok(test_mod == sdiv64[i].expected_mod, "(sdiv64) %d: Expected %lld, got %lld %% %lld = %lld\n",
           i, sdiv64[i].expected_mod, sdiv64[i].dividend, sdiv64[i].divisor, test_mod);
    }
 
    for (i = 0; i < _countof(udiv64); i++)
    {
        ULONGLONG test_div, test_mod;
 
        test_div = udiv64[i].dividend / udiv64[i].divisor;
        test_mod = udiv64[i].dividend % udiv64[i].divisor;
        ok(test_div == udiv64[i].expected_div, "(udiv64) %d: Expected %llu, got %llu / %llu = %llu\n",
           i, udiv64[i].expected_div, udiv64[i].dividend, udiv64[i].divisor, test_div);
        ok(test_mod == udiv64[i].expected_mod, "(udiv64) %d: Expected %llu, got %llu %% %llu = %llu\n",
           i, udiv64[i].expected_mod, udiv64[i].dividend, udiv64[i].divisor, test_mod);
    }
}