large_int.c File Reference

#include <stdlib.h>
#include <stdarg.h>
#include "ntstatus.h"
#include "windef.h"
#include "winbase.h"
#include "winternl.h"
#include "wine/test.h"

Include dependency graph for large_int.c:

Go to the source code of this file.

Classes
struct	magic_divide_t
struct	largeint2str_t

Macros
#define	WIN32_NO_STATUS
#define	ULL(a, b)   (((ULONGLONG)(a) << 32) | (b))
#define	LARGE_STRI_BUFFER_LENGTH   67

Functions
static	LONGLONG (WINAPI *pRtlExtendedMagicDivide)(LONGLONG
static	VOID (WINAPI *pRtlFreeAnsiString)(PSTRING)
static	NTSTATUS (WINAPI *pRtlInt64ToUnicodeString)(ULONGLONG
static	ULONGLONG (WINAPI *p_aulldiv)(ULONGLONG a
static void	InitFunctionPtrs (void)
static void	test_RtlExtendedMagicDivide (void)
static void	one_RtlInt64ToUnicodeString_test (int test_num, const largeint2str_t *largeint2str)
static void	test_RtlInt64ToUnicodeString (void)
static void	one_RtlLargeIntegerToChar_test (int test_num, const largeint2str_t *largeint2str)
static void	test_RtlLargeIntegerToChar (void)
static void	test_builtins (void)
	START_TEST (large_int)

Variables
static HMODULE	hntdll = 0
static	LONGLONG
static	INT
static	ULONG
static UNICODE_STRING *static	PCHAR
static const UNICODE_STRING	BOOLEAN
static LONGLONG	b
static void *	p_allshl
static void *	p_allshr
static void *	p_aullshr
static const magic_divide_t	magic_divide []
static const largeint2str_t	largeint2str []

Macro Definition Documentation

LARGE_STRI_BUFFER_LENGTH

#define LARGE_STRI_BUFFER_LENGTH   67

Definition at line 143 of file large_int.c.

ULL

#define ULL	(		a,
			b
	)		(((ULONGLONG)(a) << 32) | (b))

Definition at line 72 of file large_int.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 28 of file large_int.c.

Function Documentation

InitFunctionPtrs()

static void InitFunctionPtrs ( void  )

static

Definition at line 50 of file large_int.c.

{
    hntdll = LoadLibraryA("ntdll.dll");
    ok(hntdll != 0, "LoadLibrary failed\n");
    if (hntdll) {
    pRtlExtendedMagicDivide = (void *)GetProcAddress(hntdll, "RtlExtendedMagicDivide");
    pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString");
    pRtlInt64ToUnicodeString = (void *)GetProcAddress(hntdll, "RtlInt64ToUnicodeString");
    pRtlLargeIntegerToChar = (void *)GetProcAddress(hntdll, "RtlLargeIntegerToChar");
    pRtlUnicodeStringToAnsiString = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToAnsiString");
 
        p_alldiv = (void *)GetProcAddress(hntdll, "_alldiv");
        p_allrem = (void *)GetProcAddress(hntdll, "_allrem");
        p_allmul = (void *)GetProcAddress(hntdll, "_allmul");
        p_allshl = (void *)GetProcAddress(hntdll, "_allshl");
        p_allshr = (void *)GetProcAddress(hntdll, "_allshr");
        p_aulldiv = (void *)GetProcAddress(hntdll, "_aulldiv");
        p_aullrem = (void *)GetProcAddress(hntdll, "_aullrem");
        p_aullshr = (void *)GetProcAddress(hntdll, "_aullshr");
    } /* if */
}

Referenced by START_TEST().

LONGLONG()

static LONGLONG ( WINAPI *  pRtlExtendedMagicDivide )

static

NTSTATUS()

static NTSTATUS ( WINAPI *  pRtlInt64ToUnicodeString )

static

one_RtlInt64ToUnicodeString_test()

static void one_RtlInt64ToUnicodeString_test ( int  test_num, const largeint2str_t *  largeint2str  )

static

Definition at line 297 of file large_int.c.

{
    int pos;
    WCHAR expected_str_Buffer[LARGE_STRI_BUFFER_LENGTH + 1];
    UNICODE_STRING expected_unicode_string;
    STRING expected_ansi_str;
    WCHAR str_Buffer[LARGE_STRI_BUFFER_LENGTH + 1];
    UNICODE_STRING unicode_string;
    STRING ansi_str;
    NTSTATUS result;
 
#ifdef _WIN64
    if (largeint2str->value >> 32 == 0xffffffff)  /* this crashes on 64-bit Vista */
    {
        skip( "Value ffffffff%08lx broken on 64-bit windows\n", (DWORD)largeint2str->value );
        return;
    }
#endif
 
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
    expected_str_Buffer[pos] = largeint2str->Buffer[pos];
    } /* for */
    expected_unicode_string.Length = largeint2str->Length * sizeof(WCHAR);
    expected_unicode_string.MaximumLength = largeint2str->MaximumLength * sizeof(WCHAR);
    expected_unicode_string.Buffer = expected_str_Buffer;
    pRtlUnicodeStringToAnsiString(&expected_ansi_str, &expected_unicode_string, 1);
 
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
    str_Buffer[pos] = '-';
    } /* for */
    unicode_string.Length = 0;
    unicode_string.MaximumLength = largeint2str->MaximumLength * sizeof(WCHAR);
    unicode_string.Buffer = str_Buffer;
 
    if (largeint2str->base == 0) {
    result = pRtlInt64ToUnicodeString(largeint2str->value, 10, &unicode_string);
    } else {
    result = pRtlInt64ToUnicodeString(largeint2str->value, largeint2str->base, &unicode_string);
    } /* if */
    pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
    if (result == STATUS_BUFFER_OVERFLOW) {
    /* On BUFFER_OVERFLOW the string Buffer should be unchanged */
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
        expected_str_Buffer[pos] = '-';
    } /* for */
    /* w2k: The native function has two reasons for BUFFER_OVERFLOW: */
    /* If the value is too large to convert: The Length is unchanged */
    /* If str is too small to hold the string: Set str->Length to the length */
    /* the string would have (which can be larger than the MaximumLength). */
    /* To allow all this in the tests we do the following: */
    if (expected_unicode_string.Length >= 64) {
        /* The value is too large to convert only triggered when testing native */
        /* Length is not filled with the expected string length (garbage?) */
        expected_unicode_string.Length = unicode_string.Length;
    } /* if */
    } else {
    ok(result == largeint2str->result,
           "(test %d): RtlInt64ToUnicodeString(0x%s, %d, [out]) has result %lx, expected: %lx\n",
       test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base, result, largeint2str->result);
    if (result == STATUS_SUCCESS) {
        ok(unicode_string.Buffer[unicode_string.Length/sizeof(WCHAR)] == '\0',
               "(test %d): RtlInt64ToUnicodeString(0x%s, %d, [out]) string \"%s\" is not NULL terminated\n",
           test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base, ansi_str.Buffer);
    } /* if */
    } /* if */
    ok(memcmp(unicode_string.Buffer, expected_unicode_string.Buffer, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
       "(test %d): RtlInt64ToUnicodeString(0x%I64x, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
       test_num, largeint2str->value, largeint2str->base, ansi_str.Buffer, expected_ansi_str.Buffer);
    ok(unicode_string.Length == expected_unicode_string.Length ||
       broken(largeint2str->broken_len && !unicode_string.Length) /* win11 */,
       "(test %d): RtlInt64ToUnicodeString(0x%s, %d, [out]) string has Length %d, expected: %d\n",
       test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base,
       unicode_string.Length, expected_unicode_string.Length);
    ok(unicode_string.MaximumLength == expected_unicode_string.MaximumLength,
       "(test %d): RtlInt64ToUnicodeString(0x%s, %d, [out]) string has MaximumLength %d, expected: %d\n",
       test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base,
       unicode_string.MaximumLength, expected_unicode_string.MaximumLength);
    pRtlFreeAnsiString(&expected_ansi_str);
    pRtlFreeAnsiString(&ansi_str);
}

