string.c File Reference

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

Include dependency graph for string.c:

Go to the source code of this file.

Classes
struct	ulong2str_t
struct	ulonglong2str_t
struct	str2long_t
struct	str2longlong_t

Macros
#define	LARGE_STRI_BUFFER_LENGTH   67
#define	NB_ULONG2STR   (sizeof(ulong2str)/sizeof(*ulong2str))
#define	ULL(a, b)   (((ULONGLONG)(a) << 32) | (b))
#define	NB_ULONGLONG2STR   (sizeof(ulonglong2str)/sizeof(*ulonglong2str))
#define	NB_STR2LONG   (sizeof(str2long)/sizeof(*str2long))
#define	NB_STR2LONGLONG   (sizeof(str2longlong)/sizeof(*str2longlong))

Functions
static	NTSTATUS (WINAPI *pRtlUnicodeStringToAnsiString)(STRING *
static	VOID (WINAPI *pRtlFreeAnsiString)(PSTRING)
static	BOOLEAN (WINAPI *pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING
static	int (WINAPIV *patoi)(const char *)
static	long (WINAPIV *patol)(const char *)
static	LONGLONG (WINAPIV *p_atoi64)(const char *)
static	LPSTR (WINAPIV *p_itoa)(int
static	LPWSTR (WINAPIV *p_itow)(int
static	LPWSTR (__cdecl *p_wcslwr)(LPWSTR)
static	void (__cdecl *p_qsort)(void *
static	int (__cdecl *compar)(const void *
static const void *static void *__cdecl *	p_bsearch (void *, void *, size_t, size_t, int(__cdecl *compar)(const void *, const void *))
static const char static void	InitFunctionPtrs (void)
static void	one_itoa_test (int test_num, const ulong2str_t *ulong2str)
static void	one_ltoa_test (int test_num, const ulong2str_t *ulong2str)
static void	one_ultoa_test (int test_num, const ulong2str_t *ulong2str)
static void	test_ulongtoa (void)
static void	one_itow_test (int test_num, const ulong2str_t *ulong2str)
static void	one_ltow_test (int test_num, const ulong2str_t *ulong2str)
static void	one_ultow_test (int test_num, const ulong2str_t *ulong2str)
static void	test_ulongtow (void)
static void	one_i64toa_test (int test_num, const ulonglong2str_t *ulonglong2str)
static void	one_ui64toa_test (int test_num, const ulonglong2str_t *ulonglong2str)
static void	test_ulonglongtoa (void)
static void	one_i64tow_test (int test_num, const ulonglong2str_t *ulonglong2str)
static void	one_ui64tow_test (int test_num, const ulonglong2str_t *ulonglong2str)
static void	test_ulonglongtow (void)
static void	test_wtoi (void)
static void	test_atoi (void)
static void	test_atol (void)
static void	test_wtol (void)
static void	test_atoi64 (void)
static void	test_wtoi64 (void)
static void	test_wcschr (void)
static void	test_wcsrchr (void)
static void	test_wcslwrupr (void)
static int __cdecl	intcomparefunc (const void *a, const void *b)
static int __cdecl	charcomparefunc (const void *a, const void *b)
static int __cdecl	strcomparefunc (const void *a, const void *b)
static void	test_qsort (void)
static void	test_bsearch (void)
static void	test__snprintf (void)
	START_TEST (string)

Variables
static HMODULE	hntdll = 0
static const UNICODE_STRING	BOOLEAN
static	LPCSTR
static	LPSTR
static	INT
static	LPWSTR
static	int
static	WCHAR
static	size_t
static const ulong2str_t	ulong2str []
static const ulonglong2str_t	ulonglong2str []
static const str2long_t	str2long []
static const str2longlong_t	str2longlong []

Macro Definition Documentation

LARGE_STRI_BUFFER_LENGTH

#define LARGE_STRI_BUFFER_LENGTH   67

Definition at line 106 of file string.c.

NB_STR2LONG

#define NB_STR2LONG   (sizeof(str2long)/sizeof(*str2long))

Definition at line 888 of file string.c.

NB_STR2LONGLONG

#define NB_STR2LONGLONG   (sizeof(str2longlong)/sizeof(*str2longlong))

Definition at line 1071 of file string.c.

NB_ULONG2STR

#define NB_ULONG2STR   (sizeof(ulong2str)/sizeof(*ulong2str))

Definition at line 215 of file string.c.

NB_ULONGLONG2STR

#define NB_ULONGLONG2STR   (sizeof(ulonglong2str)/sizeof(*ulonglong2str))

Definition at line 591 of file string.c.

ULL

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

Definition at line 442 of file string.c.

Function Documentation

BOOLEAN()

static BOOLEAN ( WINAPI *  pRtlCreateUnicodeStringFromAsciiz )

static

charcomparefunc()

static int __cdecl charcomparefunc ( const void *  a, const void *  b  )

static

Definition at line 1177 of file string.c.

{
    const char *p = a, *q = b;
 
    ok (a != b, "must never get the same pointer\n");
 
    return *p - *q;
}

Referenced by test_qsort().

InitFunctionPtrs()

static const char static void InitFunctionPtrs ( void  )

static

Definition at line 65 of file string.c.

{
    hntdll = LoadLibraryA("ntdll.dll");
    ok(hntdll != 0, "LoadLibrary failed\n");
    if (hntdll) {
    pRtlUnicodeStringToAnsiString = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToAnsiString");
    pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString");
    pRtlCreateUnicodeStringFromAsciiz = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeStringFromAsciiz");
    pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
 
    patoi = (void *)GetProcAddress(hntdll, "atoi");
    patol = (void *)GetProcAddress(hntdll, "atol");
    p_atoi64 = (void *)GetProcAddress(hntdll, "_atoi64");
    p_itoa = (void *)GetProcAddress(hntdll, "_itoa");
    p_ltoa = (void *)GetProcAddress(hntdll, "_ltoa");
    p_ultoa = (void *)GetProcAddress(hntdll, "_ultoa");
    p_i64toa = (void *)GetProcAddress(hntdll, "_i64toa");
    p_ui64toa = (void *)GetProcAddress(hntdll, "_ui64toa");
 
    p_wtoi = (void *)GetProcAddress(hntdll, "_wtoi");
    p_wtol = (void *)GetProcAddress(hntdll, "_wtol");
    p_wtoi64 = (void *)GetProcAddress(hntdll, "_wtoi64");
    p_itow = (void *)GetProcAddress(hntdll, "_itow");
    p_ltow = (void *)GetProcAddress(hntdll, "_ltow");
    p_ultow = (void *)GetProcAddress(hntdll, "_ultow");
    p_i64tow = (void *)GetProcAddress(hntdll, "_i64tow");
    p_ui64tow = (void *)GetProcAddress(hntdll, "_ui64tow");
 
        p_wcslwr = (void *)GetProcAddress(hntdll, "_wcslwr");
        p_wcsupr = (void *)GetProcAddress(hntdll, "_wcsupr");
 
    p_wcschr= (void *)GetProcAddress(hntdll, "wcschr");
    p_wcsrchr= (void *)GetProcAddress(hntdll, "wcsrchr");
    p_qsort= (void *)GetProcAddress(hntdll, "qsort");
    p_bsearch= (void *)GetProcAddress(hntdll, "bsearch");
 
        p__snprintf = (void *)GetProcAddress(hntdll, "_snprintf");
    } /* if */
}

Referenced by START_TEST().

int() [1/2]

static int

(

__cdecl *

compar

)

const

int() [2/2]

static int ( WINAPIV *  patoi ) const

static

intcomparefunc()

static int __cdecl intcomparefunc ( const void *  a, const void *  b  )

static

Definition at line 1168 of file string.c.

{
    const int *p = a, *q = b;
 
    ok (a != b, "must never get the same pointer\n");
 
    return *p - *q;
}

Referenced by test_bsearch(), and test_qsort().

long()

static long ( WINAPIV *  patol ) const

static

LONGLONG()

static LONGLONG ( WINAPIV *  p_atoi64 ) const

static

LPSTR()

static LPSTR ( WINAPIV *  p_itoa )

static

LPWSTR() [1/2]

static LPWSTR ( __cdecl *  p_wcslwr )

static

LPWSTR() [2/2]

static LPWSTR ( WINAPIV *  p_itow )

static

NTSTATUS()

static NTSTATUS ( WINAPI *  pRtlUnicodeStringToAnsiString )

static

one_i64toa_test()

static void one_i64toa_test ( int  test_num, const ulonglong2str_t *  ulonglong2str  )

static

Definition at line 594 of file string.c.

{
    LPSTR result;
    char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
 
    memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
    dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
    result = p_i64toa(ulonglong2str->value, dest_str, ulonglong2str->base);
    ok(result == dest_str,
       "(test %d): _i64toa(%s, [out], %d) has result %p, expected: %p\n",
       test_num, wine_dbgstr_longlong(ulonglong2str->value), ulonglong2str->base, result, dest_str);
    if (ulonglong2str->mask & 0x04) {
    if (memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) != 0) {
        if (memcmp(dest_str, ulonglong2str[1].Buffer, LARGE_STRI_BUFFER_LENGTH) != 0) {
        ok(memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
           "(test %d): _i64toa(%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
           test_num, wine_dbgstr_longlong(ulonglong2str->value),
                   ulonglong2str->base, dest_str, ulonglong2str->Buffer);
        } /* if */
    } /* if */
    } else {
    ok(memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
       "(test %d): _i64toa(%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
       test_num, wine_dbgstr_longlong(ulonglong2str->value),
           ulonglong2str->base, dest_str, ulonglong2str->Buffer);
    } /* if */
}

Referenced by test_ulonglongtoa().

one_i64tow_test()

static void one_i64tow_test ( int  test_num, const ulonglong2str_t *  ulonglong2str  )

static

Definition at line 658 of file string.c.

{
    int pos;
    WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
    WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
    UNICODE_STRING unicode_string;
    STRING ansi_str;
    LPWSTR result;
 
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
    expected_wstr[pos] = ulonglong2str->Buffer[pos];
    } /* for */
    expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
 
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
    dest_wstr[pos] = '-';
    } /* for */
    dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
    unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR);
    unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR);
    unicode_string.Buffer = dest_wstr;
 
    result = p_i64tow(ulonglong2str->value, dest_wstr, ulonglong2str->base);
    pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
    ok(result == dest_wstr,
       "(test %d): _i64tow(0x%s, [out], %d) has result %p, expected: %p\n",
       test_num, wine_dbgstr_longlong(ulonglong2str->value), ulonglong2str->base, result, dest_wstr);
    if (ulonglong2str->mask & 0x04) {
    if (memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) != 0) {
        for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
        expected_wstr[pos] = ulonglong2str[1].Buffer[pos];
        } /* for */
        expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
        if (memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) != 0) {
        ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
                   "(test %d): _i64tow(0x%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
           test_num, wine_dbgstr_longlong(ulonglong2str->value),
           ulonglong2str->base, ansi_str.Buffer, ulonglong2str->Buffer);
        } /* if */
    } /* if */
    } else {
    ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
           "(test %d): _i64tow(0x%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
       test_num, wine_dbgstr_longlong(ulonglong2str->value),
       ulonglong2str->base, ansi_str.Buffer, ulonglong2str->Buffer);
    } /* if */
    pRtlFreeAnsiString(&ansi_str);
}

