#include <stdlib.h>
#include "ntdll_test.h"

Include dependency graph for large_int.c:

Classes
struct	magic_divide_t

struct	largeint2str_t

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

#define	NB_MAGIC_DIVIDE (sizeof(magic_divide)/sizeof(*magic_divide))

#define	LARGE_STRI_BUFFER_LENGTH 67

#define	NB_LARGEINT2STR (sizeof(largeint2str)/sizeof(*largeint2str))

Functions
static	LONGLONG (WINAPI *pRtlExtendedMagicDivide)(LONGLONG

static	VOID (WINAPI *pRtlFreeAnsiString)(PSTRING)

static	NTSTATUS (WINAPI *pRtlInt64ToUnicodeString)(ULONGLONG

static	void (WINAPI *p_alldvrm)(LONGLONG

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)

	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	ULONGLONG

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 127 of file large_int.c.

◆ NB_LARGEINT2STR

#define NB_LARGEINT2STR (sizeof(largeint2str)/sizeof(*largeint2str))

Definition at line 278 of file large_int.c.

◆ NB_MAGIC_DIVIDE

#define NB_MAGIC_DIVIDE (sizeof(magic_divide)/sizeof(*magic_divide))

Definition at line 109 of file large_int.c.

◆ ULL

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

Definition at line 55 of file large_int.c.

Function Documentation

◆ InitFunctionPtrs()

static void InitFunctionPtrs ( void )

static

Definition at line 40 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_alldvrm = (void *)GetProcAddress(hntdll, "_alldvrm");
        p_aulldvrm = (void *)GetProcAddress(hntdll, "_aulldvrm");
    } /* 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 281 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%08x 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 %x, expected: %x\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%x%08x, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
       test_num, (DWORD)(largeint2str->value >>32), (DWORD)largeint2str->value, largeint2str->base, 
       ansi_str.Buffer, expected_ansi_str.Buffer);
    ok(unicode_string.Length == expected_unicode_string.Length,
       "(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 373 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%08x 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 %x, expected: %x\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 502 of file large_int.c.

{
    InitFunctionPtrs();
 
    if (pRtlExtendedMagicDivide)
        test_RtlExtendedMagicDivide();
    if (pRtlInt64ToUnicodeString)
        test_RtlInt64ToUnicodeString();
    if (pRtlLargeIntegerToChar)
        test_RtlLargeIntegerToChar();
 
#ifdef __i386__
    test__alldvrm();
#endif  /* __i386__ */
}

◆ test_RtlExtendedMagicDivide()

static void test_RtlExtendedMagicDivide ( void )

static

Definition at line 112 of file large_int.c.

{
    int i;
    LONGLONG result;
 
    for (i = 0; i < NB_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 363 of file large_int.c.

{
    int test_num;
 
    for (test_num = 0; test_num < NB_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 406 of file large_int.c.

{
    NTSTATUS result;
    int test_num;
    ULONGLONG value;
 
    for (test_num = 0; test_num < NB_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 %x, expected: %x\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 %x, expected: %x\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 %x, expected: %x\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 %x, expected: %x\n",
       wine_dbgstr_longlong(largeint2str[0].value),
       largeint2str[0].base, largeint2str[0].MaximumLength, result, STATUS_ACCESS_VIOLATION);
}