Referenced by test_RtlInt64ToUnicodeString().

one_RtlLargeIntegerToChar_test()

static void one_RtlLargeIntegerToChar_test ( int  test_num, const largeint2str_t *  largeint2str  )

static

Definition at line 389 of file large_int.c.

{
    NTSTATUS result;
    char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
    ULONGLONG value;
 
#ifdef _WIN64
    if (largeint2str->value >> 32 == 0xffffffff)  /* this crashes on 64-bit Vista */
    {
        skip( "Value ffffffff%08lx broken on 64-bit windows\n", (DWORD)largeint2str->value );
        return;
    }
#endif
 
    memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
    dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
    value = largeint2str->value;
    if (largeint2str->base == 0) {
    result = pRtlLargeIntegerToChar(&value, 10, largeint2str->MaximumLength, dest_str);
    } else {
    result = pRtlLargeIntegerToChar(&value, largeint2str->base, largeint2str->MaximumLength, dest_str);
    } /* if */
    ok(result == largeint2str->result,
       "(test %d): RtlLargeIntegerToChar(0x%s, %d, %d, [out]) has result %lx, expected: %lx\n",
       test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base,
       largeint2str->MaximumLength, result, largeint2str->result);
    ok(memcmp(dest_str, largeint2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
       "(test %d): RtlLargeIntegerToChar(0x%s, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
       test_num, wine_dbgstr_longlong(largeint2str->value), largeint2str->base,
       largeint2str->MaximumLength, dest_str, largeint2str->Buffer);
}

Referenced by test_RtlLargeIntegerToChar().

START_TEST()

START_TEST

(

large_int

)

Definition at line 582 of file large_int.c.

{
    InitFunctionPtrs();
 
    if (pRtlExtendedMagicDivide)
        test_RtlExtendedMagicDivide();
    if (pRtlInt64ToUnicodeString)
        test_RtlInt64ToUnicodeString();
    if (pRtlLargeIntegerToChar)
        test_RtlLargeIntegerToChar();
    test_builtins();
}

test_builtins()

static void test_builtins ( void  )

static

Definition at line 457 of file large_int.c.

{
#ifdef __i386__
    void *code_mem;
    ULONGLONG u;
    LONGLONG l;
 
    static const BYTE call_shift_code[] =
    {
        0x55,                           /* pushl %ebp */
        0x89, 0xe5,                     /* movl %esp,%ebp */
        0x31, 0xc0,                     /* xorl %eax,%eax */
        0x31, 0xd2,                     /* xorl %edx,%edx */
        0x31, 0xc9,                     /* xorl %ecx,%ecx */
        0x87, 0x45, 0x0c,               /* xchgl 12(%ebp),%eax */
        0x87, 0x55, 0x10,               /* xchgl 16(%ebp),%edx */
        0x87, 0x4d, 0x14,               /* xchgl 20(%ebp),%ecx */
        0xff, 0x55, 0x08,               /* call *8(%ebp) */
        0x39, 0xe5,                     /* cmpl %esp,%ebp */
        0x74, 0x05,                     /* je 1f */
        0xb8, 0xef, 0xbe, 0xad, 0xde,   /* movl $0xdeadbeef,%eax */
        0xc9,                           /* leave */
        0xc3,                           /* ret */
    };
    LONGLONG (__cdecl *call_shift_func)(void *func, LONGLONG a, LONG b);
 
    code_mem = VirtualAlloc(NULL, 0x1000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
 
    l = p_alldiv(100, 7);
    ok(l == 14, "_alldiv returned %s\n", wine_dbgstr_longlong(l));
 
    l = p_alldiv(-100, 7);
    ok(l == -14, "_alldiv returned %s\n", wine_dbgstr_longlong(l));
 
    l = p_alldiv(0x2000000040ll, 0x100000007ll);
    ok(l == 0x1f, "_alldiv returned %s\n", wine_dbgstr_longlong(l));
 
    u = p_aulldiv(100, 7);
    ok(u == 14, "_aulldiv returned %s\n", wine_dbgstr_longlong(u));
 
    u = p_aulldiv(-100, 7);
    ok(u == 0x2492492492492484ull, "_alldiv returned %s\n", wine_dbgstr_longlong(u));
 
    u = p_aulldiv(0x2000000040ull, 0x100000007ull);
    ok(u == 0x1f, "_aulldiv returned %s\n", wine_dbgstr_longlong(u));
 
    l = p_allrem(100, 7);
    ok(l == 2, "_allrem returned %s\n", wine_dbgstr_longlong(l));
 
    l = p_allrem(-100, 7);
    ok(l == -2, "_allrem returned %s\n", wine_dbgstr_longlong(l));
 
    l = p_allrem(0x2000000040ll, 0x100000007ll);
    ok(l == 0xffffff67, "_allrem returned %s\n", wine_dbgstr_longlong(l));
 
    u = p_aullrem(100, 7);
    ok(u == 2, "_aullrem returned %s\n", wine_dbgstr_longlong(u));
 
    u = p_aullrem(-100, 7);
    ok(u == 0, "_allrem returned %s\n", wine_dbgstr_longlong(u));
 
    u = p_aullrem(0x2000000040ull, 0x100000007ull);
    ok(u == 0xffffff67, "_aullrem returned %s\n", wine_dbgstr_longlong(u));
 
    l = p_allmul(3, 4);
    ok(l == 12, "_allmul = %s\n", wine_dbgstr_longlong(l));
 
    l = p_allmul(0x300000001ll, 4);
    ok(l == 0xc00000004, "_allmul = %s\n", wine_dbgstr_longlong(l));
 
    memcpy(code_mem, call_shift_code, sizeof(call_shift_code));
    call_shift_func = code_mem;
 
    l = call_shift_func(p_allshl, 0x0123456789abcdefll, 12);
    ok(l == 0x3456789abcdef000ll, "got %#I64x\n", l);
 
    l = call_shift_func(p_allshl, 0x0123456789abcdefll, 44);
    ok(l == 0xbcdef00000000000ll, "got %#I64x\n", l);
 
    l = call_shift_func(p_allshl, 0x0123456789abcdefll, 88);
    ok(!l, "got %#I64x\n", l);
 
    l = call_shift_func(p_allshl, 0x0123456789abcdefll, 0x88);
    ok(!l, "got %#I64x\n", l);
 
    l = call_shift_func(p_allshl, 0x0123456789abcdefll, 0x108);
    ok(l == 0x23456789abcdef00ll, "got %#I64x\n", l);
 
    l = call_shift_func(p_allshr, 0x0123456789abcdefll, 12);
    ok(l == 0x0123456789abcll, "got %#I64x\n", l);
 
    l = call_shift_func(p_allshr, 0x0123456789abcdefll, 44);
    ok(l == 0x01234ll, "got %#I64x\n", l);
 
    l = call_shift_func(p_allshr, 0x0123456789abcdefll, 88);
    ok(!l, "got %#I64x\n", l);
 
    l = call_shift_func(p_allshr, 0x8123456789abcdefll, 12);
    ok(l == 0xfff8123456789abcll, "got %#I64x\n", l);
 
    l = call_shift_func(p_allshr, 0x8123456789abcdefll, 44);
    ok(l == 0xfffffffffff81234ll, "got %#I64x\n", l);
 
    l = call_shift_func(p_allshr, 0x8123456789abcdefll, 88);
    ok(l == -1ll, "got %#I64x\n", l);
 
    l = call_shift_func(p_allshr, 0x8123456789abcdefll, 0x108);
    ok(l == 0xff8123456789abcdll, "got %#I64x\n", l);
 
    l = call_shift_func(p_aullshr, 0x8123456789abcdefll, 12);
    ok(l == 0x8123456789abcll, "got %#I64x\n", l);
 
    l = call_shift_func(p_aullshr, 0x8123456789abcdefll, 44);
    ok(l == 0x81234ll, "got %#I64x\n", l);
 
    l = call_shift_func(p_aullshr, 0x8123456789abcdefll, 88);
    ok(!l, "got %#I64x\n", l);
 
    l = call_shift_func(p_aullshr, 0x8123456789abcdefll, 0x108);
    ok(l == 0x8123456789abcdll, "got %#I64x\n", l);
 
    VirtualFree(code_mem, 0, MEM_RELEASE);
#endif /* __i386__ */
}

Referenced by START_TEST().

test_RtlExtendedMagicDivide()

static void test_RtlExtendedMagicDivide ( void  )

static

Definition at line 128 of file large_int.c.

{
    int i;
    LONGLONG result;
 
    for (i = 0; i < ARRAY_SIZE(magic_divide); i++) {
    result = pRtlExtendedMagicDivide(magic_divide[i].a, magic_divide[i].b, magic_divide[i].shift);
    ok(result == magic_divide[i].result,
           "call failed: RtlExtendedMagicDivide(0x%s, 0x%s, %d) has result 0x%s, expected 0x%s\n",
       wine_dbgstr_longlong(magic_divide[i].a), wine_dbgstr_longlong(magic_divide[i].b), magic_divide[i].shift,
       wine_dbgstr_longlong(result), wine_dbgstr_longlong(magic_divide[i].result));
    }
}

Referenced by START_TEST().

test_RtlInt64ToUnicodeString()

static void test_RtlInt64ToUnicodeString ( void  )

static

Definition at line 379 of file large_int.c.

{
    int test_num;
 
    for (test_num = 0; test_num < ARRAY_SIZE(largeint2str); test_num++) {
    one_RtlInt64ToUnicodeString_test(test_num, &largeint2str[test_num]);
    } /* for */
}

Referenced by START_TEST().

test_RtlLargeIntegerToChar()

static void test_RtlLargeIntegerToChar ( void  )

static

Definition at line 422 of file large_int.c.

{
    NTSTATUS result;
    int test_num;
    ULONGLONG value;
 
    for (test_num = 0; test_num < ARRAY_SIZE(largeint2str); test_num++) {
    one_RtlLargeIntegerToChar_test(test_num, &largeint2str[test_num]);
    } /* for */
 
    value = largeint2str[0].value;
    result = pRtlLargeIntegerToChar(&value, 20, largeint2str[0].MaximumLength, NULL);
    ok(result == STATUS_INVALID_PARAMETER,
       "(test a): RtlLargeIntegerToChar(0x%s, %d, %d, NULL) has result %lx, expected: %lx\n",
       wine_dbgstr_longlong(largeint2str[0].value), 20,
       largeint2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER);
 
    result = pRtlLargeIntegerToChar(&value, 20, 0, NULL);
    ok(result == STATUS_INVALID_PARAMETER,
       "(test b): RtlLargeIntegerToChar(0x%s, %d, %d, NULL) has result %lx, expected: %lx\n",
       wine_dbgstr_longlong(largeint2str[0].value), 20,
       largeint2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER);
 
    result = pRtlLargeIntegerToChar(&value, largeint2str[0].base, 0, NULL);
    ok(result == STATUS_BUFFER_OVERFLOW,
       "(test c): RtlLargeIntegerToChar(0x%s, %d, %d, NULL) has result %lx, expected: %lx\n",
       wine_dbgstr_longlong(largeint2str[0].value), largeint2str[0].base, 0, result, STATUS_BUFFER_OVERFLOW);
 
    result = pRtlLargeIntegerToChar(&value, largeint2str[0].base, largeint2str[0].MaximumLength, NULL);
    ok(result == STATUS_ACCESS_VIOLATION,
       "(test d): RtlLargeIntegerToChar(0x%s, %d, %d, NULL) has result %lx, expected: %lx\n",
       wine_dbgstr_longlong(largeint2str[0].value),
       largeint2str[0].base, largeint2str[0].MaximumLength, result, STATUS_ACCESS_VIOLATION);
}

Referenced by START_TEST().

ULONGLONG()

static ULONGLONG ( WINAPI *  p_aulldiv )

static

VOID()

static VOID ( WINAPI *  pRtlFreeAnsiString )

static

Variable Documentation

b

ULONGLONG b

Definition at line 43 of file large_int.c.

Referenced by test_builtins().

BOOLEAN

const UNICODE_STRING BOOLEAN

Definition at line 41 of file large_int.c.

hntdll

HMODULE hntdll = 0

static

Definition at line 36 of file large_int.c.

Referenced by InitFunctionPtrs().

INT

INT

Definition at line 37 of file large_int.c.

largeint2str

const largeint2str_t largeint2str[]

static

Definition at line 161 of file large_int.c.

Referenced by one_RtlInt64ToUnicodeString_test(), one_RtlLargeIntegerToChar_test(), test_RtlInt64ToUnicodeString(), and test_RtlLargeIntegerToChar().

LONGLONG

LONGLONG

Definition at line 37 of file large_int.c.

Referenced by test_builtins().

magic_divide

const magic_divide_t magic_divide[]

static

Definition at line 81 of file large_int.c.

Referenced by test_RtlExtendedMagicDivide().

p_allshl

void* p_allshl

static

Definition at line 48 of file large_int.c.

Referenced by InitFunctionPtrs(), and test_builtins().

p_allshr

void * p_allshr

static

Definition at line 48 of file large_int.c.

Referenced by InitFunctionPtrs(), and test_builtins().

p_aullshr

void * p_aullshr

static

Definition at line 48 of file large_int.c.

Referenced by InitFunctionPtrs(), and test_builtins().

PCHAR

UNICODE_STRING *static PCHAR

Definition at line 40 of file large_int.c.

ULONG

UNICODE_STRING *static ULONG

Definition at line 39 of file large_int.c.