Referenced by test_ulonglongtow().

one_itoa_test()

static void one_itoa_test ( int  test_num, const ulong2str_t *  ulong2str  )

static

Definition at line 218 of file string.c.

{
    char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
    int value;
    LPSTR result;
 
    memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
    dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
    value = ulong2str->value;
    result = p_itoa(value, dest_str, ulong2str->base);
    ok(result == dest_str,
       "(test %d): _itoa(%d, [out], %d) has result %p, expected: %p\n",
       test_num, value, ulong2str->base, result, dest_str);
    ok(memcmp(dest_str, ulong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
       "(test %d): _itoa(%d, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
       test_num, value, ulong2str->base, dest_str, ulong2str->Buffer);
}

Referenced by test_ulongtoa().

one_itow_test()

static void one_itow_test ( int  test_num, const ulong2str_t *  ulong2str  )

static

Definition at line 293 of file string.c.

{
    int pos;
    WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
    WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
    UNICODE_STRING unicode_string;
    STRING ansi_str;
    int value;
    LPWSTR result;
 
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
    expected_wstr[pos] = ulong2str->Buffer[pos];
    } /* for */
    expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
 
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
    dest_wstr[pos] = '-';
    } /* for */
    dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
    unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR);
    unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR);
    unicode_string.Buffer = dest_wstr;
    value = ulong2str->value;
    result = p_itow(value, dest_wstr, ulong2str->base);
    pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
    ok(result == dest_wstr,
       "(test %d): _itow(%d, [out], %d) has result %p, expected: %p\n",
       test_num, value, ulong2str->base, result, dest_wstr);
    ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
       "(test %d): _itow(%d, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
       test_num, value, ulong2str->base, ansi_str.Buffer, ulong2str->Buffer);
    pRtlFreeAnsiString(&ansi_str);
}

Referenced by test_ulongtow().

one_ltoa_test()

static void one_ltoa_test ( int  test_num, const ulong2str_t *  ulong2str  )

static

Definition at line 237 of file string.c.

{
    char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
    LONG value;
    LPSTR result;
 
    memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
    dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
    value = ulong2str->value;
    result = p_ltoa(ulong2str->value, dest_str, ulong2str->base);
    ok(result == dest_str,
       "(test %d): _ltoa(%d, [out], %d) has result %p, expected: %p\n",
       test_num, value, ulong2str->base, result, dest_str);
    ok(memcmp(dest_str, ulong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
       "(test %d): _ltoa(%d, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
       test_num, value, ulong2str->base, dest_str, ulong2str->Buffer);
}

Referenced by test_ulongtoa().

one_ltow_test()

static void one_ltow_test ( int  test_num, const ulong2str_t *  ulong2str  )

static

Definition at line 328 of file string.c.

{
    int pos;
    WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
    WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
    UNICODE_STRING unicode_string;
    STRING ansi_str;
    LONG value;
    LPWSTR result;
 
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
    expected_wstr[pos] = ulong2str->Buffer[pos];
    } /* for */
    expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
 
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
    dest_wstr[pos] = '-';
    } /* for */
    dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
    unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR);
    unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR);
    unicode_string.Buffer = dest_wstr;
 
    value = ulong2str->value;
    result = p_ltow(value, dest_wstr, ulong2str->base);
    pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
    ok(result == dest_wstr,
       "(test %d): _ltow(%d, [out], %d) has result %p, expected: %p\n",
       test_num, value, ulong2str->base, result, dest_wstr);
    ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
       "(test %d): _ltow(%d, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
       test_num, value, ulong2str->base, ansi_str.Buffer, ulong2str->Buffer);
    pRtlFreeAnsiString(&ansi_str);
}

Referenced by test_ulongtow().

one_ui64toa_test()

static void one_ui64toa_test ( int  test_num, const ulonglong2str_t *  ulonglong2str  )

static

Definition at line 623 of file string.c.

{
    LPSTR result;
    char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
 
    memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
    dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
    result = p_ui64toa(ulonglong2str->value, dest_str, ulonglong2str->base);
    ok(result == dest_str,
       "(test %d): _ui64toa(%s, [out], %d) has result %p, expected: %p\n",
       test_num, wine_dbgstr_longlong(ulonglong2str->value), ulonglong2str->base, result, dest_str);
    ok(memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
       "(test %d): _ui64toa(%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
       test_num, wine_dbgstr_longlong(ulonglong2str->value),
       ulonglong2str->base, dest_str, ulonglong2str->Buffer);
}

Referenced by test_ulonglongtoa().

one_ui64tow_test()

static void one_ui64tow_test ( int  test_num, const ulonglong2str_t *  ulonglong2str  )

static

Definition at line 708 of file string.c.

{
    int pos;
    WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
    WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
    UNICODE_STRING unicode_string;
    STRING ansi_str;
    LPWSTR result;
 
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
    expected_wstr[pos] = ulonglong2str->Buffer[pos];
    } /* for */
    expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
 
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
    dest_wstr[pos] = '-';
    } /* for */
    dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
    unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR);
    unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR);
    unicode_string.Buffer = dest_wstr;
 
    result = p_ui64tow(ulonglong2str->value, dest_wstr, ulonglong2str->base);
    pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
    ok(result == dest_wstr,
       "(test %d): _ui64tow(0x%s, [out], %d) has result %p, expected: %p\n",
       test_num, wine_dbgstr_longlong(ulonglong2str->value),
       ulonglong2str->base, result, dest_wstr);
    ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
       "(test %d): _ui64tow(0x%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
       test_num, wine_dbgstr_longlong(ulonglong2str->value),
       ulonglong2str->base, ansi_str.Buffer, ulonglong2str->Buffer);
    pRtlFreeAnsiString(&ansi_str);
}

Referenced by test_ulonglongtow().

one_ultoa_test()

static void one_ultoa_test ( int  test_num, const ulong2str_t *  ulong2str  )

static

Definition at line 256 of file string.c.

{
    char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
    ULONG value;
    LPSTR result;
 
    memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
    dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
    value = ulong2str->value;
    result = p_ultoa(ulong2str->value, dest_str, ulong2str->base);
    ok(result == dest_str,
       "(test %d): _ultoa(%u, [out], %d) has result %p, expected: %p\n",
       test_num, value, ulong2str->base, result, dest_str);
    ok(memcmp(dest_str, ulong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
       "(test %d): _ultoa(%u, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
       test_num, value, ulong2str->base, dest_str, ulong2str->Buffer);
}

Referenced by test_ulongtoa().

one_ultow_test()

static void one_ultow_test ( int  test_num, const ulong2str_t *  ulong2str  )

static

Definition at line 364 of file string.c.

{
    int pos;
    WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
    WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
    UNICODE_STRING unicode_string;
    STRING ansi_str;
    ULONG value;
    LPWSTR result;
 
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
    expected_wstr[pos] = ulong2str->Buffer[pos];
    } /* for */
    expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
 
    for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
    dest_wstr[pos] = '-';
    } /* for */
    dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
    unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR);
    unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR);
    unicode_string.Buffer = dest_wstr;
 
    value = ulong2str->value;
    result = p_ultow(value, dest_wstr, ulong2str->base);
    pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
    ok(result == dest_wstr,
       "(test %d): _ultow(%u, [out], %d) has result %p, expected: %p\n",
       test_num, value, ulong2str->base, result, dest_wstr);
    ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
       "(test %d): _ultow(%u, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
       test_num, value, ulong2str->base, ansi_str.Buffer, ulong2str->Buffer);
    pRtlFreeAnsiString(&ansi_str);
}

Referenced by test_ulongtow().

p_bsearch()

static const void *static void *__cdecl * p_bsearch ( void *  , void *  , size_t  , size_t  , int(__cdecl *compar)(const void *, const void *)    )

static

Referenced by InitFunctionPtrs(), START_TEST(), and test_bsearch().

START_TEST()

START_TEST

(

string

)

Definition at line 1304 of file string.c.

{
    InitFunctionPtrs();
 
    if (p_ultoa)
        test_ulongtoa();
    if (p_ui64toa)
        test_ulonglongtoa();
    if (p_atoi64)
        test_atoi64();
    if (p_ultow)
        test_ulongtow();
    if (p_ui64tow)
        test_ulonglongtow();
    if (p_wtoi)
        test_wtoi();
    if (p_wtol)
        test_wtol();
    if (p_wtoi64)
        test_wtoi64();
    if (p_wcschr)
        test_wcschr();
    if (p_wcsrchr)
        test_wcsrchr();
    if (p_wcslwr && p_wcsupr)
        test_wcslwrupr();
    if (patoi)
        test_atoi();
    if (patol)
        test_atol();
    if (p_qsort)
        test_qsort();
    if (p_bsearch)
        test_bsearch();
    if (p__snprintf)
        test__snprintf();
}

strcomparefunc()

static int __cdecl strcomparefunc ( const void *  a, const void *  b  )

static

Definition at line 1186 of file string.c.

{
    const char * const *p = a;
    const char * const *q = b;
 
    ok (a != b, "must never get the same pointer\n");
 
    return lstrcmpA(*p, *q);
}

Referenced by test_qsort().

test__snprintf()

static void test__snprintf ( void  )

static

Definition at line 1273 of file string.c.

{
    const char *origstring = "XXXXXXXXXXXX";
    const char *teststring = "hello world";
    char buffer[32];
    int res;
 
    res = p__snprintf(NULL, 0, teststring);
    ok(res == lstrlenA(teststring) || broken(res == -1) /* <= w2k */,
       "_snprintf returned %d, expected %d.\n", res, lstrlenA(teststring));
 
    if (res != -1)
    {
        res = p__snprintf(NULL, 1, teststring);
        ok(res == lstrlenA(teststring) /* WinXP */ || res < 0 /* Vista and greater */,
           "_snprintf returned %d, expected %d or < 0.\n", res, lstrlenA(teststring));
    }
    res = p__snprintf(buffer, strlen(teststring) - 1, teststring);
    ok(res < 0, "_snprintf returned %d, expected < 0.\n", res);
 
    strcpy(buffer,  origstring);
    res = p__snprintf(buffer, strlen(teststring), teststring);
    ok(res == lstrlenA(teststring), "_snprintf returned %d, expected %d.\n", res, lstrlenA(teststring));
    ok(!strcmp(buffer, "hello worldX"), "_snprintf returned buffer '%s', expected 'hello worldX'.\n", buffer);
 
    strcpy(buffer, origstring);
    res = p__snprintf(buffer, strlen(teststring) + 1, teststring);
    ok(res == lstrlenA(teststring), "_snprintf returned %d, expected %d.\n", res, lstrlenA(teststring));
    ok(!strcmp(buffer, teststring), "_snprintf returned buffer '%s', expected '%s'.\n", buffer, teststring);
}

Referenced by START_TEST().

test_atoi()

static void test_atoi ( void  )

static

Definition at line 907 of file string.c.

{
    int test_num;
    int result;
 
    for (test_num = 0; test_num < NB_STR2LONG; test_num++) {
        result = patoi(str2long[test_num].str);
        ok(result == str2long[test_num].value,
           "(test %d): call failed: _atoi(\"%s\") has result %d, expected: %d\n",
           test_num, str2long[test_num].str, result, str2long[test_num].value);
    }
}

test_atoi64()

static void test_atoi64 ( void  )

static

Definition at line 1074 of file string.c.

{
    int test_num;
    LONGLONG result;
 
    for (test_num = 0; test_num < NB_STR2LONGLONG; test_num++) {
    result = p_atoi64(str2longlong[test_num].str);
        if (str2longlong[test_num].overflow)
            ok(result == str2longlong[test_num].value ||
               (result == ((str2longlong[test_num].overflow == -1) ?
                ULL(0x80000000,0x00000000) : ULL(0x7fffffff,0xffffffff))),
               "(test %d): call failed: _atoi64(\"%s\") has result 0x%s, expected: 0x%s\n",
               test_num, str2longlong[test_num].str, wine_dbgstr_longlong(result),
               wine_dbgstr_longlong(str2longlong[test_num].value));
        else
            ok(result == str2longlong[test_num].value,
               "(test %d): call failed: _atoi64(\"%s\") has result 0x%s, expected: 0x%s\n",
               test_num, str2longlong[test_num].str, wine_dbgstr_longlong(result),
               wine_dbgstr_longlong(str2longlong[test_num].value));
    }
}

Referenced by START_TEST().

test_atol()

static void test_atol ( void  )

static

Definition at line 920 of file string.c.

{
    int test_num;
    int result;
 
    for (test_num = 0; test_num < NB_STR2LONG; test_num++) {
        result = patol(str2long[test_num].str);
        ok(result == str2long[test_num].value,
           "(test %d): call failed: _atol(\"%s\") has result %d, expected: %d\n",
           test_num, str2long[test_num].str, result, str2long[test_num].value);
    }
}

test_bsearch()

static void test_bsearch ( void  )

static

Definition at line 1255 of file string.c.

{
    int arr[7] = { 1, 3, 4, 8, 16, 23, 42 };
    int *x, l, i, j;
 
    /* just try all array sizes */
    for (j=1;j<sizeof(arr)/sizeof(arr[0]);j++) {
        for (i=0;i<j;i++) {
            l = arr[i];
            x = p_bsearch (&l, arr, j, sizeof(arr[0]), intcomparefunc);
            ok (x == &arr[i], "bsearch did not find %d entry in loopsize %d.\n", i, j);
        }
        l = 4242;
        x = p_bsearch (&l, arr, j, sizeof(arr[0]), intcomparefunc);
        ok (x == NULL, "bsearch did find 4242 entry in loopsize %d.\n", j);
    }
}

Referenced by START_TEST().

test_qsort()

static void test_qsort ( void  )

static

Definition at line 1196 of file string.c.

{
    int arr[5] = { 23, 42, 8, 4, 16 };
    char carr[5] = { 42, 23, 4, 8, 16 };
    const char *strarr[7] = {
    "Hello",
    "Wine",
    "World",
    "!",
    "Hopefully",
    "Sorted",
    "."
    };
 
    p_qsort ((void*)arr, 0, sizeof(int), intcomparefunc);
    ok(arr[0] == 23, "badly sorted, nmemb=0, arr[0] is %d\n", arr[0]);
    ok(arr[1] == 42, "badly sorted, nmemb=0, arr[1] is %d\n", arr[1]);
    ok(arr[2] == 8,  "badly sorted, nmemb=0, arr[2] is %d\n", arr[2]);
    ok(arr[3] == 4,  "badly sorted, nmemb=0, arr[3] is %d\n", arr[3]);
    ok(arr[4] == 16, "badly sorted, nmemb=0, arr[4] is %d\n", arr[4]);
 
    p_qsort ((void*)arr, 1, sizeof(int), intcomparefunc);
    ok(arr[0] == 23, "badly sorted, nmemb=1, arr[0] is %d\n", arr[0]);
    ok(arr[1] == 42, "badly sorted, nmemb=1, arr[1] is %d\n", arr[1]);
    ok(arr[2] == 8,  "badly sorted, nmemb=1, arr[2] is %d\n", arr[2]);
    ok(arr[3] == 4,  "badly sorted, nmemb=1, arr[3] is %d\n", arr[3]);
    ok(arr[4] == 16, "badly sorted, nmemb=1, arr[4] is %d\n", arr[4]);
 
    p_qsort ((void*)arr, 5, 0, intcomparefunc);
    ok(arr[0] == 23, "badly sorted, size=0, arr[0] is %d\n", arr[0]);
    ok(arr[1] == 42, "badly sorted, size=0, arr[1] is %d\n", arr[1]);
    ok(arr[2] == 8,  "badly sorted, size=0, arr[2] is %d\n", arr[2]);
    ok(arr[3] == 4,  "badly sorted, size=0, arr[3] is %d\n", arr[3]);
    ok(arr[4] == 16, "badly sorted, size=0, arr[4] is %d\n", arr[4]);
 
    p_qsort ((void*)arr, 5, sizeof(int), intcomparefunc);
    ok(arr[0] == 4,  "badly sorted, arr[0] is %d\n", arr[0]);
    ok(arr[1] == 8,  "badly sorted, arr[1] is %d\n", arr[1]);
    ok(arr[2] == 16, "badly sorted, arr[2] is %d\n", arr[2]);
    ok(arr[3] == 23, "badly sorted, arr[3] is %d\n", arr[3]);
    ok(arr[4] == 42, "badly sorted, arr[4] is %d\n", arr[4]);
 
    p_qsort ((void*)carr, 5, sizeof(char), charcomparefunc);
    ok(carr[0] == 4,  "badly sorted, carr[0] is %d\n", carr[0]);
    ok(carr[1] == 8,  "badly sorted, carr[1] is %d\n", carr[1]);
    ok(carr[2] == 16, "badly sorted, carr[2] is %d\n", carr[2]);
    ok(carr[3] == 23, "badly sorted, carr[3] is %d\n", carr[3]);
    ok(carr[4] == 42, "badly sorted, carr[4] is %d\n", carr[4]);
 
    p_qsort ((void*)strarr, 7, sizeof(char*), strcomparefunc);
    ok(!strcmp(strarr[0],"!"),  "badly sorted, strarr[0] is %s\n", strarr[0]);
    ok(!strcmp(strarr[1],"."),  "badly sorted, strarr[1] is %s\n", strarr[1]);
    ok(!strcmp(strarr[2],"Hello"),  "badly sorted, strarr[2] is %s\n", strarr[2]);
    ok(!strcmp(strarr[3],"Hopefully"),  "badly sorted, strarr[3] is %s\n", strarr[3]);
    ok(!strcmp(strarr[4],"Sorted"),  "badly sorted, strarr[4] is %s\n", strarr[4]);
    ok(!strcmp(strarr[5],"Wine"),  "badly sorted, strarr[5] is %s\n", strarr[5]);
    ok(!strcmp(strarr[6],"World"),  "badly sorted, strarr[6] is %s\n", strarr[6]);
}

Referenced by START_TEST().

test_ulonglongtoa()

static void test_ulonglongtoa ( void  )

static

Definition at line 641 of file string.c.

{
    int test_num;
 
    for (test_num = 0; test_num < NB_ULONGLONG2STR; test_num++) {
    if (ulonglong2str[test_num].mask & 0x01) {
        one_i64toa_test(test_num, &ulonglong2str[test_num]);
    } /* if */
        if (p_ui64toa != NULL) {
        if (ulonglong2str[test_num].mask & 0x02) {
        one_ui64toa_test(test_num, &ulonglong2str[test_num]);
        } /* if */
    } /* if */
    } /* for */
}

Referenced by START_TEST().

test_ulonglongtow()

static void test_ulonglongtow ( void  )

static

Definition at line 744 of file string.c.

{
    int test_num;
    LPWSTR result;
 
    for (test_num = 0; test_num < NB_ULONGLONG2STR; test_num++) {
    if (ulonglong2str[test_num].mask & 0x10) {
        one_i64tow_test(test_num, &ulonglong2str[test_num]);
    } /* if */
    if (p_ui64tow) {
        if (ulonglong2str[test_num].mask & 0x20) {
        one_ui64tow_test(test_num, &ulonglong2str[test_num]);
        } /* if */
    } /* if */
    } /* for */
 
    if (0) {
        /* Crashes on XP and W2K3 */
        result = p_i64tow(ulonglong2str[0].value, NULL, 10);
        ok(result == NULL,
           "(test d): _i64tow(0x%s, NULL, 10) has result %p, expected: NULL\n",
           wine_dbgstr_longlong(ulonglong2str[0].value), result);
    }
 
    if (p_ui64tow) {
        if (0) {
            /* Crashes on XP and W2K3 */
        result = p_ui64tow(ulonglong2str[0].value, NULL, 10);
        ok(result == NULL,
               "(test e): _ui64tow(0x%s, NULL, 10) has result %p, expected: NULL\n",
           wine_dbgstr_longlong(ulonglong2str[0].value), result);
        }
    } /* if */
}

Referenced by START_TEST().

test_ulongtoa()

static void test_ulongtoa ( void  )

static

Definition at line 275 of file string.c.

{
    int test_num;
 
    for (test_num = 0; test_num < NB_ULONG2STR; test_num++) {
    if (ulong2str[test_num].mask & 0x01) {
        one_itoa_test(test_num, &ulong2str[test_num]);
    } /* if */
    if (ulong2str[test_num].mask & 0x02) {
        one_ltoa_test(test_num, &ulong2str[test_num]);
    } /* if */
    if (ulong2str[test_num].mask & 0x04) {
        one_ultoa_test(test_num, &ulong2str[test_num]);
    } /* if */
    } /* for */
}

Referenced by START_TEST().

test_ulongtow()

static void test_ulongtow ( void  )

static

Definition at line 400 of file string.c.

{
    int test_num;
    LPWSTR result;
 
    for (test_num = 0; test_num < NB_ULONG2STR; test_num++) {
    if (ulong2str[test_num].mask & 0x10) {
        one_itow_test(test_num, &ulong2str[test_num]);
    } /* if */
    if (ulong2str[test_num].mask & 0x20) {
        one_ltow_test(test_num, &ulong2str[test_num]);
    } /* if */
    if (ulong2str[test_num].mask & 0x40) {
        one_ultow_test(test_num, &ulong2str[test_num]);
    } /* if */
    } /* for */
 
    if (0) {
        /* Crashes on XP and W2K3 */
        result = p_itow(ulong2str[0].value, NULL, 10);
        ok(result == NULL,
           "(test a): _itow(%d, NULL, 10) has result %p, expected: NULL\n",
           ulong2str[0].value, result);
    }
 
    if (0) {
        /* Crashes on XP and W2K3 */
        result = p_ltow(ulong2str[0].value, NULL, 10);
        ok(result == NULL,
           "(test b): _ltow(%d, NULL, 10) has result %p, expected: NULL\n",
           ulong2str[0].value, result);
    }
 
    if (0) {
        /* Crashes on XP and W2K3 */
        result = p_ultow(ulong2str[0].value, NULL, 10);
        ok(result == NULL,
           "(test c): _ultow(%d, NULL, 10) has result %p, expected: NULL\n",
           ulong2str[0].value, result);
    }
}

Referenced by START_TEST().

test_wcschr()

static void test_wcschr ( void  )

static

Definition at line 1122 of file string.c.

{
    static const WCHAR teststringW[] = {'a','b','r','a','c','a','d','a','b','r','a',0};
 
    ok(p_wcschr(teststringW, 'a') == teststringW + 0,
       "wcschr should have returned a pointer to the first 'a' character\n");
    ok(p_wcschr(teststringW, 0) == teststringW + 11,
       "wcschr should have returned a pointer to the null terminator\n");
    ok(p_wcschr(teststringW, 'x') == NULL,
       "wcschr should have returned NULL\n");
}

Referenced by START_TEST().

test_wcslwrupr()

static void test_wcslwrupr ( void  )

static

Definition at line 1146 of file string.c.

{
    static WCHAR teststringW[] = {'a','b','r','a','c','a','d','a','b','r','a',0};
    static WCHAR emptyW[] = {0};
    static const WCHAR constemptyW[] = {0};
 
    if (0) /* crashes on native */
    {
        static const WCHAR conststringW[] = {'a','b','r','a','c','a','d','a','b','r','a',0};
        ok(p_wcslwr((LPWSTR)conststringW) == conststringW, "p_wcslwr returned different string\n");
        ok(p_wcsupr((LPWSTR)conststringW) == conststringW, "p_wcsupr returned different string\n");
        ok(p_wcslwr(NULL) == NULL, "p_wcslwr didn't returned NULL\n");
        ok(p_wcsupr(NULL) == NULL, "p_wcsupr didn't returned NULL\n");
    }
    ok(p_wcslwr(teststringW) == teststringW, "p_wcslwr returned different string\n");
    ok(p_wcsupr(teststringW) == teststringW, "p_wcsupr returned different string\n");
    ok(p_wcslwr(emptyW) == emptyW, "p_wcslwr returned different string\n");
    ok(p_wcsupr(emptyW) == emptyW, "p_wcsupr returned different string\n");
    ok(p_wcslwr((LPWSTR)constemptyW) == constemptyW, "p_wcslwr returned different string\n");
    ok(p_wcsupr((LPWSTR)constemptyW) == constemptyW, "p_wcsupr returned different string\n");
}

Referenced by START_TEST().

test_wcsrchr()

static void test_wcsrchr ( void  )

static

Definition at line 1134 of file string.c.

{
    static const WCHAR teststringW[] = {'a','b','r','a','c','a','d','a','b','r','a',0};
 
    ok(p_wcsrchr(teststringW, 'a') == teststringW + 10,
       "wcsrchr should have returned a pointer to the last 'a' character\n");
    ok(p_wcsrchr(teststringW, 0) == teststringW + 11,
       "wcsrchr should have returned a pointer to the null terminator\n");
    ok(p_wcsrchr(teststringW, 'x') == NULL,
       "wcsrchr should have returned NULL\n");
}

Referenced by START_TEST().

test_wtoi()

static void test_wtoi ( void  )

static

Definition at line 891 of file string.c.

{
    int test_num;
    UNICODE_STRING uni;
    int result;
 
    for (test_num = 0; test_num < NB_STR2LONG; test_num++) {
    pRtlCreateUnicodeStringFromAsciiz(&uni, str2long[test_num].str);
    result = p_wtoi(uni.Buffer);
    ok(result == str2long[test_num].value,
           "(test %d): call failed: _wtoi(\"%s\") has result %d, expected: %d\n",
       test_num, str2long[test_num].str, result, str2long[test_num].value);
    pRtlFreeUnicodeString(&uni);
    } /* for */
}

Referenced by START_TEST().

test_wtoi64()

static void test_wtoi64 ( void  )

static

Definition at line 1097 of file string.c.

{
    int test_num;
    UNICODE_STRING uni;
    LONGLONG result;
 
    for (test_num = 0; test_num < NB_STR2LONGLONG; test_num++) {
    pRtlCreateUnicodeStringFromAsciiz(&uni, str2longlong[test_num].str);
    result = p_wtoi64(uni.Buffer);
        if (str2longlong[test_num].overflow)
            ok(result == str2longlong[test_num].value ||
               (result == ((str2longlong[test_num].overflow == -1) ?
                ULL(0x80000000,0x00000000) : ULL(0x7fffffff,0xffffffff))),
               "(test %d): call failed: _atoi64(\"%s\") has result 0x%s, expected: 0x%s\n",
               test_num, str2longlong[test_num].str, wine_dbgstr_longlong(result),
               wine_dbgstr_longlong(str2longlong[test_num].value));
        else
            ok(result == str2longlong[test_num].value,
               "(test %d): call failed: _atoi64(\"%s\") has result 0x%s, expected: 0x%s\n",
               test_num, str2longlong[test_num].str, wine_dbgstr_longlong(result),
               wine_dbgstr_longlong(str2longlong[test_num].value));
    pRtlFreeUnicodeString(&uni);
    }
}

Referenced by START_TEST().

test_wtol()

static void test_wtol ( void  )

static

Definition at line 933 of file string.c.

{
    int test_num;
    UNICODE_STRING uni;
    LONG result;
 
    for (test_num = 0; test_num < NB_STR2LONG; test_num++) {
    pRtlCreateUnicodeStringFromAsciiz(&uni, str2long[test_num].str);
    result = p_wtol(uni.Buffer);
    ok(result == str2long[test_num].value,
           "(test %d): call failed: _wtol(\"%s\") has result %d, expected: %d\n",
       test_num, str2long[test_num].str, result, str2long[test_num].value);
    pRtlFreeUnicodeString(&uni);
    } /* for */
}

Referenced by START_TEST().

void()

static void ( __cdecl *  p_qsort )

static

VOID()

static VOID ( WINAPI *  pRtlFreeAnsiString )

static

Variable Documentation

BOOLEAN

const UNICODE_STRING BOOLEAN

Definition at line 31 of file string.c.

hntdll

HMODULE hntdll = 0

static

Definition at line 30 of file string.c.

Referenced by InitFunctionPtrs().

INT

INT

Definition at line 39 of file string.c.

int

int

Definition at line 48 of file string.c.

LPCSTR

LPCSTR

Definition at line 33 of file string.c.

LPSTR

LPSTR

Definition at line 39 of file string.c.

LPWSTR

LPWSTR

Definition at line 48 of file string.c.

size_t

size_t

Definition at line 60 of file string.c.

str2long

const str2long_t str2long[]

static

Definition at line 785 of file string.c.

Referenced by test_atoi(), test_atol(), test_wtoi(), and test_wtol().

str2longlong

const str2longlong_t str2longlong[]

static

Definition at line 956 of file string.c.

Referenced by test_atoi64(), and test_wtoi64().

ulong2str

const ulong2str_t ulong2str[]

static

Definition at line 116 of file string.c.

Referenced by one_itoa_test(), one_itow_test(), one_ltoa_test(), one_ltow_test(), one_ultoa_test(), one_ultow_test(), test_ulongtoa(), and test_ulongtow().

ulonglong2str

const ulonglong2str_t ulonglong2str[]

static

Definition at line 452 of file string.c.

Referenced by one_i64toa_test(), one_i64tow_test(), one_ui64toa_test(), one_ui64tow_test(), test_ulonglongtoa(), and test_ulonglongtow().

WCHAR

WCHAR

Definition at line 57 of file string.c.