rtlstr.c File Reference

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

Include dependency graph for rtlstr.c:

Go to the source code of this file.

Classes
struct	dupl_ustr_t
struct	ustr2astr_t
struct	app_asc2str_t
struct	app_str2str_t
struct	app_uni2str_t
struct	app_ustr2str_t
struct	find_ch_in_ustr_t
struct	str2int_t
struct	int2str_t
struct	hash_unicodestring_test
struct	unicode_to_utf8_test
struct	utf8_to_unicode_test

Macros
#define	INITGUID
#define	WIN32_NO_STATUS
#define	STRINGW   {'S','o','m','e',' ','W','i','l','d',' ','S','t','r','i','n','g',0}
#define	TESTSTRING2_LEN   1000000
#define	STRI_BUFFER_LENGTH   35
#define	utf8_expect(out_string, buflen, out_bytes, in_string, in_bytes, expect_status)    utf8_expect_(out_string, buflen, out_bytes, in_string, in_bytes, expect_status, __LINE__)
#define	length_expect(in_chars, out_bytes, expect_status)
#define	unicode_expect(out_string, buflen, out_chars, in_string, in_chars, expect_status)    unicode_expect_(out_string, buflen, out_chars, in_string, in_chars, expect_status, __LINE__)
#define	length_expect(in_chars, out_chars, expect_status)
#define	truncate_expect(buflen, out_chars, expect_status)

Functions
static	NTSTATUS (WINAPI *pRtlAnsiStringToUnicodeString)(PUNICODE_STRING
static int *static	LONG (WINAPI *pRtlCompareUnicodeString)(const UNICODE_STRING *
static	VOID (WINAPI *pRtlCopyString)(STRING *
static const STRING *static	BOOLEAN (WINAPI *pRtlCreateUnicodeString)(PUNICODE_STRING
static int *static	WCHAR (WINAPI *pRtlUpcaseUnicodeChar)(WCHAR)
static	CHAR (WINAPI *pRtlUpperChar)(CHAR)
static va_list ULONG *static WCHAR *	AtoW (const char *p)
static void	InitFunctionPtrs (void)
static void	test_RtlInitString (void)
static void	test_RtlInitUnicodeString (void)
static void	test_RtlInitUnicodeStringEx (void)
static void	test_RtlDuplicateUnicodeString (void)
static void	test_RtlCopyString (void)
static void	test_RtlUpperChar (void)
static void	test_RtlUpperString (void)
static void	test_RtlUpcaseUnicodeChar (void)
static void	test_RtlUpcaseUnicodeString (void)
static void	test_RtlDowncaseUnicodeString (void)
static void	test_RtlUnicodeStringToAnsiString (void)
static void	test_RtlAppendAsciizToString (void)
static void	test_RtlAppendStringToString (void)
static void	test_RtlAppendUnicodeToString (void)
static void	test_RtlAppendUnicodeStringToString (void)
static void	test_RtlFindCharInUnicodeString (void)
static void	test_RtlUnicodeStringToInteger (void)
static void	test_RtlCharToInteger (void)
static void	one_RtlIntegerToUnicodeString_test (int test_num, const int2str_t *int2str)
static void	test_RtlIntegerToUnicodeString (void)
static void	one_RtlIntegerToChar_test (int test_num, const int2str_t *int2str)
static void	test_RtlIntegerToChar (void)
static void	test_RtlIsTextUnicode (void)
static void	test_RtlCompareUnicodeString (void)
	DEFINE_GUID (IID_Endianness, 0x01020304, 0x0506, 0x0708, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x0A)
static void	test_RtlGUIDFromString (void)
static void	test_RtlStringFromGUID (void)
static void	test_RtlHashUnicodeString (void)
static void	utf8_expect_ (const unsigned char *out_string, ULONG buflen, ULONG out_bytes, const WCHAR *in_string, ULONG in_bytes, NTSTATUS expect_status, int line)
static void	test_RtlUnicodeToUTF8N (void)
static void	unicode_expect_ (const WCHAR *out_string, ULONG buflen, ULONG out_chars, const char *in_string, ULONG in_chars, NTSTATUS expect_status, int line)
static void	test_RtlUTF8ToUnicodeN (void)
static NTSTATUS WINAPIV	fmt (const WCHAR *src, ULONG width, BOOLEAN ignore_inserts, BOOLEAN ansi, WCHAR *buffer, ULONG size, ULONG *retsize,...)
static void WINAPIV	testfmt (const WCHAR *src, const WCHAR *expect, ULONG width, BOOL ansi,...)
static void	testfmt_arg_eaten (const WCHAR *src,...)
static void	test_RtlFormatMessage (void)
	START_TEST (rtlstr)

Variables
static HMODULE	hntdll = 0
static	PCANSI_STRING
static	BOOLEAN
static	LPCSTR
static const STRING *static const UNICODE_STRING *static	LPCWSTR
static	ULONG
static	SIZE_T
static	PCHAR
static UNICODE_STRING *static	LONG
static	int
static const STRING *static UNICODE_STRING *static GUID *static UNICODE_STRING *static	INT
static va_list	LPWSTR
static const dupl_ustr_t	dupl_ustr []
static const ustr2astr_t	ustr2astr []
static const app_asc2str_t	app_asc2str []
static const app_str2str_t	app_str2str []
static const app_uni2str_t	app_uni2str []
static const app_ustr2str_t	app_ustr2str []
static const find_ch_in_ustr_t	find_ch_in_ustr []
static const str2int_t	str2int []
static const int2str_t	int2str []
static const WCHAR	szGuid []
static const WCHAR	szGuid2 []
static const struct hash_unicodestring_test	hash_test []
static const struct unicode_to_utf8_test	unicode_to_utf8 []
static const struct utf8_to_unicode_test	utf8_to_unicode []

Macro Definition Documentation

INITGUID

#define INITGUID

Definition at line 28 of file rtlstr.c.

length_expect [1/2]

#define length_expect	(		in_chars,
			out_bytes,
			expect_status
	)

Value:

        utf8_expect_(NULL, 0, out_bytes, \
                     special_string, in_chars * sizeof(WCHAR), \
                     expect_status, __LINE__)

length_expect [2/2]

#define length_expect	(		in_chars,
			out_chars,
			expect_status
	)

Value:

        unicode_expect_(NULL, 0, out_chars, special_string, in_chars, \
                        expect_status, __LINE__)

STRI_BUFFER_LENGTH

#define STRI_BUFFER_LENGTH   35

Definition at line 1522 of file rtlstr.c.

STRINGW

#define STRINGW   {'S','o','m','e',' ','W','i','l','d',' ','S','t','r','i','n','g',0}

TESTSTRING2_LEN

#define TESTSTRING2_LEN   1000000

Definition at line 200 of file rtlstr.c.

truncate_expect

#define truncate_expect	(		buflen,
			out_chars,
			expect_status
	)

Value:

        unicode_expect_(special_expected, buflen, out_chars, \
                        special_string, sizeof(special_string), \
                        expect_status, __LINE__)

unicode_expect

#define unicode_expect	(		out_string,
			buflen,
			out_chars,
			in_string,
			in_chars,
			expect_status
	)		unicode_expect_(out_string, buflen, out_chars, in_string, in_chars, expect_status, __LINE__)

Definition at line 2454 of file rtlstr.c.

utf8_expect

#define utf8_expect	(		out_string,
			buflen,
			out_bytes,
			in_string,
			in_bytes,
			expect_status
	)		utf8_expect_(out_string, buflen, out_bytes, in_string, in_bytes, expect_status, __LINE__)

Definition at line 2121 of file rtlstr.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 31 of file rtlstr.c.

Function Documentation

AtoW()

static va_list ULONG *static WCHAR * AtoW ( const char *  p )

static

Definition at line 99 of file rtlstr.c.

{
    WCHAR* buffer;
    DWORD len = MultiByteToWideChar( CP_ACP, 0, p, -1, NULL, 0 );
    buffer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR) );
    MultiByteToWideChar( CP_ACP, 0, p, -1, buffer, len );
    return buffer;
}

Referenced by test_RtlUnicodeStringToInteger().

BOOLEAN()

static const STRING *static BOOLEAN ( WINAPI *  pRtlCreateUnicodeString )

static

CHAR()

static CHAR ( WINAPI *  pRtlUpperChar )

static

DEFINE_GUID()

DEFINE_GUID	(	IID_Endianness	,
		0x01020304	,
		0x0506	,
		0x0708	,
		0x09	,
		0x0A	,
		0x0B	,
		0x0C	,
		0x0D	,
		0x0E	,
		0x0F	,
		0x0A
	)

fmt()

static NTSTATUS WINAPIV fmt ( const WCHAR *  src, ULONG  width, BOOLEAN  ignore_inserts, BOOLEAN  ansi, WCHAR *  buffer, ULONG  size, ULONG *  retsize,   ...  )

static

Definition at line 2640 of file rtlstr.c.

{
    va_list args;
    NTSTATUS status;
 
    *retsize = 0xdeadbeef;
    va_start( args, retsize );
    status = pRtlFormatMessage( src, width, ignore_inserts, ansi, FALSE, &args, buffer, size, retsize );
    va_end( args );
    return status;
}

InitFunctionPtrs()

static void InitFunctionPtrs ( void  )

static

Definition at line 109 of file rtlstr.c.

{
    hntdll = LoadLibraryA("ntdll.dll");
    ok(hntdll != 0, "LoadLibrary failed\n");
    if (hntdll) {
    pRtlAnsiStringToUnicodeString = (void *)GetProcAddress(hntdll, "RtlAnsiStringToUnicodeString");
    pRtlAppendAsciizToString = (void *)GetProcAddress(hntdll, "RtlAppendAsciizToString");
    pRtlAppendStringToString = (void *)GetProcAddress(hntdll, "RtlAppendStringToString");
    pRtlAppendUnicodeStringToString = (void *)GetProcAddress(hntdll, "RtlAppendUnicodeStringToString");
    pRtlAppendUnicodeToString = (void *)GetProcAddress(hntdll, "RtlAppendUnicodeToString");
    pRtlCharToInteger = (void *)GetProcAddress(hntdll, "RtlCharToInteger");
    pRtlCompareUnicodeString = (void *)GetProcAddress(hntdll, "RtlCompareUnicodeString");
    pRtlCompareUnicodeStrings = (void *)GetProcAddress(hntdll, "RtlCompareUnicodeStrings");
    pRtlCopyString = (void *)GetProcAddress(hntdll, "RtlCopyString");
    pRtlCreateUnicodeString = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeString");
    pRtlCreateUnicodeStringFromAsciiz = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeStringFromAsciiz");
    pRtlDowncaseUnicodeString = (void *)GetProcAddress(hntdll, "RtlDowncaseUnicodeString");
    pRtlDuplicateUnicodeString = (void *)GetProcAddress(hntdll, "RtlDuplicateUnicodeString");
    pRtlEqualUnicodeString = (void *)GetProcAddress(hntdll, "RtlEqualUnicodeString");
    pRtlFindCharInUnicodeString = (void *)GetProcAddress(hntdll, "RtlFindCharInUnicodeString");
    pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString");
    pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
    pRtlInitAnsiString = (void *)GetProcAddress(hntdll, "RtlInitAnsiString");
    pRtlInitString = (void *)GetProcAddress(hntdll, "RtlInitString");
    pRtlInitUnicodeString = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString");
    pRtlInitUnicodeStringEx = (void *)GetProcAddress(hntdll, "RtlInitUnicodeStringEx");
    pRtlIntegerToChar = (void *)GetProcAddress(hntdll, "RtlIntegerToChar");
    pRtlIntegerToUnicodeString = (void *)GetProcAddress(hntdll, "RtlIntegerToUnicodeString");
    pRtlMultiAppendUnicodeStringBuffer = (void *)GetProcAddress(hntdll, "RtlMultiAppendUnicodeStringBuffer");
    pRtlUnicodeStringToAnsiString = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToAnsiString");
    pRtlUnicodeStringToInteger = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToInteger");
    pRtlUpcaseUnicodeChar = (void *)GetProcAddress(hntdll, "RtlUpcaseUnicodeChar");
    pRtlUpcaseUnicodeString = (void *)GetProcAddress(hntdll, "RtlUpcaseUnicodeString");
    pRtlUpperChar = (void *)GetProcAddress(hntdll, "RtlUpperChar");
    pRtlUpperString = (void *)GetProcAddress(hntdll, "RtlUpperString");
    pRtlValidateUnicodeString = (void *)GetProcAddress(hntdll, "RtlValidateUnicodeString");
    pRtlGUIDFromString = (void *)GetProcAddress(hntdll, "RtlGUIDFromString");
    pRtlStringFromGUID = (void *)GetProcAddress(hntdll, "RtlStringFromGUID");
    pRtlIsTextUnicode = (void *)GetProcAddress(hntdll, "RtlIsTextUnicode");
        pRtlHashUnicodeString = (void*)GetProcAddress(hntdll, "RtlHashUnicodeString");
        pRtlUnicodeToUTF8N = (void*)GetProcAddress(hntdll, "RtlUnicodeToUTF8N");
        pRtlUTF8ToUnicodeN = (void*)GetProcAddress(hntdll, "RtlUTF8ToUnicodeN");
        pRtlFormatMessage = (void*)GetProcAddress(hntdll, "RtlFormatMessage");
    }
}

Referenced by START_TEST().

LONG()

static int *static LONG ( WINAPI *  pRtlCompareUnicodeString ) const

static

NTSTATUS()

static NTSTATUS ( WINAPI *  pRtlAnsiStringToUnicodeString )

static

one_RtlIntegerToChar_test()

static void one_RtlIntegerToChar_test ( int  test_num, const int2str_t *  int2str  )

static

Definition at line 1717 of file rtlstr.c.

{
    NTSTATUS result;
    char dest_str[STRI_BUFFER_LENGTH + 1];
 
    memset(dest_str, '-', STRI_BUFFER_LENGTH);
    dest_str[STRI_BUFFER_LENGTH] = '\0';
    result = pRtlIntegerToChar(int2str->value, int2str->base, int2str->MaximumLength, dest_str);
    ok(result == int2str->result,
       "(test %d): RtlIntegerToChar(%lu, %d, %d, [out]) has result %lx, expected: %lx\n",
       test_num, int2str->value, int2str->base, int2str->MaximumLength, result, int2str->result);
    ok(memcmp(dest_str, int2str->Buffer, STRI_BUFFER_LENGTH) == 0,
       "(test %d): RtlIntegerToChar(%lu, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
       test_num, int2str->value, int2str->base, int2str->MaximumLength, dest_str, int2str->Buffer);
}

Referenced by test_RtlIntegerToChar().

one_RtlIntegerToUnicodeString_test()

static void one_RtlIntegerToUnicodeString_test ( int  test_num, const int2str_t *  int2str  )

static

Definition at line 1641 of file rtlstr.c.

{
    int pos;
    WCHAR expected_str_Buffer[STRI_BUFFER_LENGTH + 1];
    UNICODE_STRING expected_unicode_string;
    STRING expected_ansi_str;
    WCHAR str_Buffer[STRI_BUFFER_LENGTH + 1];
    UNICODE_STRING unicode_string;
    STRING ansi_str;
    NTSTATUS result;
 
    for (pos = 0; pos < STRI_BUFFER_LENGTH; pos++) {
    expected_str_Buffer[pos] = int2str->Buffer[pos];
    }
    expected_unicode_string.Length = int2str->Length * sizeof(WCHAR);
    expected_unicode_string.MaximumLength = int2str->MaximumLength * sizeof(WCHAR);
    expected_unicode_string.Buffer = expected_str_Buffer;
    pRtlUnicodeStringToAnsiString(&expected_ansi_str, &expected_unicode_string, 1);
 
    for (pos = 0; pos < STRI_BUFFER_LENGTH; pos++) {
    str_Buffer[pos] = '-';
    }
    unicode_string.Length = 0;
    unicode_string.MaximumLength = int2str->MaximumLength * sizeof(WCHAR);
    unicode_string.Buffer = str_Buffer;
 
    result = pRtlIntegerToUnicodeString(int2str->value, int2str->base, &unicode_string);
    pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
    if (result == STATUS_BUFFER_OVERFLOW) {
    /* On BUFFER_OVERFLOW the string Buffer should be unchanged */
    for (pos = 0; pos < STRI_BUFFER_LENGTH; pos++) {
        expected_str_Buffer[pos] = '-';
    }
    /* 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 > 32 && unicode_string.Length == 0) {
        /* The value is too large to convert only triggered when testing native */
        expected_unicode_string.Length = 0;
    }
    } else {
    ok(result == int2str->result,
           "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) has result %lx, expected: %lx\n",
       test_num, int2str->value, int2str->base, result, int2str->result);
    if (result == STATUS_SUCCESS) {
        ok(unicode_string.Buffer[unicode_string.Length/sizeof(WCHAR)] == '\0',
               "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) string \"%s\" is not NULL terminated\n",
           test_num, int2str->value, int2str->base, ansi_str.Buffer);
    }
    }
    ok(memcmp(unicode_string.Buffer, expected_unicode_string.Buffer, STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
       "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
       test_num, int2str->value, int2str->base, ansi_str.Buffer, expected_ansi_str.Buffer);
    ok(unicode_string.Length == expected_unicode_string.Length ||
       broken(int2str->broken_len && !unicode_string.Length) /* win11 */,
       "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) string has Length %d, expected: %d\n",
       test_num, int2str->value, int2str->base, unicode_string.Length, expected_unicode_string.Length);
    ok(unicode_string.MaximumLength == expected_unicode_string.MaximumLength,
       "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) string has MaximumLength %d, expected: %d\n",
       test_num, int2str->value, int2str->base, unicode_string.MaximumLength, expected_unicode_string.MaximumLength);
    pRtlFreeAnsiString(&expected_ansi_str);
    pRtlFreeAnsiString(&ansi_str);
}

Referenced by test_RtlIntegerToUnicodeString().

START_TEST()

START_TEST

(

rtlstr

)

Definition at line 2948 of file rtlstr.c.

{
    InitFunctionPtrs();
    if (pRtlInitAnsiString) {
    test_RtlInitString();
    test_RtlInitUnicodeString();
    test_RtlCopyString();
    test_RtlUnicodeStringToInteger();
    test_RtlCharToInteger();
    test_RtlIntegerToUnicodeString();
    test_RtlIntegerToChar();
    test_RtlUpperChar();
    test_RtlUpperString();
    test_RtlUnicodeStringToAnsiString();
    test_RtlAppendAsciizToString();
    test_RtlAppendStringToString();
    test_RtlAppendUnicodeToString();
    test_RtlAppendUnicodeStringToString();
    }
 
    test_RtlInitUnicodeStringEx();
    test_RtlDuplicateUnicodeString();
    test_RtlFindCharInUnicodeString();
    test_RtlGUIDFromString();
    test_RtlStringFromGUID();
    test_RtlIsTextUnicode();
    test_RtlCompareUnicodeString();
    test_RtlUpcaseUnicodeChar();
    test_RtlUpcaseUnicodeString();
    test_RtlDowncaseUnicodeString();
    test_RtlHashUnicodeString();
    test_RtlUnicodeToUTF8N();
    test_RtlUTF8ToUnicodeN();
    test_RtlFormatMessage();
}

test_RtlAppendAsciizToString()

static void test_RtlAppendAsciizToString ( void  )

static

Definition at line 898 of file rtlstr.c.

{
    CHAR dest_buf[257];
    STRING dest_str;
    NTSTATUS result;
    unsigned int test_num;
 
    for (test_num = 0; test_num < ARRAY_SIZE(app_asc2str); test_num++) {
    dest_str.Length        = app_asc2str[test_num].dest_Length;
    dest_str.MaximumLength = app_asc2str[test_num].dest_MaximumLength;
    if (app_asc2str[test_num].dest_buf != NULL) {
        memcpy(dest_buf, app_asc2str[test_num].dest_buf, app_asc2str[test_num].dest_buf_size);
        dest_buf[app_asc2str[test_num].dest_buf_size] = '\0';
        dest_str.Buffer = dest_buf;
    } else {
        dest_str.Buffer = NULL;
    }
    result = pRtlAppendAsciizToString(&dest_str, app_asc2str[test_num].src);
    ok(result == app_asc2str[test_num].result,
           "(test %d): RtlAppendAsciizToString(dest, src) has result %lx, expected %lx\n",
       test_num, result, app_asc2str[test_num].result);
    ok(dest_str.Length == app_asc2str[test_num].res_Length,
       "(test %d): RtlAppendAsciizToString(dest, src) dest has Length %d, expected %d\n",
       test_num, dest_str.Length, app_asc2str[test_num].res_Length);
    ok(dest_str.MaximumLength == app_asc2str[test_num].res_MaximumLength,
       "(test %d): RtlAppendAsciizToString(dest, src) dest has MaximumLength %d, expected %d\n",
       test_num, dest_str.MaximumLength, app_asc2str[test_num].res_MaximumLength);
    if (dest_str.Buffer == dest_buf) {
        ok(memcmp(dest_buf, app_asc2str[test_num].res_buf, app_asc2str[test_num].res_buf_size) == 0,
           "(test %d): RtlAppendAsciizToString(dest, src) has dest \"%s\" expected \"%s\"\n",
           test_num, dest_buf, app_asc2str[test_num].res_buf);
    } else {
        ok(dest_str.Buffer == app_asc2str[test_num].res_buf,
           "(test %d): RtlAppendAsciizToString(dest, src) dest has Buffer %p expected %p\n",
           test_num, dest_str.Buffer, app_asc2str[test_num].res_buf);
    }
    }
}

Referenced by START_TEST().

test_RtlAppendStringToString()

static void test_RtlAppendStringToString ( void  )

static

Definition at line 967 of file rtlstr.c.

{
    CHAR dest_buf[257];
    CHAR src_buf[257];
    STRING dest_str;
    STRING src_str;
    NTSTATUS result;
    unsigned int test_num;
 
    for (test_num = 0; test_num < ARRAY_SIZE(app_str2str); test_num++) {
    dest_str.Length        = app_str2str[test_num].dest_Length;
    dest_str.MaximumLength = app_str2str[test_num].dest_MaximumLength;
    if (app_str2str[test_num].dest_buf != NULL) {
        memcpy(dest_buf, app_str2str[test_num].dest_buf, app_str2str[test_num].dest_buf_size);
        dest_buf[app_str2str[test_num].dest_buf_size] = '\0';
        dest_str.Buffer = dest_buf;
    } else {
        dest_str.Buffer = NULL;
    }
    src_str.Length         = app_str2str[test_num].src_Length;
    src_str.MaximumLength  = app_str2str[test_num].src_MaximumLength;
    if (app_str2str[test_num].src_buf != NULL) {
        memcpy(src_buf, app_str2str[test_num].src_buf, app_str2str[test_num].src_buf_size);
        src_buf[app_str2str[test_num].src_buf_size] = '\0';
        src_str.Buffer = src_buf;
    } else {
        src_str.Buffer = NULL;
    }
    result = pRtlAppendStringToString(&dest_str, &src_str);
    ok(result == app_str2str[test_num].result,
           "(test %d): RtlAppendStringToString(dest, src) has result %lx, expected %lx\n",
       test_num, result, app_str2str[test_num].result);
    ok(dest_str.Length == app_str2str[test_num].res_Length,
       "(test %d): RtlAppendStringToString(dest, src) dest has Length %d, expected %d\n",
       test_num, dest_str.Length, app_str2str[test_num].res_Length);
    ok(dest_str.MaximumLength == app_str2str[test_num].res_MaximumLength,
       "(test %d): RtlAppendStringToString(dest, src) dest has MaximumLength %d, expected %d\n",
       test_num, dest_str.MaximumLength, app_str2str[test_num].res_MaximumLength);
    if (dest_str.Buffer == dest_buf) {
        ok(memcmp(dest_buf, app_str2str[test_num].res_buf, app_str2str[test_num].res_buf_size) == 0,
           "(test %d): RtlAppendStringToString(dest, src) has dest \"%s\" expected \"%s\"\n",
           test_num, dest_buf, app_str2str[test_num].res_buf);
    } else {
        ok(dest_str.Buffer == app_str2str[test_num].res_buf,
           "(test %d): RtlAppendStringToString(dest, src) dest has Buffer %p expected %p\n",
           test_num, dest_str.Buffer, app_str2str[test_num].res_buf);
    }
    }
}

Referenced by START_TEST().

test_RtlAppendUnicodeStringToString()

static void test_RtlAppendUnicodeStringToString ( void  )

static

Definition at line 1122 of file rtlstr.c.

{
    WCHAR dest_buf[257];
    WCHAR src_buf[257];
    UNICODE_STRING dest_str;
    UNICODE_STRING src_str;
    NTSTATUS result;
    unsigned int test_num;
 
    for (test_num = 0; test_num < ARRAY_SIZE(app_ustr2str); test_num++) {
    dest_str.Length        = app_ustr2str[test_num].dest_Length;
    dest_str.MaximumLength = app_ustr2str[test_num].dest_MaximumLength;
    if (app_ustr2str[test_num].dest_buf != NULL) {
        memcpy(dest_buf, app_ustr2str[test_num].dest_buf, app_ustr2str[test_num].dest_buf_size);
        dest_buf[app_ustr2str[test_num].dest_buf_size/sizeof(WCHAR)] = '\0';
        dest_str.Buffer = dest_buf;
    } else {
        dest_str.Buffer = NULL;
    }
    src_str.Length         = app_ustr2str[test_num].src_Length;
    src_str.MaximumLength  = app_ustr2str[test_num].src_MaximumLength;
    if (app_ustr2str[test_num].src_buf != NULL) {
        memcpy(src_buf, app_ustr2str[test_num].src_buf, app_ustr2str[test_num].src_buf_size);
        src_buf[app_ustr2str[test_num].src_buf_size/sizeof(WCHAR)] = '\0';
        src_str.Buffer = src_buf;
    } else {
        src_str.Buffer = NULL;
    }
    result = pRtlAppendUnicodeStringToString(&dest_str, &src_str);
    ok(result == app_ustr2str[test_num].result,
           "(test %d): RtlAppendStringToString(dest, src) has result %lx, expected %lx\n",
       test_num, result, app_ustr2str[test_num].result);
    ok(dest_str.Length == app_ustr2str[test_num].res_Length,
       "(test %d): RtlAppendStringToString(dest, src) dest has Length %d, expected %d\n",
       test_num, dest_str.Length, app_ustr2str[test_num].res_Length);
    ok(dest_str.MaximumLength == app_ustr2str[test_num].res_MaximumLength,
       "(test %d): RtlAppendStringToString(dest, src) dest has MaximumLength %d, expected %d\n",
       test_num, dest_str.MaximumLength, app_ustr2str[test_num].res_MaximumLength);
    if (dest_str.Buffer == dest_buf) {
        ok(memcmp(dest_buf, app_ustr2str[test_num].res_buf, app_ustr2str[test_num].res_buf_size) == 0,
           "(test %d): RtlAppendStringToString(dest, src) has dest \"%s\" expected \"%s\"\n",
           test_num, (char *) dest_buf, app_ustr2str[test_num].res_buf);
    } else {
        ok(dest_str.Buffer == (WCHAR *) app_ustr2str[test_num].res_buf,
           "(test %d): RtlAppendStringToString(dest, src) dest has Buffer %p expected %p\n",
           test_num, dest_str.Buffer, app_ustr2str[test_num].res_buf);
    }
    }
}

Referenced by START_TEST().

test_RtlAppendUnicodeToString()

static void test_RtlAppendUnicodeToString ( void  )

static

Definition at line 1049 of file rtlstr.c.

{
    WCHAR dest_buf[257];
    UNICODE_STRING dest_str;
    NTSTATUS result;
    unsigned int test_num;
 
    for (test_num = 0; test_num < ARRAY_SIZE(app_uni2str); test_num++) {
    dest_str.Length        = app_uni2str[test_num].dest_Length;
    dest_str.MaximumLength = app_uni2str[test_num].dest_MaximumLength;
    if (app_uni2str[test_num].dest_buf != NULL) {
        memcpy(dest_buf, app_uni2str[test_num].dest_buf, app_uni2str[test_num].dest_buf_size);
        dest_buf[app_uni2str[test_num].dest_buf_size/sizeof(WCHAR)] = '\0';
        dest_str.Buffer = dest_buf;
    } else {
        dest_str.Buffer = NULL;
    }
    result = pRtlAppendUnicodeToString(&dest_str, (LPCWSTR) app_uni2str[test_num].src);
    ok(result == app_uni2str[test_num].result,
           "(test %d): RtlAppendUnicodeToString(dest, src) has result %lx, expected %lx\n",
       test_num, result, app_uni2str[test_num].result);
    ok(dest_str.Length == app_uni2str[test_num].res_Length,
       "(test %d): RtlAppendUnicodeToString(dest, src) dest has Length %d, expected %d\n",
       test_num, dest_str.Length, app_uni2str[test_num].res_Length);
    ok(dest_str.MaximumLength == app_uni2str[test_num].res_MaximumLength,
       "(test %d): RtlAppendUnicodeToString(dest, src) dest has MaximumLength %d, expected %d\n",
       test_num, dest_str.MaximumLength, app_uni2str[test_num].res_MaximumLength);
    if (dest_str.Buffer == dest_buf) {
        ok(memcmp(dest_buf, app_uni2str[test_num].res_buf, app_uni2str[test_num].res_buf_size) == 0,
           "(test %d): RtlAppendUnicodeToString(dest, src) has dest \"%s\" expected \"%s\"\n",
           test_num, (char *) dest_buf, app_uni2str[test_num].res_buf);
    } else {
        ok(dest_str.Buffer == (WCHAR *) app_uni2str[test_num].res_buf,
           "(test %d): RtlAppendUnicodeToString(dest, src) dest has Buffer %p expected %p\n",
           test_num, dest_str.Buffer, app_uni2str[test_num].res_buf);
    }
    }
}

Referenced by START_TEST().

test_RtlCharToInteger()

static void test_RtlCharToInteger ( void  )

static

Definition at line 1483 of file rtlstr.c.

{
    unsigned int test_num;
    int value;
    NTSTATUS result;
 
    for (test_num = 0; test_num < ARRAY_SIZE(str2int); test_num++) {
    /* w2k skips a leading '\0' and processes the string after */
    if (str2int[test_num].str[0] != '\0') {
        value = 0xdeadbeef;
        result = pRtlCharToInteger(str2int[test_num].str, str2int[test_num].base, &value);
        ok(result == str2int[test_num].result ||
               (str2int[test_num].alternative && result == str2int[test_num].alternative),
               "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) has result %lx, expected: %lx (%lx)\n",
           test_num, str2int[test_num].str, str2int[test_num].base, result,
               str2int[test_num].result, str2int[test_num].alternative);
            if (result == STATUS_SUCCESS)
                ok(value == str2int[test_num].value,
                   "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d\n",
                   test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value);
            else
                ok(value == 0 || value == 0xdeadbeef,
                   "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) assigns value %d, expected 0 or deadbeef\n",
                   test_num, str2int[test_num].str, str2int[test_num].base, value);
    }
    }
 
    result = pRtlCharToInteger(str2int[1].str, str2int[1].base, NULL);
    ok(result == STATUS_ACCESS_VIOLATION,
       "call failed: RtlCharToInteger(\"%s\", %d, NULL) has result %lx\n",
       str2int[1].str, str2int[1].base, result);
 
    result = pRtlCharToInteger(str2int[1].str, 20, NULL);
    ok(result == STATUS_INVALID_PARAMETER,
       "call failed: RtlCharToInteger(\"%s\", 20, NULL) has result %lx\n",
       str2int[1].str, result);
}

Referenced by START_TEST().

test_RtlCompareUnicodeString()

static void test_RtlCompareUnicodeString ( void  )

static

Definition at line 1898 of file rtlstr.c.

{
    WCHAR ch1, ch2;
    UNICODE_STRING str1, str2;
 
    str1.Buffer = &ch1;
    str1.Length = str1.MaximumLength = sizeof(WCHAR);
    str2.Buffer = &ch2;
    str2.Length = str2.MaximumLength = sizeof(WCHAR);
    for (ch1 = 0; ch1 < 512; ch1++)
    {
        for (ch2 = 0; ch2 < 1024; ch2++)
        {
            LONG res = pRtlCompareUnicodeString( &str1, &str2, FALSE );
            ok( res == (ch1 - ch2), "wrong result %ld %04x %04x\n", res, ch1, ch2 );
            res = pRtlCompareUnicodeString( &str1, &str2, TRUE );
            ok( res == (pRtlUpcaseUnicodeChar(ch1) - pRtlUpcaseUnicodeChar(ch2)),
                "wrong result %ld %04x %04x\n", res, ch1, ch2 );
            if (pRtlCompareUnicodeStrings)
            {
                res = pRtlCompareUnicodeStrings( &ch1, 1, &ch2, 1, FALSE );
                ok( res == (ch1 - ch2), "wrong result %ld %04x %04x\n", res, ch1, ch2 );
                res = pRtlCompareUnicodeStrings( &ch1, 1, &ch2, 1, TRUE );
                ok( res == (pRtlUpcaseUnicodeChar(ch1) - pRtlUpcaseUnicodeChar(ch2)),
                    "wrong result %ld %04x %04x\n", res, ch1, ch2 );
            }
        }
    }
}

Referenced by START_TEST().

test_RtlCopyString()

static void test_RtlCopyString ( void  )

static

Definition at line 508 of file rtlstr.c.

{
    static const char teststring[] = "Some Wild String";
    char deststring[] = "                    ";
    STRING str;
    STRING deststr;
 
    pRtlInitString(&str, teststring);
    pRtlInitString(&deststr, deststring);
    pRtlCopyString(&deststr, &str);
    ok(strncmp(str.Buffer, deststring, str.Length) == 0, "String not copied\n");
}

Referenced by START_TEST().

test_RtlDowncaseUnicodeString()

static void test_RtlDowncaseUnicodeString ( void  )

static

Definition at line 682 of file rtlstr.c.

{
    int i;
    WCHAR ch;
    WCHAR lower_ch;
    WCHAR source_buf[1025];
    WCHAR result_buf[1025];
    WCHAR lower_buf[1025];
    UNICODE_STRING source_str;
    UNICODE_STRING result_str;
    UNICODE_STRING lower_str;
 
    for (i = 0; i < 1024; i++) {
    ch = (WCHAR) i;
    if (ch >= 'A' && ch <= 'Z') {
        lower_ch = ch - 'A' + 'a';
    } else if (ch >= 0xc0 && ch <= 0xde && ch != 0xd7) {
        lower_ch = ch + 0x20;
    } else if (ch >= 0x391 && ch <= 0x3ab && ch != 0x3a2) {
        lower_ch = ch + 0x20;
    } else {
        switch (ch) {
        case 0x178: lower_ch = 0xff; break;
        case 0x181: lower_ch = 0x253; break;
        case 0x186: lower_ch = 0x254; break;
        case 0x189: lower_ch = 0x256; break;
        case 0x18a: lower_ch = 0x257; break;
        case 0x18e: lower_ch = 0x1dd; break;
        case 0x18f: lower_ch = 0x259; break;
        case 0x190: lower_ch = 0x25b; break;
        case 0x193: lower_ch = 0x260; break;
        case 0x194: lower_ch = 0x263; break;
        case 0x196: lower_ch = 0x269; break;
        case 0x197: lower_ch = 0x268; break;
        case 0x19c: lower_ch = 0x26f; break;
        case 0x19d: lower_ch = 0x272; break;
        case 0x19f: lower_ch = 0x275; break;
        case 0x1a9: lower_ch = 0x283; break;
        case 0x1a6: lower_ch = 0x280; break;
        case 0x1ae: lower_ch = 0x288; break;
        case 0x1b1: lower_ch = 0x28a; break;
        case 0x1b2: lower_ch = 0x28b; break;
        case 0x1b7: lower_ch = 0x292; break;
        case 0x1c4: lower_ch = 0x1c6; break;
        case 0x1c7: lower_ch = 0x1c9; break;
        case 0x1ca: lower_ch = 0x1cc; break;
        case 0x1f1: lower_ch = 0x1f3; break;
        case 0x1f6: lower_ch = 0x195; break;
        case 0x1f7: lower_ch = 0x1bf; break;
        case 0x220: lower_ch = 0x19e; break;
        case 0x23a: lower_ch = 0x2c65; break;
        case 0x23d: lower_ch = 0x19a; break;
        case 0x23e: lower_ch = 0x2c66; break;
        case 0x243: lower_ch = 0x180; break;
        case 0x244: lower_ch = 0x289; break;
        case 0x245: lower_ch = 0x28c; break;
        case 0x37f: lower_ch = 0x3f3; break;
        case 0x386: lower_ch = 0x3ac; break;
        case 0x388: lower_ch = 0x3ad; break;
        case 0x389: lower_ch = 0x3ae; break;
        case 0x38a: lower_ch = 0x3af; break;
        case 0x38c: lower_ch = 0x3cc; break;
        case 0x38e: lower_ch = 0x3cd; break;
        case 0x38f: lower_ch = 0x3ce; break;
        case 0x3cf: lower_ch = 0x3d7; break;
        case 0x3f9: lower_ch = 0x3f2; break;
        case 0x3fd: lower_ch = 0x37b; break;
        case 0x3fe: lower_ch = 0x37c; break;
        case 0x3ff: lower_ch = 0x37d; break;
        default: lower_ch = ch; break;
        } /* switch */
    }
    source_buf[i] = ch;
    result_buf[i] = '\0';
    lower_buf[i] = lower_ch;
    }
    source_buf[i] = '\0';
    result_buf[i] = '\0';
    lower_buf[i] = '\0';
    source_str.Length = 2048;
    source_str.MaximumLength = 2048;
    source_str.Buffer = source_buf;
    result_str.Length = 2048;
    result_str.MaximumLength = 2048;
    result_str.Buffer = result_buf;
    lower_str.Length = 2048;
    lower_str.MaximumLength = 2048;
    lower_str.Buffer = lower_buf;
 
    pRtlDowncaseUnicodeString(&result_str, &source_str, 0);
    for (i = 0; i <= 1024; i++) {
    ok(result_str.Buffer[i] == lower_str.Buffer[i] || result_str.Buffer[i] == source_str.Buffer[i] + 1 ||
           broken( result_str.Buffer[i] == source_str.Buffer[i] ),
       "RtlDowncaseUnicodeString works wrong: '%c'[=0x%x] is converted to '%c'[=0x%x], expected: '%c'[=0x%x]\n",
       source_str.Buffer[i], source_str.Buffer[i],
       result_str.Buffer[i], result_str.Buffer[i],
       lower_str.Buffer[i], lower_str.Buffer[i]);
    }
}

Referenced by START_TEST().

test_RtlDuplicateUnicodeString()

static void test_RtlDuplicateUnicodeString ( void  )

static

Definition at line 416 of file rtlstr.c.

{
    size_t pos;
    WCHAR source_buf[257];
    WCHAR dest_buf[257];
    WCHAR res_buf[257];
    UNICODE_STRING source_str;
    UNICODE_STRING dest_str;
    UNICODE_STRING res_str;
    CHAR dest_ansi_buf[257];
    STRING dest_ansi_str;
    NTSTATUS result;
    unsigned int test_num;
 
    if (!pRtlDuplicateUnicodeString)
    {
        win_skip("RtlDuplicateUnicodeString is not available\n");
        return;
    }
 
    for (test_num = 0; test_num < ARRAY_SIZE(dupl_ustr); test_num++) {
    source_str.Length        = dupl_ustr[test_num].source_Length;
    source_str.MaximumLength = dupl_ustr[test_num].source_MaximumLength;
    if (dupl_ustr[test_num].source_buf != NULL) {
        for (pos = 0; pos < dupl_ustr[test_num].source_buf_size/sizeof(WCHAR); pos++) {
        source_buf[pos] = dupl_ustr[test_num].source_buf[pos];
        }
        source_str.Buffer = source_buf;
    } else {
        source_str.Buffer = NULL;
    }
    dest_str.Length        = dupl_ustr[test_num].dest_Length;
    dest_str.MaximumLength = dupl_ustr[test_num].dest_MaximumLength;
    if (dupl_ustr[test_num].dest_buf != NULL) {
        for (pos = 0; pos < dupl_ustr[test_num].dest_buf_size/sizeof(WCHAR); pos++) {
        dest_buf[pos] = dupl_ustr[test_num].dest_buf[pos];
        }
        dest_str.Buffer = dest_buf;
    } else {
        dest_str.Buffer = NULL;
    }
    res_str.Length        = dupl_ustr[test_num].res_Length;
    res_str.MaximumLength = dupl_ustr[test_num].res_MaximumLength;
    if (dupl_ustr[test_num].res_buf != NULL) {
        for (pos = 0; pos < dupl_ustr[test_num].res_buf_size/sizeof(WCHAR); pos++) {
        res_buf[pos] = dupl_ustr[test_num].res_buf[pos];
        }
        res_str.Buffer = res_buf;
    } else {
        res_str.Buffer = NULL;
    }
    result = pRtlDuplicateUnicodeString(dupl_ustr[test_num].add_nul, &source_str, &dest_str);
        dest_ansi_str.Length = dest_str.Length / sizeof(WCHAR);
        dest_ansi_str.MaximumLength = dest_ansi_str.Length + 1;
        for (pos = 0; pos < dest_ansi_str.Length; pos++) {
            dest_ansi_buf[pos] = (char)dest_buf[pos];
        }
        dest_ansi_buf[dest_ansi_str.Length] = '\0';
        dest_ansi_str.Buffer = dest_ansi_buf;
    ok(result == dupl_ustr[test_num].result,
           "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has result %lx, expected %lx\n",
       test_num, dupl_ustr[test_num].add_nul, result, dupl_ustr[test_num].result);
    ok(dest_str.Length == dupl_ustr[test_num].res_Length,
       "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination has Length %d, expected %d\n",
       test_num, dupl_ustr[test_num].add_nul, dest_str.Length, dupl_ustr[test_num].res_Length);
    ok(dest_str.MaximumLength == dupl_ustr[test_num].res_MaximumLength,
       "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination has MaximumLength %d, expected %d\n",
       test_num, dupl_ustr[test_num].add_nul, dest_str.MaximumLength, dupl_ustr[test_num].res_MaximumLength);
        if (result == STATUS_INVALID_PARAMETER) {
        ok((dest_str.Buffer == NULL && res_str.Buffer == NULL) ||
               dest_str.Buffer == dest_buf,
           "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination buffer changed %p expected %p\n",
           test_num, dupl_ustr[test_num].add_nul, dest_str.Buffer, dest_buf);
        } else {
        ok(dest_str.Buffer != dest_buf,
           "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination buffer unchanged %p\n",
           test_num, dupl_ustr[test_num].add_nul, dest_str.Buffer);
        }
        if (dest_str.Buffer != NULL && dupl_ustr[test_num].res_buf != NULL) {
        ok(memcmp(dest_str.Buffer, res_str.Buffer, dupl_ustr[test_num].res_buf_size) == 0,
           "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination \"%s\" expected \"%s\"\n",
           test_num, dupl_ustr[test_num].add_nul, dest_ansi_str.Buffer, dupl_ustr[test_num].res_buf);
            if(result == STATUS_SUCCESS) pRtlFreeUnicodeString(&dest_str);
        } else {
        ok(dest_str.Buffer == NULL && dupl_ustr[test_num].res_buf == NULL,
           "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination %p expected %p\n",
           test_num, dupl_ustr[test_num].add_nul, dest_str.Buffer, dupl_ustr[test_num].res_buf);
        }
    }
}

Referenced by START_TEST().

test_RtlFindCharInUnicodeString()

static void test_RtlFindCharInUnicodeString ( void  )

static

Definition at line 1231 of file rtlstr.c.

{
    WCHAR main_str_buf[257];
    WCHAR search_chars_buf[257];
    UNICODE_STRING main_str;
    UNICODE_STRING search_chars;
    USHORT pos;
    NTSTATUS result;
    unsigned int idx;
    unsigned int test_num;
 
    if (!pRtlFindCharInUnicodeString)
    {
        win_skip("RtlFindCharInUnicodeString is not available\n");
        return;
    }
 
    for (test_num = 0; test_num < ARRAY_SIZE(find_ch_in_ustr); test_num++) {
    if (find_ch_in_ustr[test_num].main_str != NULL) {
        main_str.Length        = strlen(find_ch_in_ustr[test_num].main_str) * sizeof(WCHAR);
        main_str.MaximumLength = main_str.Length + sizeof(WCHAR);
        for (idx = 0; idx < main_str.Length / sizeof(WCHAR); idx++) {
        main_str_buf[idx] = find_ch_in_ustr[test_num].main_str[idx];
        }
        main_str.Buffer = main_str_buf;
    } else {
        main_str.Length        = 0;
        main_str.MaximumLength = 0;
        main_str.Buffer        = NULL;
    }
    if (find_ch_in_ustr[test_num].search_chars != NULL) {
        search_chars.Length        = strlen(find_ch_in_ustr[test_num].search_chars) * sizeof(WCHAR);
        search_chars.MaximumLength = search_chars.Length + sizeof(WCHAR);
        for (idx = 0; idx < search_chars.Length / sizeof(WCHAR); idx++) {
        search_chars_buf[idx] = find_ch_in_ustr[test_num].search_chars[idx];
        }
        search_chars.Buffer = search_chars_buf;
    } else {
        search_chars.Length        = 0;
        search_chars.MaximumLength = 0;
        search_chars.Buffer        = NULL;
    }
    pos = 12345;
        result = pRtlFindCharInUnicodeString(find_ch_in_ustr[test_num].flags, &main_str, &search_chars, &pos);
        ok(result == find_ch_in_ustr[test_num].result,
           "(test %d): RtlFindCharInUnicodeString(%d, %s, %s, [out]) has result %lx, expected %lx\n",
           test_num, find_ch_in_ustr[test_num].flags,
           find_ch_in_ustr[test_num].main_str, find_ch_in_ustr[test_num].search_chars,
           result, find_ch_in_ustr[test_num].result);
        ok(pos == find_ch_in_ustr[test_num].pos,
           "(test %d): RtlFindCharInUnicodeString(%d, %s, %s, [out]) assigns %d to pos, expected %d\n",
           test_num, find_ch_in_ustr[test_num].flags,
           find_ch_in_ustr[test_num].main_str, find_ch_in_ustr[test_num].search_chars,
           pos, find_ch_in_ustr[test_num].pos);
    }
}

Referenced by START_TEST().

test_RtlFormatMessage()

static void test_RtlFormatMessage ( void  )

static

Definition at line 2689 of file rtlstr.c.

{
    WCHAR buffer[128];
    NTSTATUS status;
    ULONG i, size;
 
#ifdef __REACTOS__
    if (is_reactos())
    {
        ok(FALSE, "RtlFormatMessage is unimplemented!\n");
        return;
    }
#endif
 
    /* basic formats */
    testfmt( L"test", L"test", 0, FALSE );
    testfmt( L"", L"", 0, FALSE );
    testfmt( L"%1", L"test", 0, FALSE, L"test" );
    testfmt( L"%1!s!", L"test", 0, FALSE, L"test" );
    testfmt( L"%1!s!", L"foo", 0, TRUE, "foo" );
    testfmt( L"%1!S!", L"test", 0, FALSE, "test" );
    testfmt( L"%1!S!", L"foo", 0, TRUE, L"foo" );
    testfmt( L"%1!hs!%1!hS!", L"testtest", 0, FALSE, "test" );
    testfmt( L"%1!ls!%1!lS!%1!ws!%1!wS!", L"foofoofoofoo", 0, TRUE, L"foo" );
    testfmt( L"%1!c!", L"a", 0, FALSE, L'a' );
    testfmt( L"%1!c!", L"b", 0, TRUE, 'b' );
    testfmt( L"%1!C!", L"c", 0, FALSE, L'c' );
    testfmt( L"%1!C!", L"d", 0, TRUE, 'd' );
    testfmt( L"%1!hc!", L"e", 0, FALSE, L'e' );
    testfmt( L"%1!hC!", L"f", 0, FALSE, L'f' );
    testfmt( L"%1!lc!", L"g", 0, TRUE, 'g' );
    testfmt( L"%1!lC!", L"h", 0, TRUE, 'h' );
    testfmt( L"%1!wc!", L"i", 0, TRUE, 'i' );
    testfmt( L"%1!wC!", L"j", 0, TRUE, 'j' );
    testfmt( L"%1!04X!", L"BEEF", 0, FALSE, 0xbeef );
    testfmt( L"%1!Saa!", L"testaa", 0, FALSE, "test" );
    testfmt( L"%.%%%Z%n%t%r%!% ", L".%Z\r\n\t\r! ", 0, FALSE );
    testfmt( L"%1!*.*u!,%1!*.*u!", L"  001, 0002", 0, FALSE, 5, 3, 1, 4, 2 );
    testfmt( L"%1!*.*u!,%3!*.*u!", L"  001,  0002", 0, FALSE, 5, 3, 1, 6, 4, 2 );
    testfmt( L"%1", L"(null)", 0, FALSE, NULL );
    testfmt( L"%2", L"(null)", 0, TRUE, "abc", NULL );
    testfmt( L"ab%1!!cd", L"abcd", 0, FALSE, L"hello" );
    testfmt( L"abc%1!#.000000000000000000000000000x!", L"abc0x22", 0, FALSE, 34 );
    testfmt( L"a\r\nb\rc\r\rd\r\r\ne", L"a\r\nb\r\nc\r\n\r\nd\r\n\r\ne", 0, FALSE, NULL );
#ifdef _WIN64
    testfmt( L"%1!#I64x! %2!x!", L"0x1234 5678", 0, FALSE, (ULONG_PTR)0x1234, 0x5678, 0xbeef );
    testfmt( L"%1!x! %2!#I64x! %3!#I64x! %4!x!", L"dead 0x1111222233334444 0x5555666677778888 beef",
             0, FALSE, 0xdead, 0x1111222233334444ull, 0x5555666677778888ull, 0xbeef );
    testfmt( L"%3!#I64x! %4!#I64x! %3!x! %1!x!", L"0x3 0x4 3 1", 0, FALSE, 0xdead00000001ll, 2, 3ll, 4ll );
    testfmt( L"%2!x! %1!I64x!", L"5678 1234", 0, FALSE, (ULONG_PTR)0x1234, 0x5678, 0xbeef );
    testfmt( L"%2!*.*I64x! %1!u! %4!u! %2!u!", L"  00000000000000d 19 11 17", 0, FALSE,
             19ull, 17ull, 15ull, 13ull, 11ull, 9ull );
    {  /* argument array works differently */
        ULONG_PTR args[] = { 19, 17, 15, 13, 11, 9, 7 };
        memset( buffer, 0xcc, sizeof(buffer) );
        status = pRtlFormatMessage( L"%2!*.*I64x! %1!u! %4!u! %2!u!", 0, FALSE, FALSE, TRUE,
                                    (va_list *)args, buffer, sizeof(buffer), &size );
        ok( !lstrcmpW( buffer, L"  00000000000000d 19 13 17" ), "got %s\n", wine_dbgstr_w(buffer) );
        memset( buffer, 0xcc, sizeof(buffer) );
        status = pRtlFormatMessage( L"%1!I64u! %2!u! %4!.*I64x! %5!I64u!", 0, FALSE, FALSE, TRUE,
                                    (va_list *)args, buffer, sizeof(buffer), &size );
        ok( !lstrcmpW( buffer, L"19 17 000000000000b 11" ), "got %s\n", wine_dbgstr_w(buffer) );
    }
#else
    fmt( L"%1!#I64x! %2!x!", 0, FALSE, FALSE, buffer, sizeof(buffer), &size, 0x1234, 0x5678, 0xbeef );
    if (lstrcmpW( buffer, L"0x567800001234 5678" ))
    {
        testfmt( L"%1!#I64x! %2!x!", L"0x567800001234 beef", 0, FALSE, 0x1234, 0x5678, 0xbeef );
        testfmt( L"%1!x! %2!#I64x! %3!#I64x! %4!x!", L"dead 0x1111222233334444 0x5555666677778888 beef",
                 0, FALSE, 0xdead, 0x1111222233334444ull, 0x5555666677778888ull, 0xbeef );
        testfmt( L"%3!#I64x! %4!#I64x! %3!x! %1!x!", L"0x1111222233334444 0x5555666677778888 33334444 1",
                 0, FALSE, 1, 2, 3, 4, 0x33334444, 0x11112222, 0x77778888, 0x55556666, 0xbeef, 0xbee2 );
        testfmt( L"%2!x! %1!I64x!", L"5678 1234", 0, FALSE, 0x1234, 0x5678, 0xbeef );
        testfmt( L"%2!*.*I64x! %1!u! %4!u! %2!u!", L"  000090000000b 19 7 15", 0, FALSE,
                 19, 17, 15, 13, 11, 9, 7 );
        {  /* argument array works differently */
            ULONG_PTR args[] = { 19, 17, 15, 13, 11, 9, 7 };
            memset( buffer, 0xcc, sizeof(buffer) );
            status = pRtlFormatMessage( L"%2!*.*I64x! %1!u! %4!u! %2!u!", 0, FALSE, FALSE, TRUE,
                                        (va_list *)args, buffer, sizeof(buffer), &size );
            ok( !lstrcmpW( buffer, L"        d0000000f 19 13 17" ), "got %s\n", wine_dbgstr_w(buffer) );
            memset( buffer, 0xcc, sizeof(buffer) );
            status = pRtlFormatMessage( L"%1!I64u! %2!u! %4!.*I64x! %5!I64u!", 0, FALSE, FALSE, TRUE,
                                        (va_list *)args, buffer, sizeof(buffer), &size );
            ok( !lstrcmpW( buffer, L"19 17 0000b00000000 11" ), "got %s\n", wine_dbgstr_w(buffer) );
        }
    }
    else win_skip( "I64 support broken\n" );
#endif
    testfmt( L"%1!Ix! %2!QQ!", L"1234 QQ", 0, FALSE, (ULONG_PTR)0x1234 );
    testfmt( L"%1!#llx!%2!#x!%1!#hx!", L"0x1234560x789abc0x3456", 0, FALSE, 0x123456, 0x789abc );
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    fmt( L"ab%0cd", 0, FALSE, FALSE, buffer, sizeof(buffer), &size );
    ok( !memcmp( buffer, L"ab\0xxxxxxx", 10 * sizeof(WCHAR) ), "got %s\n", wine_dbgstr_wn(buffer, 10) );
 
    /* max width */
    testfmt( L"%1", L"testing\r\n", 3, FALSE, L"testing" );
    testfmt( L"%1%2%3", L"testing\r\nabcdef\r\nfoobar\r\n", 4, FALSE, L"testing", L"abcdef", L"foobar");
    testfmt( L"%1%2%3%4", L"test\r\nabcd\r\nabcdef\r\n", 4, FALSE, L"test", L"abcd", L"abc", L"def" );
    testfmt( L"%1a\nb%2", L"testing\r\na\r\nbfoo bar\r\n", 3, FALSE, L"testing", L"foo bar" );
    testfmt( L"a%tb%t%t%t%c%r%r%r%r%r%rdefg", L"a\r\nb\r\n\r\n\r\nc\r\r\r\r\r\rdef\r\ng", 3, FALSE );
    testfmt( L"test abcd ", L"test\r\n\r\nabcd\r\n ", 4, FALSE );
    testfmt( L"test abcdef %1 foobar", L"tes\r\nt\r\nabc\r\ndef\r\n\r\nhello\r\nfoo\r\nbar\r\n", 3, FALSE, L"hello" );
    testfmt( L"te st\nabc d\nfoo", L"te st\r\nabc d\r\nfoo", 6, FALSE );
    testfmt( L"te st    ab    d\nfoo", L"te st\r\n  ab\r\n d foo", 7, FALSE );
    testfmt( L"te\tst\t\t\t\tab\t\t\td\nfoo", L"te\tst\t\t\r\n\t\tab\t\t\t\r\nd foo", 7, FALSE );
    testfmt( L"te st\n\n\r\n\nab    d\nfoo    ", L"te st\r\n  ab\r\n d foo\r\n   ", 7, FALSE );
    testfmt( L"te st\r\nabc d\n\nfoo\rbar", L"te st abc d  foo bar", 0xff, FALSE );
    testfmt( L"te st%r%nabc d%nfoo%rbar", L"te st\r\r\nabc d\r\nfoo\rbar", 0xff, FALSE );
    testfmt( L"\01\02\03\04\a\a\a\a\b\b\b\b\t\t\t\t\v\v\v\v\f\f\f\f\r\r\r\r    a",
             L"\01\02\r\n\03\04\r\n\a\a\r\n\a\a\r\n\b\b\r\n\b\b\r\n\t\t\r\n\t\t\r\n\v\v\r\n\v\v\r\n\f\f\r\n\f\f\r\n\r\n\r\n\r\n\r\na", 2, FALSE );
 
    for (i = 1; i < 0xffff; i++)
    {
        WCHAR src[] = { i, ' ', i, i, i, i, i, ' ', i, 0 };
        WCHAR expect[16];
        switch (i)
        {
        case '\t':
            lstrcpyW( expect, L"\r\n\r\n\t" );
            break;
        case '\r':
        case '\n':
        case ' ':
            lstrcpyW( expect, L"\r\n\r\n " );
            break;
        case '%':
            lstrcpyW( expect, L" %% \r\nxxxx" );
            break;
        default:
            swprintf( expect, ARRAY_SIZE(expect), L"%c\r\n%c%c%c%c\r\n%c %c", i,  i,  i,  i,  i,  i,  i );
            break;
        }
        lstrcpyW( buffer, L"xxxxxxxxxx" );
        fmt( src, 4, FALSE, FALSE, buffer, sizeof(buffer), &size );
        ok( !lstrcmpW( buffer, expect ), "%04lx: got %s\n", i, debugstr_w(buffer) );
    }
 
    /* args are not counted the same way with an argument array */
    {
        ULONG_PTR args[] = { 6, 4, 2, 5, 3, 1 };
        memset( buffer, 0xcc, sizeof(buffer) );
        status = pRtlFormatMessage( L"%1!*.*u!,%1!*.*u!", 0, FALSE, FALSE, TRUE, (va_list *)args,
                                    buffer, sizeof(buffer), &size );
        ok( !lstrcmpW( buffer, L"  0002, 00003" ), "got %s\n", wine_dbgstr_w(buffer) );
        memset( buffer, 0xcc, sizeof(buffer) );
        status = pRtlFormatMessage( L"%1!*.*u!,%4!*.*u!", 0, FALSE, FALSE, TRUE, (va_list *)args,
                                    buffer, sizeof(buffer), &size );
        ok( !lstrcmpW( buffer, L"  0002,  001" ), "got %s\n", wine_dbgstr_w(buffer) );
    }
 
    /* buffer overflows */
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"testing", 0, FALSE, FALSE, buffer, 8, &size );
    ok( status == STATUS_BUFFER_OVERFLOW, "failed %lx\n", status );
    ok( !lstrcmpW( buffer, L"testxxxxxx" ) || broken(!lstrcmpW( buffer, L"tesxxxxxxx" )), /* winxp */
        "got %s\n", wine_dbgstr_w(buffer) );
    ok( size == 0xdeadbeef, "wrong size %lu\n", size );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"%1", 0, FALSE, FALSE, buffer, 8, &size, L"test" );
    ok( status == STATUS_BUFFER_OVERFLOW, "failed %lx\n", status );
    ok( !memcmp( buffer, L"tes\0xxxxxx", 10 * sizeof(WCHAR) ) || broken(!lstrcmpW( buffer, L"testxxxxxx" )), /* winxp */
        "got %s\n", wine_dbgstr_w(buffer) );
    ok( size == 0xdeadbeef, "wrong size %lu\n", size );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"%1!x!", 0, FALSE, FALSE, buffer, 8, &size, 0x12345678 );
    ok( status == STATUS_BUFFER_OVERFLOW, "failed %lx\n", status );
    ok( !memcmp( buffer, L"123\0xxxxxx", 10 * sizeof(WCHAR) ) || broken(!lstrcmpW( buffer, L"1234xxxxxx" )), /* winxp */
        "got %s\n", wine_dbgstr_w(buffer) );
    ok( size == 0xdeadbeef, "wrong size %lu\n", size );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"%1!*s!", 0, FALSE, FALSE, buffer, 10, &size, 5, L"abc" );
    ok( status == STATUS_BUFFER_OVERFLOW, "failed %lx\n", status );
    ok( !memcmp( buffer, L"  ab\0xxxxx", 10 * sizeof(WCHAR) ) || broken(!lstrcmpW( buffer, L"  abcxxxxx" )), /* winxp */
        "got %s\n", wine_dbgstr_w(buffer) );
    ok( size == 0xdeadbeef, "wrong size %lu\n", size );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"ab%n", 0, FALSE, FALSE, buffer, 6, &size );
    ok( status == STATUS_BUFFER_OVERFLOW, "failed %lx\n", status );
    ok( !memcmp( buffer, L"abxxxxxxxx", 10 * sizeof(WCHAR) ), "got %s\n", wine_dbgstr_w(buffer) );
    ok( size == 0xdeadbeef, "wrong size %lu\n", size );
 
    /* ignore inserts */
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"%1!x!%r%%%n%t", 0, TRUE, FALSE, buffer, sizeof(buffer), &size );
    ok( !lstrcmpW( buffer, L"%1!x!\r%%\r\n\t" ), "got %s\n", wine_dbgstr_w(buffer) );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"ab%0cd", 0, TRUE, FALSE, buffer, sizeof(buffer), &size );
    ok( !status, "failed %lx\n", status );
    ok( !memcmp( buffer, L"ab\0xxxxxxx", 10 * sizeof(WCHAR) ), "got %s\n", wine_dbgstr_wn(buffer, 10) );
 
    /* invalid args */
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    size = 0xdeadbeef;
    status = pRtlFormatMessage( L"abc%1", 0, FALSE, FALSE, FALSE, NULL, buffer, sizeof(buffer), &size );
    ok( status == STATUS_INVALID_PARAMETER, "failed %lx\n", status );
    ok( !lstrcmpW( buffer, L"abcxxxxxxx" ), "got %s\n", wine_dbgstr_w(buffer) );
    ok( size == 0xdeadbeef, "wrong size %lu\n", size );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = pRtlFormatMessage( L"abc%1", 0, FALSE, FALSE, TRUE, NULL, buffer, sizeof(buffer), &size );
    ok( status == STATUS_INVALID_PARAMETER, "failed %lx\n", status );
    ok( !lstrcmpW( buffer, L"abcxxxxxxx" ), "got %s\n", wine_dbgstr_w(buffer) );
    ok( size == 0xdeadbeef, "wrong size %lu\n", size );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = pRtlFormatMessage( L"abc%", 0, FALSE, FALSE, TRUE, NULL, buffer, sizeof(buffer), &size );
    ok( status == STATUS_INVALID_PARAMETER, "failed %lx\n", status );
    ok( !lstrcmpW( buffer, L"abcxxxxxxx" ), "got %s\n", wine_dbgstr_w(buffer) );
    ok( size == 0xdeadbeef, "wrong size %lu\n", size );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"%1!u! %2!u", 0, FALSE, FALSE, buffer, sizeof(buffer), &size, 34 );
    ok( status == STATUS_INVALID_PARAMETER, "failed %lx\n", status );
    ok( !lstrcmpW( buffer, L"34 xxxxxxx" ), "got %s\n", wine_dbgstr_w(buffer) );
    ok( size == 0xdeadbeef, "wrong size %lu\n", size );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"%1!**u!", 0, FALSE, FALSE, buffer, sizeof(buffer), &size, 34 );
    ok( status == STATUS_SUCCESS, "failed %lx\n", status );
    ok( !lstrcmpW( buffer, L"*u" ), "got %s\n", wine_dbgstr_w(buffer) );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"%1!0.3+*u!", 0, FALSE, FALSE, buffer, sizeof(buffer), &size, 34 );
    ok( status == STATUS_SUCCESS, "failed %lx\n", status );
    ok( !lstrcmpW( buffer, L"+*u" ), "got %s\n", wine_dbgstr_w(buffer) );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"aa%1!***u!", 0, FALSE, FALSE, buffer, sizeof(buffer), &size, 34 );
    ok( status == STATUS_INVALID_PARAMETER, "failed %lx\n", status );
    ok( !lstrcmpW( buffer, L"aaxxxxxxxx" ), "got %s\n", wine_dbgstr_w(buffer) );
    ok( size == 0xdeadbeef, "wrong size %lu\n", size );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"abc%1!#.000000000000000000000000000x!", 0, FALSE, FALSE, buffer, sizeof(buffer), &size, 34 );
    ok( status == STATUS_SUCCESS, "failed %lx\n", status );
    ok( !lstrcmpW( buffer, L"abc0x22" ), "got %s\n", wine_dbgstr_w(buffer) );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"abc%1!#.0000000000000000000000000000x!", 0, FALSE, FALSE, buffer, sizeof(buffer), &size, 34 );
    ok( status == STATUS_INVALID_PARAMETER, "failed %lx\n", status );
    ok( !lstrcmpW( buffer, L"abcxxxxxxx" ), "got %s\n", wine_dbgstr_w(buffer) );
    ok( size == 0xdeadbeef, "wrong size %lu\n", size );
 
    lstrcpyW( buffer, L"xxxxxxxxxx" );
    status = fmt( L"abc%1!hsaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!", 0, FALSE, FALSE, buffer, sizeof(buffer), &size, "hello" );
    ok( status == STATUS_INVALID_PARAMETER, "failed %lx\n", status );
    ok( !lstrcmpW( buffer, L"abcxxxxxxx" ), "got %s\n", wine_dbgstr_w(buffer) );
    ok( size == 0xdeadbeef, "wrong size %lu\n", size );
 
    /* va_arg is eaten even in case of buffer overflow */
    testfmt_arg_eaten( L"%1!s! %2!s!", L"eaten", L"unused" );
}

Referenced by START_TEST().

test_RtlGUIDFromString()

static void test_RtlGUIDFromString ( void  )

static

Definition at line 1937 of file rtlstr.c.

{
  GUID guid;
  UNICODE_STRING str;
  NTSTATUS ret;
 
  if (!pRtlGUIDFromString)
  {
      win_skip("RtlGUIDFromString is not available\n");
      return;
  }
 
  str.Length = str.MaximumLength = sizeof(szGuid) - sizeof(WCHAR);
  str.Buffer = (LPWSTR)szGuid;
 
  ret = pRtlGUIDFromString(&str, &guid);
  ok(ret == 0, "expected ret=0, got 0x%0lx\n", ret);
  ok(IsEqualGUID(&guid, &IID_Endianness), "Endianness broken\n");
 
  str.Length = str.MaximumLength = sizeof(szGuid2) - sizeof(WCHAR);
  str.Buffer = (LPWSTR)szGuid2;
 
  ret = pRtlGUIDFromString(&str, &guid);
  ok(ret, "expected ret!=0\n");
}

Referenced by START_TEST().

test_RtlHashUnicodeString()

static void test_RtlHashUnicodeString ( void  )

static

Definition at line 2005 of file rtlstr.c.

{
    static const WCHAR strW[] = {'T','e','s','t',0,'1',0};
    const struct hash_unicodestring_test *ptr;
    UNICODE_STRING str;
    NTSTATUS status;
    ULONG hash;
 
    if (!pRtlHashUnicodeString)
    {
        win_skip("RtlHashUnicodeString is not available\n");
        return;
    }
 
    status = pRtlHashUnicodeString(NULL, FALSE, HASH_STRING_ALGORITHM_X65599, &hash);
    ok(status == STATUS_INVALID_PARAMETER, "got status 0x%08lx\n", status);
 
    pRtlInitUnicodeString(&str, strW);
    status = pRtlHashUnicodeString(&str, FALSE, HASH_STRING_ALGORITHM_X65599, NULL);
    ok(status == STATUS_INVALID_PARAMETER, "got status 0x%08lx\n", status);
 
    status = pRtlHashUnicodeString(&str, FALSE, HASH_STRING_ALGORITHM_INVALID, &hash);
    ok(status == STATUS_INVALID_PARAMETER, "got status 0x%08lx\n", status);
 
    /* embedded null */
    str.Buffer = (PWSTR)strW;
    str.Length = sizeof(strW) - sizeof(WCHAR);
    str.MaximumLength = sizeof(strW);
    status = pRtlHashUnicodeString(&str, FALSE, HASH_STRING_ALGORITHM_X65599, &hash);
    ok(status == STATUS_SUCCESS, "got status 0x%08lx\n", status);
    ok(hash == 0x32803083, "got 0x%08lx\n", hash);
 
    ptr = hash_test;
    while (*ptr->str)
    {
        pRtlInitUnicodeString(&str, ptr->str);
        hash = 0;
        status = pRtlHashUnicodeString(&str, ptr->case_insensitive, HASH_STRING_ALGORITHM_X65599, &hash);
        ok(status == STATUS_SUCCESS, "got status 0x%08lx for %s\n", status, wine_dbgstr_w(ptr->str));
        ok(hash == ptr->hash, "got wrong hash 0x%08lx, expected 0x%08lx, for %s, mode %d\n", hash, ptr->hash,
            wine_dbgstr_w(ptr->str), ptr->case_insensitive);
 
        ptr++;
    }
}

Referenced by START_TEST().

test_RtlInitString()

static void test_RtlInitString ( void  )

static

Definition at line 155 of file rtlstr.c.

{
    static const char teststring[] = "Some Wild String";
    STRING str;
 
    str.Length = 0;
    str.MaximumLength = 0;
    str.Buffer = (void *)0xdeadbeef;
    pRtlInitString(&str, teststring);
    ok(str.Length == sizeof(teststring) - sizeof(char), "Length uninitialized\n");
    ok(str.MaximumLength == sizeof(teststring), "MaximumLength uninitialized\n");
    ok(str.Buffer == teststring, "Buffer not equal to teststring\n");
    ok(strcmp(str.Buffer, "Some Wild String") == 0, "Buffer written to\n");
    pRtlInitString(&str, NULL);
    ok(str.Length == 0, "Length uninitialized\n");
    ok(str.MaximumLength == 0, "MaximumLength uninitialized\n");
    ok(str.Buffer == NULL, "Buffer not equal to NULL\n");
/*  pRtlInitString(NULL, teststring); */
}

Referenced by START_TEST().

test_RtlInitUnicodeString()

static void test_RtlInitUnicodeString ( void  )

static

Definition at line 176 of file rtlstr.c.

{
#define STRINGW {'S','o','m','e',' ','W','i','l','d',' ','S','t','r','i','n','g',0}
    static const WCHAR teststring[] = STRINGW;
    static const WCHAR originalstring[] = STRINGW;
#undef STRINGW
    UNICODE_STRING uni;
 
    uni.Length = 0;
    uni.MaximumLength = 0;
    uni.Buffer = (void *)0xdeadbeef;
    pRtlInitUnicodeString(&uni, teststring);
    ok(uni.Length == sizeof(teststring) - sizeof(WCHAR), "Length uninitialized\n");
    ok(uni.MaximumLength == sizeof(teststring), "MaximumLength uninitialized\n");
    ok(uni.Buffer == teststring, "Buffer not equal to teststring\n");
    ok(lstrcmpW(uni.Buffer, originalstring) == 0, "Buffer written to\n");
    pRtlInitUnicodeString(&uni, NULL);
    ok(uni.Length == 0, "Length uninitialized\n");
    ok(uni.MaximumLength == 0, "MaximumLength uninitialized\n");
    ok(uni.Buffer == NULL, "Buffer not equal to NULL\n");
/*  pRtlInitUnicodeString(NULL, teststring); */
}

Referenced by START_TEST().

test_RtlInitUnicodeStringEx()

static void test_RtlInitUnicodeStringEx ( void  )

static

Definition at line 204 of file rtlstr.c.

{
    static const WCHAR teststring[] = {'S','o','m','e',' ','W','i','l','d',' ','S','t','r','i','n','g',0};
    WCHAR *teststring2;
    UNICODE_STRING uni;
    NTSTATUS result;
 
    if (!pRtlInitUnicodeStringEx)
    {
        win_skip("RtlInitUnicodeStringEx is not available\n");
        return;
    }
 
    teststring2 = HeapAlloc(GetProcessHeap(), 0, (TESTSTRING2_LEN + 1) * sizeof(WCHAR));
    memset(teststring2, 'X', TESTSTRING2_LEN * sizeof(WCHAR));
    teststring2[TESTSTRING2_LEN] = '\0';
 
    uni.Length = 12345;
    uni.MaximumLength = 12345;
    uni.Buffer = (void *) 0xdeadbeef;
    result = pRtlInitUnicodeStringEx(&uni, teststring);
    ok(result == STATUS_SUCCESS,
       "pRtlInitUnicodeStringEx(&uni, 0) returns %lx, expected 0\n",
       result);
    ok(uni.Length == 32,
       "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u\n",
       uni.Length, 32);
    ok(uni.MaximumLength == 34,
       "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u\n",
       uni.MaximumLength, 34);
    ok(uni.Buffer == teststring,
       "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %p\n",
       uni.Buffer, teststring);
 
    uni.Length = 12345;
    uni.MaximumLength = 12345;
    uni.Buffer = (void *) 0xdeadbeef;
    pRtlInitUnicodeString(&uni, teststring);
    ok(uni.Length == 32,
       "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n",
       uni.Length, 32);
    ok(uni.MaximumLength == 34,
       "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n",
       uni.MaximumLength, 34);
    ok(uni.Buffer == teststring,
       "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p\n",
       uni.Buffer, teststring);
 
    uni.Length = 12345;
    uni.MaximumLength = 12345;
    uni.Buffer = (void *) 0xdeadbeef;
    result = pRtlInitUnicodeStringEx(&uni, teststring2);
    ok(result == STATUS_NAME_TOO_LONG,
       "pRtlInitUnicodeStringEx(&uni, 0) returns %lx, expected %lx\n",
       result, STATUS_NAME_TOO_LONG);
    ok(uni.Length == 12345 ||
       uni.Length == 0, /* win2k3 */
       "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected 12345 or 0\n",
       uni.Length);
    ok(uni.MaximumLength == 12345 ||
       uni.MaximumLength == 0, /* win2k3 */
       "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected 12345 or 0\n",
       uni.MaximumLength);
    ok(uni.Buffer == (void *) 0xdeadbeef ||
       uni.Buffer == teststring2, /* win2k3 */
       "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %x or %p\n",
       uni.Buffer, 0xdeadbeef, teststring2);
 
    uni.Length = 12345;
    uni.MaximumLength = 12345;
    uni.Buffer = (void *) 0xdeadbeef;
    pRtlInitUnicodeString(&uni, teststring2);
    ok(uni.Length == 33920 /* <= Win2000 */ || uni.Length == 65532 /* >= Win XP */,
       "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n",
       uni.Length, 65532);
    ok(uni.MaximumLength == 33922 /* <= Win2000 */ || uni.MaximumLength == 65534 /* >= Win XP */,
       "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n",
       uni.MaximumLength, 65534);
    ok(uni.Buffer == teststring2,
       "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p\n",
       uni.Buffer, teststring2);
    ok(memcmp(uni.Buffer, teststring2, (TESTSTRING2_LEN + 1) * sizeof(WCHAR)) == 0,
       "pRtlInitUnicodeString(&uni, 0) changes Buffer\n");
 
    uni.Length = 12345;
    uni.MaximumLength = 12345;
    uni.Buffer = (void *) 0xdeadbeef;
    result = pRtlInitUnicodeStringEx(&uni, 0);
    ok(result == STATUS_SUCCESS,
       "pRtlInitUnicodeStringEx(&uni, 0) returns %lx, expected 0\n",
       result);
    ok(uni.Length == 0,
       "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u\n",
       uni.Length, 0);
    ok(uni.MaximumLength == 0,
       "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u\n",
       uni.MaximumLength, 0);
    ok(uni.Buffer == NULL,
       "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %p\n",
       uni.Buffer, NULL);
 
    uni.Length = 12345;
    uni.MaximumLength = 12345;
    uni.Buffer = (void *) 0xdeadbeef;
    pRtlInitUnicodeString(&uni, 0);
    ok(uni.Length == 0,
       "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n",
       uni.Length, 0);
    ok(uni.MaximumLength == 0,
       "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n",
       uni.MaximumLength, 0);
    ok(uni.Buffer == NULL,
       "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p\n",
       uni.Buffer, NULL);
 
    HeapFree(GetProcessHeap(), 0, teststring2);
}

Referenced by START_TEST().

test_RtlIntegerToChar()

static void test_RtlIntegerToChar ( void  )

static

Definition at line 1734 of file rtlstr.c.

{
    NTSTATUS result;
    size_t test_num;
 
    for (test_num = 0; test_num < ARRAY_SIZE(int2str); test_num++)
      one_RtlIntegerToChar_test(test_num, &int2str[test_num]);
 
    result = pRtlIntegerToChar(int2str[0].value, 20, int2str[0].MaximumLength, NULL);
    ok(result == STATUS_INVALID_PARAMETER,
       "(test a): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %lx\n",
       int2str[0].value, 20, int2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER);
 
    result = pRtlIntegerToChar(int2str[0].value, 20, 0, NULL);
    ok(result == STATUS_INVALID_PARAMETER,
       "(test b): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %lx\n",
       int2str[0].value, 20, 0, result, STATUS_INVALID_PARAMETER);
 
    result = pRtlIntegerToChar(int2str[0].value, int2str[0].base, 0, NULL);
    ok(result == STATUS_BUFFER_OVERFLOW,
       "(test c): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %lx\n",
       int2str[0].value, int2str[0].base, 0, result, STATUS_BUFFER_OVERFLOW);
 
    result = pRtlIntegerToChar(int2str[0].value, int2str[0].base, int2str[0].MaximumLength, NULL);
    ok(result == STATUS_ACCESS_VIOLATION,
       "(test d): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %lx\n",
       int2str[0].value, int2str[0].base, int2str[0].MaximumLength, result, STATUS_ACCESS_VIOLATION);
}

Referenced by START_TEST().

test_RtlIntegerToUnicodeString()

static void test_RtlIntegerToUnicodeString ( void  )

static

Definition at line 1708 of file rtlstr.c.

{
    size_t test_num;
 
    for (test_num = 0; test_num < ARRAY_SIZE(int2str); test_num++)
        one_RtlIntegerToUnicodeString_test(test_num, &int2str[test_num]);
}

Referenced by START_TEST().

test_RtlIsTextUnicode()

static void test_RtlIsTextUnicode ( void  )

static

Definition at line 1763 of file rtlstr.c.

{
    char ascii[] = "A simple string";
    char false_positive[] = {0x41, 0x0a, 0x0d, 0x1d};
    WCHAR false_negative = 0x0d0a;
    WCHAR unicode[] = {'A',' ','U','n','i','c','o','d','e',' ','s','t','r','i','n','g',0};
    WCHAR unicode_no_controls[] = {'A','U','n','i','c','o','d','e','s','t','r','i','n','g',0};
    /* String with both byte-reversed and standard Unicode control characters. */
    WCHAR mixed_controls[] = {'\t',0x9000,0x0d00,'\n',0};
    WCHAR *be_unicode;
    WCHAR *be_unicode_no_controls;
    BOOLEAN res;
    int flags;
    int i;
 
    if (!pRtlIsTextUnicode)
    {
        win_skip("RtlIsTextUnicode is not available\n");
        return;
    }
 
    ok(!pRtlIsTextUnicode(ascii, sizeof(ascii), NULL), "ASCII text detected as Unicode\n");
 
    res = pRtlIsTextUnicode(unicode, sizeof(unicode), NULL);
    ok(res ||
       broken(res == FALSE), /* NT4 */
       "Text should be Unicode\n");
 
    ok(!pRtlIsTextUnicode(unicode, sizeof(unicode) - 1, NULL), "Text should be Unicode\n");
 
    flags =  IS_TEXT_UNICODE_UNICODE_MASK;
    ok(pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Text should not pass a Unicode\n");
    ok(flags == (IS_TEXT_UNICODE_STATISTICS | IS_TEXT_UNICODE_CONTROLS),
       "Expected flags 0x6, obtained %x\n", flags);
 
    flags =  IS_TEXT_UNICODE_REVERSE_MASK;
    ok(!pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Text should not pass reverse Unicode tests\n");
    ok(flags == 0, "Expected flags 0, obtained %x\n", flags);
 
    flags = IS_TEXT_UNICODE_ODD_LENGTH;
    ok(!pRtlIsTextUnicode(unicode, sizeof(unicode) - 1, &flags), "Odd length test should have passed\n");
    ok(flags == IS_TEXT_UNICODE_ODD_LENGTH, "Expected flags 0x200, obtained %x\n", flags);
 
    be_unicode = HeapAlloc(GetProcessHeap(), 0, sizeof(unicode) + sizeof(WCHAR));
    be_unicode[0] = 0xfffe;
    for (i = 0; i < ARRAY_SIZE(unicode); i++)
    {
        be_unicode[i + 1] = (unicode[i] >> 8) | ((unicode[i] & 0xff) << 8);
    }
    ok(!pRtlIsTextUnicode(be_unicode, sizeof(unicode) + 2, NULL), "Reverse endian should not be Unicode\n");
    ok(!pRtlIsTextUnicode(&be_unicode[1], sizeof(unicode), NULL), "Reverse endian should not be Unicode\n");
 
    flags = IS_TEXT_UNICODE_REVERSE_MASK;
    ok(!pRtlIsTextUnicode(&be_unicode[1], sizeof(unicode), &flags), "Reverse endian should be Unicode\n");
    todo_wine
    ok(flags == (IS_TEXT_UNICODE_REVERSE_ASCII16 | IS_TEXT_UNICODE_REVERSE_STATISTICS | IS_TEXT_UNICODE_REVERSE_CONTROLS),
       "Expected flags 0x70, obtained %x\n", flags);
 
    flags = IS_TEXT_UNICODE_REVERSE_MASK;
    ok(!pRtlIsTextUnicode(be_unicode, sizeof(unicode) + 2, &flags), "Reverse endian should be Unicode\n");
    ok(flags == (IS_TEXT_UNICODE_REVERSE_CONTROLS | IS_TEXT_UNICODE_REVERSE_SIGNATURE),
       "Expected flags 0xc0, obtained %x\n", flags);
 
    /* build byte reversed unicode string with no control chars */
    be_unicode_no_controls = HeapAlloc(GetProcessHeap(), 0, sizeof(unicode) + sizeof(WCHAR));
    ok(be_unicode_no_controls != NULL, "Expected HeapAlloc to succeed.\n");
    be_unicode_no_controls[0] = 0xfffe;
    for (i = 0; i < ARRAY_SIZE(unicode_no_controls); i++)
        be_unicode_no_controls[i + 1] = (unicode_no_controls[i] >> 8) | ((unicode_no_controls[i] & 0xff) << 8);
 
 
    /* The following tests verify that the tests for */
    /* IS_TEXT_UNICODE_CONTROLS and IS_TEXT_UNICODE_REVERSE_CONTROLS */
    /* are not mutually exclusive. Regardless of whether the strings */
    /* contain an indication of endianness, the tests are still */
    /* run if the flag is passed to (Rtl)IsTextUnicode. */
 
    /* Test IS_TEXT_UNICODE_CONTROLS flag */
    flags = IS_TEXT_UNICODE_CONTROLS;
    ok(!pRtlIsTextUnicode(unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on Unicode string lacking control characters.\n");
    ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
 
    flags = IS_TEXT_UNICODE_CONTROLS;
    ok(!pRtlIsTextUnicode(be_unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on byte-reversed Unicode string lacking control characters.\n");
    ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
 
    flags = IS_TEXT_UNICODE_CONTROLS;
    ok(pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Test should pass on Unicode string lacking control characters.\n");
    ok(flags == IS_TEXT_UNICODE_CONTROLS, "Expected flags 0x04, obtained %x\n", flags);
 
    flags = IS_TEXT_UNICODE_CONTROLS;
    ok(!pRtlIsTextUnicode(be_unicode_no_controls, sizeof(unicode_no_controls) + 2, &flags),
            "Test should not pass with standard Unicode string.\n");
    ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
 
    flags = IS_TEXT_UNICODE_CONTROLS;
    ok(pRtlIsTextUnicode(mixed_controls, sizeof(mixed_controls), &flags), "Test should pass on a string containing control characters.\n");
    ok(flags == IS_TEXT_UNICODE_CONTROLS, "Expected flags 0x04, obtained %x\n", flags);
 
    /* Test IS_TEXT_UNICODE_REVERSE_CONTROLS flag */
    flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
    ok(!pRtlIsTextUnicode(be_unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on Unicode string lacking control characters.\n");
    ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
 
    flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
    ok(!pRtlIsTextUnicode(unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on Unicode string lacking control characters.\n");
    ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
 
    flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
    ok(!pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Test should not pass on Unicode string lacking control characters.\n");
    ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
 
    flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
    ok(!pRtlIsTextUnicode(be_unicode, sizeof(unicode) + 2, &flags),
        "Test should pass with byte-reversed Unicode string containing control characters.\n");
    ok(flags == IS_TEXT_UNICODE_REVERSE_CONTROLS, "Expected flags 0x40, obtained %x\n", flags);
 
    flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
    ok(!pRtlIsTextUnicode(mixed_controls, sizeof(mixed_controls), &flags), "Test should pass on a string containing byte-reversed control characters.\n");
    ok(flags == IS_TEXT_UNICODE_REVERSE_CONTROLS, "Expected flags 0x40, obtained %x\n", flags);
 
    /* Test with flags for both byte-reverse and standard Unicode characters */
    flags = IS_TEXT_UNICODE_CONTROLS | IS_TEXT_UNICODE_REVERSE_CONTROLS;
    ok(!pRtlIsTextUnicode(mixed_controls, sizeof(mixed_controls), &flags), "Test should pass on string containing both byte-reversed and standard control characters.\n");
    ok(flags == (IS_TEXT_UNICODE_CONTROLS | IS_TEXT_UNICODE_REVERSE_CONTROLS), "Expected flags 0x44, obtained %x\n", flags);
 
    flags = IS_TEXT_UNICODE_STATISTICS;
    todo_wine ok(pRtlIsTextUnicode(false_positive, sizeof(false_positive), &flags), "Test should pass on false positive.\n");
 
    ok(!pRtlIsTextUnicode(&false_negative, sizeof(false_negative), NULL), "Test should fail on 0x0d0a (MALAYALAM LETTER UU).\n");
 
    HeapFree(GetProcessHeap(), 0, be_unicode);
    HeapFree(GetProcessHeap(), 0, be_unicode_no_controls);
}

Referenced by START_TEST().

test_RtlStringFromGUID()

static void test_RtlStringFromGUID ( void  )

static

Definition at line 1963 of file rtlstr.c.

{
  UNICODE_STRING str;
  NTSTATUS ret;
 
  if (!pRtlStringFromGUID)
  {
      win_skip("RtlStringFromGUID is not available\n");
      return;
  }
 
  str.Length = str.MaximumLength = 0;
  str.Buffer = NULL;
 
  ret = pRtlStringFromGUID(&IID_Endianness, &str);
  ok(ret == 0, "expected ret=0, got 0x%0lx\n", ret);
  ok(str.Buffer && !lstrcmpiW(str.Buffer, szGuid), "Endianness broken\n");
  pRtlFreeUnicodeString(&str);
}

Referenced by START_TEST().

test_RtlUnicodeStringToAnsiString()

static void test_RtlUnicodeStringToAnsiString ( void  )

static

Definition at line 822 of file rtlstr.c.

{
    size_t pos;
    CHAR ansi_buf[257];
    WCHAR uni_buf[257];
    STRING ansi_str;
    UNICODE_STRING uni_str;
    NTSTATUS result;
    unsigned int test_num;
 
    for (test_num = 0; test_num < ARRAY_SIZE(ustr2astr); test_num++) {
    ansi_str.Length        = ustr2astr[test_num].ansi_Length;
    ansi_str.MaximumLength = ustr2astr[test_num].ansi_MaximumLength;
    if (ustr2astr[test_num].ansi_buf != NULL) {
        memcpy(ansi_buf, ustr2astr[test_num].ansi_buf, ustr2astr[test_num].ansi_buf_size);
        ansi_buf[ustr2astr[test_num].ansi_buf_size] = '\0';
        ansi_str.Buffer = ansi_buf;
    } else {
        ansi_str.Buffer = NULL;
    }
    uni_str.Length        = ustr2astr[test_num].uni_Length;
    uni_str.MaximumLength = ustr2astr[test_num].uni_MaximumLength;
    if (ustr2astr[test_num].uni_buf != NULL) {
        for (pos = 0; pos < ustr2astr[test_num].uni_buf_size/sizeof(WCHAR); pos++) {
        uni_buf[pos] = ustr2astr[test_num].uni_buf[pos];
        }
        uni_str.Buffer = uni_buf;
    } else {
        uni_str.Buffer = NULL;
    }
    result = pRtlUnicodeStringToAnsiString(&ansi_str, &uni_str, ustr2astr[test_num].doalloc);
    ok(result == ustr2astr[test_num].result,
           "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) has result %lx, expected %lx\n",
       test_num, ustr2astr[test_num].doalloc, result, ustr2astr[test_num].result);
    ok(ansi_str.Length == ustr2astr[test_num].res_Length ||
       broken(ustr2astr[test_num].broken_len && !ansi_str.Length) /* win11 */,
       "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) ansi has Length %d, expected %d\n",
       test_num, ustr2astr[test_num].doalloc, ansi_str.Length, ustr2astr[test_num].res_Length);
    ok(ansi_str.MaximumLength == ustr2astr[test_num].res_MaximumLength,
       "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) ansi has MaximumLength %d, expected %d\n",
       test_num, ustr2astr[test_num].doalloc, ansi_str.MaximumLength, ustr2astr[test_num].res_MaximumLength);
    ok(memcmp(ansi_str.Buffer, ustr2astr[test_num].res_buf, ustr2astr[test_num].res_buf_size) == 0,
       "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) has ansi \"%s\" expected \"%s\"\n",
       test_num, ustr2astr[test_num].doalloc, ansi_str.Buffer, ustr2astr[test_num].res_buf);
        if(result == STATUS_SUCCESS && ustr2astr[test_num].doalloc)
            pRtlFreeAnsiString(&ansi_str);
    }
}

Referenced by START_TEST().

test_RtlUnicodeStringToInteger()

static void test_RtlUnicodeStringToInteger ( void  )

static

Definition at line 1412 of file rtlstr.c.

{
    unsigned int test_num;
    int value;
    NTSTATUS result;
    WCHAR *wstr;
    UNICODE_STRING uni;
 
    for (test_num = 0; test_num < ARRAY_SIZE(str2int); test_num++) {
    wstr = AtoW(str2int[test_num].str);
    value = 0xdeadbeef;
    pRtlInitUnicodeString(&uni, wstr);
    result = pRtlUnicodeStringToInteger(&uni, str2int[test_num].base, &value);
    ok(result == str2int[test_num].result ||
           (str2int[test_num].alternative && result == str2int[test_num].alternative),
           "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) has result %lx, expected: %lx (%lx)\n",
       test_num, str2int[test_num].str, str2int[test_num].base, result,
           str2int[test_num].result, str2int[test_num].alternative);
        if (result == STATUS_SUCCESS)
            ok(value == str2int[test_num].value ||
               broken(str2int[test_num].str[0] == '\0' && str2int[test_num].base == 16), /* nt4 */
               "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d\n",
               test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value);
        else
            ok(value == 0xdeadbeef || value == 0 /* vista */,
               "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) assigns value %d, expected 0 or deadbeef\n",
               test_num, str2int[test_num].str, str2int[test_num].base, value);
    HeapFree(GetProcessHeap(), 0, wstr);
    }
 
    wstr = AtoW(str2int[1].str);
    pRtlInitUnicodeString(&uni, wstr);
    result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, NULL);
    ok(result == STATUS_ACCESS_VIOLATION,
       "call failed: RtlUnicodeStringToInteger(\"%s\", %d, NULL) has result %lx\n",
       str2int[1].str, str2int[1].base, result);
    result = pRtlUnicodeStringToInteger(&uni, 20, NULL);
    ok(result == STATUS_INVALID_PARAMETER || result == STATUS_ACCESS_VIOLATION,
       "call failed: RtlUnicodeStringToInteger(\"%s\", 20, NULL) has result %lx\n",
       str2int[1].str, result);
 
    uni.Length = 10; /* Make Length shorter (5 WCHARS instead of 7) */
    result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value);
    ok(result == STATUS_SUCCESS,
       "call failed: RtlUnicodeStringToInteger(\"12345\", %d, [out]) has result %lx\n",
       str2int[1].base, result);
    ok(value == 12345,
       "didn't return expected value (test a): expected: %d, got: %d\n",
       12345, value);
 
    uni.Length = 5; /* Use odd Length (2.5 WCHARS) */
    result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value);
    ok(result == STATUS_SUCCESS || result == STATUS_INVALID_PARAMETER /* vista */,
       "call failed: RtlUnicodeStringToInteger(\"12\", %d, [out]) has result %lx\n",
       str2int[1].base, result);
    if (result == STATUS_SUCCESS)
        ok(value == 12, "didn't return expected value (test b): expected: %d, got: %d\n", 12, value);
 
    uni.Length = 2;
    result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value);
    ok(result == STATUS_SUCCESS,
       "call failed: RtlUnicodeStringToInteger(\"1\", %d, [out]) has result %lx\n",
       str2int[1].base, result);
    ok(value == 1,
       "didn't return expected value (test c): expected: %d, got: %d\n",
       1, value);
    /* w2k: uni.Length = 0 returns value 11234567 instead of 0 */
    HeapFree(GetProcessHeap(), 0, wstr);
}

Referenced by START_TEST().

test_RtlUnicodeToUTF8N()

static void test_RtlUnicodeToUTF8N ( void  )

static

Definition at line 2124 of file rtlstr.c.

{
    NTSTATUS status;
    ULONG bytes_out;
    ULONG bytes_out_array[2];
    void * const invalid_pointer = (void *)0x8;
    char buffer[128];
    const WCHAR empty_string[] = { 0 };
    const WCHAR test_string[] = { 'A',0,'a','b','c','d','e','f','g',0 };
    const WCHAR special_string[] = { 'X',0x80,0xd800,0 };
    const ULONG special_string_len[] = { 0, 1, 1, 3, 3, 3, 6, 7 };
    const unsigned char special_expected[] = { 'X',0xc2,0x80,0xef,0xbf,0xbd,0 };
    unsigned int input_len;
    const unsigned int test_count = ARRAY_SIZE(unicode_to_utf8);
    unsigned int i, ret;
 
    if (!pRtlUnicodeToUTF8N)
    {
        win_skip("RtlUnicodeToUTF8N is not available\n");
        return;
    }
 
    /* show that bytes_out is really ULONG */
    memset(bytes_out_array, 0x55, sizeof(bytes_out_array));
    status = pRtlUnicodeToUTF8N(NULL, 0, bytes_out_array, empty_string, 0);
    ok(status == STATUS_SUCCESS, "status = 0x%lx\n", status);
    ok(bytes_out_array[0] == 0x00000000, "Got 0x%lx\n", bytes_out_array[0]);
    ok(bytes_out_array[1] == 0x55555555, "Got 0x%lx\n", bytes_out_array[1]);
 
    /* parameter checks */
    status = pRtlUnicodeToUTF8N(NULL, 0, NULL, NULL, 0);
    ok(status == STATUS_INVALID_PARAMETER_4, "status = 0x%lx\n", status);
 
    status = pRtlUnicodeToUTF8N(NULL, 0, NULL, empty_string, 0);
    ok(status == STATUS_INVALID_PARAMETER, "status = 0x%lx\n", status);
 
    bytes_out = 0x55555555;
    status = pRtlUnicodeToUTF8N(NULL, 0, &bytes_out, NULL, 0);
    ok(status == STATUS_INVALID_PARAMETER_4, "status = 0x%lx\n", status);
    ok(bytes_out == 0x55555555, "bytes_out = 0x%lx\n", bytes_out);
 
    bytes_out = 0x55555555;
    status = pRtlUnicodeToUTF8N(NULL, 0, &bytes_out, invalid_pointer, 0);
    ok(status == STATUS_SUCCESS, "status = 0x%lx\n", status);
    ok(bytes_out == 0, "bytes_out = 0x%lx\n", bytes_out);
 
    bytes_out = 0x55555555;
    status = pRtlUnicodeToUTF8N(NULL, 0, &bytes_out, empty_string, 0);
    ok(status == STATUS_SUCCESS, "status = 0x%lx\n", status);
    ok(bytes_out == 0, "bytes_out = 0x%lx\n", bytes_out);
 
    bytes_out = 0x55555555;
    status = pRtlUnicodeToUTF8N(NULL, 0, &bytes_out, test_string, 0);
    ok(status == STATUS_SUCCESS, "status = 0x%lx\n", status);
    ok(bytes_out == 0, "bytes_out = 0x%lx\n", bytes_out);
 
    bytes_out = 0x55555555;
    status = pRtlUnicodeToUTF8N(NULL, 0, &bytes_out, empty_string, 1);
    ok(status == STATUS_SUCCESS, "status = 0x%lx\n", status);
    ok(bytes_out == 0, "bytes_out = 0x%lx\n", bytes_out);
 
    bytes_out = 0x55555555;
    status = pRtlUnicodeToUTF8N(invalid_pointer, 0, &bytes_out, empty_string, 1);
    ok(status == STATUS_INVALID_PARAMETER_5, "status = 0x%lx\n", status);
    ok(bytes_out == 0x55555555, "bytes_out = 0x%lx\n", bytes_out);
 
    bytes_out = 0x55555555;
    status = pRtlUnicodeToUTF8N(invalid_pointer, 8, &bytes_out, empty_string, 1);
    ok(status == STATUS_INVALID_PARAMETER_5, "status = 0x%lx\n", status);
    ok(bytes_out == 0x55555555, "bytes_out = 0x%lx\n", bytes_out);
 
    /* length output with special chars */
#define length_expect(in_chars, out_bytes, expect_status) \
        utf8_expect_(NULL, 0, out_bytes, \
                     special_string, in_chars * sizeof(WCHAR), \
                     expect_status, __LINE__)
 
    length_expect(0, 0, STATUS_SUCCESS);
    length_expect(1, 1, STATUS_SUCCESS);
    length_expect(2, 3, STATUS_SUCCESS);
    length_expect(3, 6, STATUS_SOME_NOT_MAPPED);
    length_expect(4, 7, STATUS_SOME_NOT_MAPPED);
#undef length_expect
 
    for (i = 0; i <= 6; i++)
    {
        memset(buffer, 0x55, sizeof(buffer));
        bytes_out = 0xdeadbeef;
        status = pRtlUnicodeToUTF8N(buffer, i, &bytes_out, special_string, sizeof(special_string));
        ok(status == STATUS_BUFFER_TOO_SMALL, "%d: status = 0x%lx\n", i, status);
        ok(bytes_out == special_string_len[i], "%d: expected %lu, got %lu\n", i, special_string_len[i], bytes_out);
        ok(memcmp(buffer, special_expected, special_string_len[i]) == 0, "%d: bad conversion\n", i);
    }
 
    status = pRtlUnicodeToUTF8N(buffer, 7, &bytes_out, special_string, sizeof(special_string));
    ok(status == STATUS_SOME_NOT_MAPPED, "status = 0x%lx\n", status);
    ok(bytes_out == special_string_len[7], "expected %lu, got %lu\n", special_string_len[7], bytes_out);
    ok(memcmp(buffer, special_expected, 7) == 0, "bad conversion\n");
 
    /* conversion behavior with varying input length */
    for (input_len = 0; input_len <= sizeof(test_string); input_len++) {
        /* no output buffer, just length */
        utf8_expect(NULL, 0, input_len / sizeof(WCHAR),
                    test_string, input_len, STATUS_SUCCESS);
 
        /* write output */
        bytes_out = 0x55555555;
        memset(buffer, 0x55, sizeof(buffer));
        status = pRtlUnicodeToUTF8N(
            buffer, sizeof(buffer), &bytes_out,
            test_string, input_len);
        if (input_len % sizeof(WCHAR) == 0) {
            ok(status == STATUS_SUCCESS,
               "(len %u): status = 0x%lx\n", input_len, status);
            ok(bytes_out == input_len / sizeof(WCHAR),
               "(len %u): bytes_out = 0x%lx\n", input_len, bytes_out);
            for (i = 0; i < bytes_out; i++) {
                ok(buffer[i] == test_string[i],
                   "(len %u): buffer[%d] = 0x%x, expected 0x%x\n",
                   input_len, i, buffer[i], test_string[i]);
            }
            for (; i < sizeof(buffer); i++) {
                ok(buffer[i] == 0x55,
                   "(len %u): buffer[%d] = 0x%x\n", input_len, i, buffer[i]);
            }
        } else {
            ok(status == STATUS_INVALID_PARAMETER_5,
               "(len %u): status = 0x%lx\n", input_len, status);
            ok(bytes_out == 0x55555555,
               "(len %u): bytes_out = 0x%lx\n", input_len, bytes_out);
            for (i = 0; i < sizeof(buffer); i++) {
                ok(buffer[i] == 0x55,
                   "(len %u): buffer[%d] = 0x%x\n", input_len, i, buffer[i]);
            }
        }
    }
 
    /* test cases for special characters */
    for (i = 0; i < test_count; i++) {
        bytes_out = 0x55555555;
        memset(buffer, 0x55, sizeof(buffer));
        status = pRtlUnicodeToUTF8N(
            buffer, sizeof(buffer), &bytes_out,
            unicode_to_utf8[i].unicode, lstrlenW(unicode_to_utf8[i].unicode) * sizeof(WCHAR));
        ok(status == unicode_to_utf8[i].status,
           "(test %d): status is 0x%lx, expected 0x%lx\n",
           i, status, unicode_to_utf8[i].status);
        ok(bytes_out == strlen(unicode_to_utf8[i].expected),
           "(test %d): bytes_out is %lu, expected %u\n",
           i, bytes_out, lstrlenA(unicode_to_utf8[i].expected));
        ok(!memcmp(buffer, unicode_to_utf8[i].expected, bytes_out),
           "(test %d): got \"%.*s\", expected \"%s\"\n",
           i, (int)bytes_out, buffer, unicode_to_utf8[i].expected);
        ok(buffer[bytes_out] == 0x55,
           "(test %d): behind string: 0x%x\n", i, buffer[bytes_out]);
        memset(buffer, 0x55, sizeof(buffer));
        ret = WideCharToMultiByte( CP_UTF8, 0, unicode_to_utf8[i].unicode, lstrlenW(unicode_to_utf8[i].unicode),
                                   buffer, sizeof(buffer), NULL, NULL );
        ok( ret == strlen(unicode_to_utf8[i].expected), "(test %d): wrong len %u\n", i, ret );
        ok(!memcmp(buffer, unicode_to_utf8[i].expected, ret),
           "(test %d): got \"%.*s\", expected \"%s\"\n",
           i, ret, buffer, unicode_to_utf8[i].expected);
        ok(buffer[ret] == 0x55, "(test %d): behind string: 0x%x\n", i, buffer[ret]);
 
        /* same test but include the null terminator */
        bytes_out = 0x55555555;
        memset(buffer, 0x55, sizeof(buffer));
        status = pRtlUnicodeToUTF8N(
            buffer, sizeof(buffer), &bytes_out,
            unicode_to_utf8[i].unicode, (lstrlenW(unicode_to_utf8[i].unicode) + 1) * sizeof(WCHAR));
        ok(status == unicode_to_utf8[i].status,
           "(test %d): status is 0x%lx, expected 0x%lx\n",
           i, status, unicode_to_utf8[i].status);
        ok(bytes_out == strlen(unicode_to_utf8[i].expected) + 1,
           "(test %d): bytes_out is %lu, expected %u\n",
           i, bytes_out, lstrlenA(unicode_to_utf8[i].expected) + 1);
        ok(!memcmp(buffer, unicode_to_utf8[i].expected, bytes_out),
           "(test %d): got \"%.*s\", expected \"%s\"\n",
           i, (int)bytes_out, buffer, unicode_to_utf8[i].expected);
        ok(buffer[bytes_out] == 0x55,
           "(test %d): behind string: 0x%x\n", i, buffer[bytes_out]);
        memset(buffer, 0x55, sizeof(buffer));
        ret = WideCharToMultiByte( CP_UTF8, 0, unicode_to_utf8[i].unicode, -1, buffer, sizeof(buffer), NULL, NULL );
        ok( ret == strlen(unicode_to_utf8[i].expected) + 1, "(test %d): wrong len %u\n", i, ret );
        ok(!memcmp(buffer, unicode_to_utf8[i].expected, ret),
           "(test %d): got \"%.*s\", expected \"%s\"\n",
           i, ret, buffer, unicode_to_utf8[i].expected);
        ok(buffer[ret] == 0x55, "(test %d): behind string: 0x%x\n", i, buffer[ret]);
        SetLastError( 0xdeadbeef );
        memset(buffer, 0x55, sizeof(buffer));
        ret = WideCharToMultiByte( CP_UTF8, WC_ERR_INVALID_CHARS, unicode_to_utf8[i].unicode, -1,
                                   buffer, sizeof(buffer), NULL, NULL );
        if (unicode_to_utf8[i].status == STATUS_SOME_NOT_MAPPED)
        {
            ok( ret == 0, "(test %d): wrong len %u\n", i, ret );
            ok( GetLastError() == ERROR_NO_UNICODE_TRANSLATION, "(test %d): wrong error %lu\n", i, GetLastError() );
            ret = strlen(unicode_to_utf8[i].expected) + 1;
        }
        else
            ok( ret == strlen(unicode_to_utf8[i].expected) + 1, "(test %d): wrong len %u\n", i, ret );
 
        ok(!memcmp(buffer, unicode_to_utf8[i].expected, ret),
           "(test %d): got \"%.*s\", expected \"%s\"\n",
           i, ret, buffer, unicode_to_utf8[i].expected);
        ok(buffer[ret] == 0x55, "(test %d): behind string: 0x%x\n", i, buffer[ret]);
    }
}

Referenced by START_TEST().

test_RtlUpcaseUnicodeChar()

static void test_RtlUpcaseUnicodeChar ( void  )

static

Definition at line 586 of file rtlstr.c.

{
    int i;
    WCHAR ch;
    WCHAR upper_ch;
    WCHAR expected_upper_ch;
 
    for (i = 0; i <= 255; i++) {
    ch = (WCHAR) i;
    upper_ch = pRtlUpcaseUnicodeChar(ch);
    if (ch >= 'a' && ch <= 'z') {
        expected_upper_ch = ch - 'a' + 'A';
    } else if (ch >= 0xe0 && ch <= 0xfe && ch != 0xf7) {
        expected_upper_ch = ch - 0x20;
    } else if (ch == 0xff) {
        expected_upper_ch = 0x178;
    } else {
        expected_upper_ch = ch;
    }
    ok(upper_ch == expected_upper_ch,
       "RtlUpcaseUnicodeChar('%c'[=0x%x]) has result '%c'[=0x%x], expected: '%c'[=0x%x]\n",
       ch, ch, upper_ch, upper_ch, expected_upper_ch, expected_upper_ch);
    }
}

Referenced by START_TEST().

test_RtlUpcaseUnicodeString()

static void test_RtlUpcaseUnicodeString ( void  )

static

Definition at line 612 of file rtlstr.c.

{
    int i, j;
    WCHAR ch;
    WCHAR upper_ch;
    WCHAR ascii_buf[257];
    WCHAR result_buf[257];
    WCHAR upper_buf[257];
    UNICODE_STRING ascii_str;
    UNICODE_STRING result_str;
    UNICODE_STRING upper_str;
 
    for (i = 0; i <= 255; i++) {
    ch = (WCHAR) i;
    if (ch >= 'a' && ch <= 'z') {
        upper_ch = ch - 'a' + 'A';
    } else if (ch >= 0xe0 && ch <= 0xfe && ch != 0xf7) {
        upper_ch = ch - 0x20;
    } else if (ch == 0xff) {
        upper_ch = 0x178;
    } else {
        upper_ch = ch;
    }
    ascii_buf[i] = ch;
    result_buf[i] = '\0';
    upper_buf[i] = upper_ch;
    }
    ascii_buf[i] = '\0';
    result_buf[i] = '\0';
    upper_buf[i] = '\0';
    ascii_str.Length = 512;
    ascii_str.MaximumLength = 512;
    ascii_str.Buffer = ascii_buf;
    result_str.Length = 512;
    result_str.MaximumLength = 512;
    result_str.Buffer = result_buf;
    upper_str.Length = 512;
    upper_str.MaximumLength = 512;
    upper_str.Buffer = upper_buf;
 
    pRtlUpcaseUnicodeString(&result_str, &ascii_str, 0);
    for (i = 0; i <= 255; i++) {
    ok(result_str.Buffer[i] == upper_str.Buffer[i],
       "RtlUpcaseUnicodeString works wrong: '%c'[=0x%x] is converted to '%c'[=0x%x], expected: '%c'[=0x%x]\n",
       ascii_str.Buffer[i], ascii_str.Buffer[i],
       result_str.Buffer[i], result_str.Buffer[i],
       upper_str.Buffer[i], upper_str.Buffer[i]);
    }
 
    /* test surrogates */
    for (i = 0x100; i < 0x1100; i++)
    {
        WCHAR src[512], dst[512];
        for (j = 0; j < 256; j++)
        {
            unsigned int ch = ((i << 8) + j) - 0x10000;
            src[2 * j] = 0xd800 | (ch >> 10);
            src[2 * j + 1] = 0xdc00 | (ch & 0x3ff);
        }
        upper_str.Length = upper_str.MaximumLength = 512 * sizeof(WCHAR);
        upper_str.Buffer = src;
        result_str.Length = result_str.MaximumLength = 512 * sizeof(WCHAR);
        result_str.Buffer = dst;
        pRtlUpcaseUnicodeString(&result_str, &upper_str, 0);
        ok( !memcmp(src, dst, sizeof(dst)),
            "string compare mismatch in %04x-%04x\n", i << 8, (i << 8) + 255 );
    }
}

Referenced by START_TEST().

test_RtlUpperChar()

static void test_RtlUpperChar ( void  )

static

Definition at line 522 of file rtlstr.c.

{
    int ch;
    int upper_ch;
    int expected_upper_ch;
    int byte_ch;
 
    for (ch = -1; ch <= 1024; ch++) {
    upper_ch = pRtlUpperChar(ch);
    byte_ch = ch & 0xff;
    if (byte_ch >= 'a' && byte_ch <= 'z') {
        expected_upper_ch = (CHAR) (byte_ch - 'a' + 'A');
    } else {
        expected_upper_ch = (CHAR) byte_ch;
    }
    ok(upper_ch == expected_upper_ch,
       "RtlUpperChar('%c'[=0x%x]) has result '%c'[=0x%x], expected '%c'[=0x%x]\n",
       ch, ch, upper_ch, upper_ch, expected_upper_ch, expected_upper_ch);
    }
}

Referenced by START_TEST().

test_RtlUpperString()

static void test_RtlUpperString ( void  )

static

Definition at line 544 of file rtlstr.c.

{
    int i;
    CHAR ch;
    CHAR upper_ch;
    char ascii_buf[257];
    char result_buf[257];
    char upper_buf[257];
    STRING ascii_str;
    STRING result_str;
    STRING upper_str;
 
    for (i = 0; i <= 255; i++) {
    ch = (CHAR) i;
    if (ch >= 'a' && ch <= 'z') {
        upper_ch = ch - 'a' + 'A';
    } else {
        upper_ch = ch;
    }
    ascii_buf[i] = ch;
    result_buf[i] = '\0';
    upper_buf[i] = upper_ch;
    }
    ascii_buf[i] = '\0';
    result_buf[i] = '\0';
    upper_buf[i] = '\0';
    ascii_str.Length = 256;
    ascii_str.MaximumLength = 256;
    ascii_str.Buffer = ascii_buf;
    result_str.Length = 256;
    result_str.MaximumLength = 256;
    result_str.Buffer = result_buf;
    upper_str.Length = 256;
    upper_str.MaximumLength = 256;
    upper_str.Buffer = upper_buf;
 
    pRtlUpperString(&result_str, &ascii_str);
    ok(memcmp(result_str.Buffer, upper_str.Buffer, 256) == 0,
       "RtlUpperString does not work as expected\n");
}

Referenced by START_TEST().

test_RtlUTF8ToUnicodeN()

static void test_RtlUTF8ToUnicodeN ( void  )

static

Definition at line 2457 of file rtlstr.c.

{
    NTSTATUS status;
    ULONG bytes_out;
    ULONG bytes_out_array[2];
    void * const invalid_pointer = (void *)0x8;
    WCHAR buffer[128];
    const char empty_string[] = "";
    const char test_string[] = "A\0abcdefg";
    const WCHAR test_stringW[] = {'A',0,'a','b','c','d','e','f','g',0 };
    const char special_string[] = { 'X',0xc2,0x80,0xF0,0x90,0x80,0x80,0 };
    const WCHAR special_expected[] = { 'X',0x80,0xd800,0xdc00,0 };
    unsigned int input_len;
    const unsigned int test_count = ARRAY_SIZE(utf8_to_unicode);
    unsigned int i, ret;
 
    if (!pRtlUTF8ToUnicodeN)
    {
        win_skip("RtlUTF8ToUnicodeN is not available\n");
        return;
    }
 
    /* show that bytes_out is really ULONG */
    memset(bytes_out_array, 0x55, sizeof(bytes_out_array));
    status = pRtlUTF8ToUnicodeN(NULL, 0, bytes_out_array, empty_string, 0);
    ok(status == STATUS_SUCCESS, "status = 0x%lx\n", status);
    ok(bytes_out_array[0] == 0x00000000, "Got 0x%lx\n", bytes_out_array[0]);
    ok(bytes_out_array[1] == 0x55555555, "Got 0x%lx\n", bytes_out_array[1]);
 
    /* parameter checks */
    status = pRtlUTF8ToUnicodeN(NULL, 0, NULL, NULL, 0);
    ok(status == STATUS_INVALID_PARAMETER_4, "status = 0x%lx\n", status);
 
    status = pRtlUTF8ToUnicodeN(NULL, 0, NULL, empty_string, 0);
    ok(status == STATUS_INVALID_PARAMETER, "status = 0x%lx\n", status);
 
    bytes_out = 0x55555555;
    status = pRtlUTF8ToUnicodeN(NULL, 0, &bytes_out, NULL, 0);
    ok(status == STATUS_INVALID_PARAMETER_4, "status = 0x%lx\n", status);
    ok(bytes_out == 0x55555555, "bytes_out = 0x%lx\n", bytes_out);
 
    bytes_out = 0x55555555;
    status = pRtlUTF8ToUnicodeN(NULL, 0, &bytes_out, invalid_pointer, 0);
    ok(status == STATUS_SUCCESS, "status = 0x%lx\n", status);
    ok(bytes_out == 0, "bytes_out = 0x%lx\n", bytes_out);
 
    bytes_out = 0x55555555;
    status = pRtlUTF8ToUnicodeN(NULL, 0, &bytes_out, empty_string, 0);
    ok(status == STATUS_SUCCESS, "status = 0x%lx\n", status);
    ok(bytes_out == 0, "bytes_out = 0x%lx\n", bytes_out);
 
    bytes_out = 0x55555555;
    status = pRtlUTF8ToUnicodeN(NULL, 0, &bytes_out, test_string, 0);
    ok(status == STATUS_SUCCESS, "status = 0x%lx\n", status);
    ok(bytes_out == 0, "bytes_out = 0x%lx\n", bytes_out);
 
    bytes_out = 0x55555555;
    status = pRtlUTF8ToUnicodeN(NULL, 0, &bytes_out, empty_string, 1);
    ok(status == STATUS_SUCCESS, "status = 0x%lx\n", status);
    ok(bytes_out == sizeof(WCHAR), "bytes_out = 0x%lx\n", bytes_out);
 
    /* length output with special chars */
#define length_expect(in_chars, out_chars, expect_status) \
        unicode_expect_(NULL, 0, out_chars, special_string, in_chars, \
                        expect_status, __LINE__)
 
    length_expect(0, 0, STATUS_SUCCESS);
    length_expect(1, 1, STATUS_SUCCESS);
    length_expect(2, 2, STATUS_SOME_NOT_MAPPED);
    length_expect(3, 2, STATUS_SUCCESS);
    length_expect(4, 3, STATUS_SOME_NOT_MAPPED);
    length_expect(5, 3, STATUS_SOME_NOT_MAPPED);
    length_expect(6, 3, STATUS_SOME_NOT_MAPPED);
    length_expect(7, 4, STATUS_SUCCESS);
    length_expect(8, 5, STATUS_SUCCESS);
#undef length_expect
 
    /* output truncation */
#define truncate_expect(buflen, out_chars, expect_status) \
        unicode_expect_(special_expected, buflen, out_chars, \
                        special_string, sizeof(special_string), \
                        expect_status, __LINE__)
 
    truncate_expect( 0, 0, STATUS_BUFFER_TOO_SMALL);
    truncate_expect( 1, 0, STATUS_BUFFER_TOO_SMALL);
    truncate_expect( 2, 1, STATUS_BUFFER_TOO_SMALL);
    truncate_expect( 3, 1, STATUS_BUFFER_TOO_SMALL);
    truncate_expect( 4, 2, STATUS_BUFFER_TOO_SMALL);
    truncate_expect( 5, 2, STATUS_BUFFER_TOO_SMALL);
    truncate_expect( 6, 3, STATUS_BUFFER_TOO_SMALL);
    truncate_expect( 7, 3, STATUS_BUFFER_TOO_SMALL);
    truncate_expect( 8, 4, STATUS_BUFFER_TOO_SMALL);
    truncate_expect( 9, 4, STATUS_BUFFER_TOO_SMALL);
    truncate_expect(10, 5, STATUS_SUCCESS);
#undef truncate_expect
 
    /* conversion behavior with varying input length */
    for (input_len = 0; input_len <= sizeof(test_string); input_len++) {
        /* no output buffer, just length */
        unicode_expect(NULL, 0, input_len,
                       test_string, input_len, STATUS_SUCCESS);
 
        /* write output */
        unicode_expect(test_stringW, -1, input_len,
                       test_string, input_len, STATUS_SUCCESS);
    }
 
    /* test cases for special characters */
    for (i = 0; i < test_count; i++) {
        bytes_out = 0x55555555;
        memset(buffer, 0x55, sizeof(buffer));
        status = pRtlUTF8ToUnicodeN(
            buffer, sizeof(buffer), &bytes_out,
            utf8_to_unicode[i].utf8, strlen(utf8_to_unicode[i].utf8));
        ok(status == utf8_to_unicode[i].status,
           "(test %d): status is 0x%lx, expected 0x%lx\n",
           i, status, utf8_to_unicode[i].status);
        ok(bytes_out == lstrlenW(utf8_to_unicode[i].expected) * sizeof(WCHAR),
           "(test %d): bytes_out is %lu, expected %lu\n",
           i, bytes_out, lstrlenW(utf8_to_unicode[i].expected) * (ULONG)sizeof(WCHAR));
        ok(!memcmp(buffer, utf8_to_unicode[i].expected, bytes_out),
           "(test %d): got %s, expected %s\n",
           i, wine_dbgstr_wn(buffer, bytes_out / sizeof(WCHAR)), wine_dbgstr_w(utf8_to_unicode[i].expected));
        ok(buffer[bytes_out / sizeof(WCHAR)] == 0x5555,
           "(test %d): behind string: 0x%x\n", i, buffer[bytes_out / sizeof(WCHAR)]);
        memset(buffer, 0x55, sizeof(buffer));
        ret = MultiByteToWideChar( CP_UTF8, 0, utf8_to_unicode[i].utf8, strlen(utf8_to_unicode[i].utf8),
                                   buffer, ARRAY_SIZE(buffer) );
        ok( ret == lstrlenW(utf8_to_unicode[i].expected), "(test %d): wrong len %u\n", i, ret );
        ok(!memcmp(buffer, utf8_to_unicode[i].expected, lstrlenW(utf8_to_unicode[i].expected) * sizeof(WCHAR)),
           "(test %d): got %s, expected %s\n",
           i, wine_dbgstr_wn(buffer, ret), wine_dbgstr_w(utf8_to_unicode[i].expected));
        ok(buffer[ret] == 0x5555,
           "(test %d): behind string: 0x%x\n", i, buffer[ret]);
 
        /* same test but include the null terminator */
        bytes_out = 0x55555555;
        memset(buffer, 0x55, sizeof(buffer));
        status = pRtlUTF8ToUnicodeN(
            buffer, sizeof(buffer), &bytes_out,
            utf8_to_unicode[i].utf8, strlen(utf8_to_unicode[i].utf8) + 1);
        ok(status == utf8_to_unicode[i].status,
           "(test %d): status is 0x%lx, expected 0x%lx\n",
           i, status, utf8_to_unicode[i].status);
        ok(bytes_out == (lstrlenW(utf8_to_unicode[i].expected) + 1) * sizeof(WCHAR),
           "(test %d): bytes_out is %lu, expected %lu\n",
           i, bytes_out, (lstrlenW(utf8_to_unicode[i].expected) + 1) * (ULONG)sizeof(WCHAR));
        ok(!memcmp(buffer, utf8_to_unicode[i].expected, bytes_out),
           "(test %d): got %s, expected %s\n",
           i, wine_dbgstr_wn(buffer, bytes_out / sizeof(WCHAR)), wine_dbgstr_w(utf8_to_unicode[i].expected));
        ok(buffer[bytes_out / sizeof(WCHAR)] == 0x5555,
           "(test %d): behind string: 0x%x\n", i, buffer[bytes_out / sizeof(WCHAR)]);
 
        memset(buffer, 0x55, sizeof(buffer));
        ret = MultiByteToWideChar( CP_UTF8, 0, utf8_to_unicode[i].utf8, -1, buffer, ARRAY_SIZE(buffer) );
        ok( ret == lstrlenW(utf8_to_unicode[i].expected) + 1, "(test %d): wrong len %u\n", i, ret );
        ok(!memcmp(buffer, utf8_to_unicode[i].expected, ret * sizeof(WCHAR)),
           "(test %d): got %s, expected %s\n",
           i, wine_dbgstr_wn(buffer, ret), wine_dbgstr_w(utf8_to_unicode[i].expected));
        ok(buffer[ret] == 0x5555,
           "(test %d): behind string: 0x%x\n", i, buffer[ret]);
 
        SetLastError( 0xdeadbeef );
        memset(buffer, 0x55, sizeof(buffer));
        ret = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS,
                                   utf8_to_unicode[i].utf8, -1, buffer, ARRAY_SIZE(buffer) );
        if (utf8_to_unicode[i].status == STATUS_SOME_NOT_MAPPED)
        {
            ok( ret == 0, "(test %d): wrong len %u\n", i, ret );
            ok( GetLastError() == ERROR_NO_UNICODE_TRANSLATION, "(test %d): wrong error %lu\n", i, GetLastError() );
            ret = lstrlenW(utf8_to_unicode[i].expected) + 1;
        }
        else
            ok( ret == lstrlenW(utf8_to_unicode[i].expected) + 1, "(test %d): wrong len %u\n", i, ret );
 
        ok(!memcmp(buffer, utf8_to_unicode[i].expected, ret * sizeof(WCHAR)),
           "(test %d): got %s, expected %s\n",
           i, wine_dbgstr_wn(buffer, ret), wine_dbgstr_w(utf8_to_unicode[i].expected));
        ok(buffer[ret] == 0x5555,
           "(test %d): behind string: 0x%x\n", i, buffer[ret]);
    }
}

Referenced by START_TEST().

testfmt()

static void WINAPIV testfmt ( const WCHAR *  src, const WCHAR *  expect, ULONG  width, BOOL  ansi,   ...  )

static

Definition at line 2653 of file rtlstr.c.

{
    va_list args;
    NTSTATUS status;
    WCHAR buffer[128];
    ULONG size = 0xdeadbeef;
 
    memset( buffer, 0xcc, sizeof(buffer) );
    va_start( args, ansi );
    status = pRtlFormatMessage( src, width, FALSE, ansi, FALSE, &args, buffer, sizeof(buffer), &size );
    va_end( args );
    ok( !status, "%s: failed %lx\n", debugstr_w(src), status );
    ok( !lstrcmpW( buffer, expect ), "%s: got %s expected %s\n", debugstr_w(src),
        debugstr_w(buffer), debugstr_w(expect) );
    ok( size == (lstrlenW(expect) + 1) * sizeof(WCHAR), "%s: wrong size %lu\n", debugstr_w(src), size );
}

Referenced by test_RtlFormatMessage().

testfmt_arg_eaten()

static void testfmt_arg_eaten ( const WCHAR *  src,   ...  )

static

Definition at line 2670 of file rtlstr.c.

{
    va_list args;
    NTSTATUS status;
    WCHAR *arg, buffer[1];
    ULONG size = 0xdeadbeef;
 
    buffer[0] = 0xcccc;
    va_start( args, src );
    status = pRtlFormatMessage( src, 0, FALSE, FALSE, FALSE, &args, buffer, ARRAY_SIZE(buffer), &size );
    ok( status == STATUS_BUFFER_OVERFLOW, "%s: failed %lx\n", debugstr_w(src), status );
    todo_wine
    ok( buffer[0] == 0xcccc, "%s: got %x\n", debugstr_w(src), buffer[0] );
    ok( size == 0xdeadbeef, "%s: wrong size %lu\n", debugstr_w(src), size );
    arg = va_arg( args, WCHAR * );
    ok( !wcscmp( L"unused", arg ), "%s: wrong arg %s\n", debugstr_w(src), debugstr_w(arg) );
    va_end( args );
}

Referenced by test_RtlFormatMessage().

unicode_expect_()

static void unicode_expect_ ( const WCHAR *  out_string, ULONG  buflen, ULONG  out_chars, const char *  in_string, ULONG  in_chars, NTSTATUS  expect_status, int  line  )

static

Definition at line 2423 of file rtlstr.c.

{
    NTSTATUS status;
    ULONG bytes_out;
    WCHAR buffer[128];
    unsigned int i;
 
    if (buflen == (ULONG)-1)
        buflen = sizeof(buffer);
    bytes_out = 0x55555555;
    memset(buffer, 0x55, sizeof(buffer));
    status = pRtlUTF8ToUnicodeN(
        out_string ? buffer : NULL, buflen, &bytes_out,
        in_string, in_chars);
    ok_(__FILE__, line)(status == expect_status, "status = 0x%lx\n", status);
    ok_(__FILE__, line)(bytes_out == out_chars * sizeof(WCHAR),
                        "bytes_out = %lu, expected %lu\n", bytes_out, out_chars * (ULONG)sizeof(WCHAR));
    if (out_string)
    {
        for (i = 0; i < bytes_out / sizeof(WCHAR); i++)
            ok_(__FILE__, line)(buffer[i] == out_string[i],
                                "buffer[%d] = 0x%x, expected 0x%x\n",
                                i, buffer[i], out_string[i]);
        for (; i < ARRAY_SIZE(buffer); i++)
            ok_(__FILE__, line)(buffer[i] == 0x5555,
                                "buffer[%d] = 0x%x, expected 0x5555\n",
                                i, buffer[i]);
    }
}

utf8_expect_()

static void utf8_expect_ ( const unsigned char *  out_string, ULONG  buflen, ULONG  out_bytes, const WCHAR *  in_string, ULONG  in_bytes, NTSTATUS  expect_status, int  line  )

static

Definition at line 2090 of file rtlstr.c.

{
    NTSTATUS status;
    ULONG bytes_out;
    char buffer[128];
    unsigned char *buf = (unsigned char *)buffer;
    unsigned int i;
 
    if (buflen == (ULONG)-1)
        buflen = sizeof(buffer);
    bytes_out = 0x55555555;
    memset(buffer, 0x55, sizeof(buffer));
    status = pRtlUnicodeToUTF8N(
        out_string ? buffer : NULL, buflen, &bytes_out,
        in_string, in_bytes);
    ok_(__FILE__, line)(status == expect_status, "status 0x%lx, expected 0x%lx\n", status, expect_status);
    ok_(__FILE__, line)(bytes_out == out_bytes, "bytes_out = %lu, expected %lu\n", bytes_out, out_bytes);
    if (out_string)
    {
        for (i = 0; i < bytes_out; i++)
            ok_(__FILE__, line)(buf[i] == out_string[i],
                                "buffer[%d] = 0x%x, expected 0x%x\n",
                                i, buf[i], out_string[i]);
        for (; i < sizeof(buffer); i++)
            ok_(__FILE__, line)(buf[i] == 0x55,
                                "buffer[%d] = 0x%x, expected 0x55\n",
                                i, buf[i]);
    }
}

VOID()

static VOID ( WINAPI *  pRtlCopyString )

static

WCHAR()

static int *static WCHAR ( WINAPI *  pRtlUpcaseUnicodeChar )

static

Variable Documentation

app_asc2str

const app_asc2str_t app_asc2str[]

static

Initial value:

= {
    { 5, 12, 15,  "TestS01234abcde", "tring", 10, 12, 15,  "TestStringabcde", STATUS_SUCCESS},
    { 5, 11, 15,  "TestS01234abcde", "tring", 10, 11, 15,  "TestStringabcde", STATUS_SUCCESS},
    { 5, 10, 15,  "TestS01234abcde", "tring", 10, 10, 15,  "TestStringabcde", STATUS_SUCCESS},
    { 5,  9, 15,  "TestS01234abcde", "tring",  5,  9, 15,  "TestS01234abcde", STATUS_BUFFER_TOO_SMALL},
    { 5,  0, 15,  "TestS01234abcde", "tring",  5,  0, 15,  "TestS01234abcde", STATUS_BUFFER_TOO_SMALL},
    { 5, 14, 15,  "TestS01234abcde", "tring", 10, 14, 15,  "TestStringabcde", STATUS_SUCCESS},
    { 5, 14, 15,  "TestS01234abcde",    NULL,  5, 14, 15,  "TestS01234abcde", STATUS_SUCCESS},
    { 5, 14, 15,               NULL,    NULL,  5, 14, 15,               NULL, STATUS_SUCCESS},
    { 5, 12, 15, "Tst\0S01234abcde", "tr\0i",  7, 12, 15, "Tst\0Str234abcde", STATUS_SUCCESS},
}

Definition at line 885 of file rtlstr.c.

Referenced by test_RtlAppendAsciizToString().

app_str2str

const app_str2str_t app_str2str[]

static

Initial value:

= {
    { 5, 12, 15,  "TestS01234abcde", 5, 5, 7, "tringZY", 10, 12, 15,   "TestStringabcde", STATUS_SUCCESS},
    { 5, 11, 15,  "TestS01234abcde", 5, 5, 7, "tringZY", 10, 11, 15,   "TestStringabcde", STATUS_SUCCESS},
    { 5, 10, 15,  "TestS01234abcde", 5, 5, 7, "tringZY", 10, 10, 15,   "TestStringabcde", STATUS_SUCCESS},
    { 5,  9, 15,  "TestS01234abcde", 5, 5, 7, "tringZY",  5,  9, 15,   "TestS01234abcde", STATUS_BUFFER_TOO_SMALL},
    { 5,  0, 15,  "TestS01234abcde", 0, 0, 7, "tringZY",  5,  0, 15,   "TestS01234abcde", STATUS_SUCCESS},
    { 5, 14, 15,  "TestS01234abcde", 0, 0, 7, "tringZY",  5, 14, 15,   "TestS01234abcde", STATUS_SUCCESS},
    { 5, 14, 15,  "TestS01234abcde", 0, 0, 7,      NULL,  5, 14, 15,   "TestS01234abcde", STATUS_SUCCESS},
    { 5, 14, 15,               NULL, 0, 0, 7,      NULL,  5, 14, 15,                NULL, STATUS_SUCCESS},
    { 5, 12, 15, "Tst\0S01234abcde", 4, 4, 7, "tr\0iZY",  9, 12, 15, "Tst\0Str\0i4abcde", STATUS_SUCCESS},
}

Definition at line 954 of file rtlstr.c.

Referenced by test_RtlAppendStringToString().

app_uni2str

const app_uni2str_t app_uni2str[]

static

Initial value:

= {
    { 4, 12, 14,     "Fake0123abcdef",    "Ustr\0",  8, 12, 14,  "FakeUstr\0\0cdef", STATUS_SUCCESS},
    { 4, 11, 14,     "Fake0123abcdef",    "Ustr\0",  8, 11, 14,  "FakeUstr\0\0cdef", STATUS_SUCCESS},
    { 4, 10, 14,     "Fake0123abcdef",    "Ustr\0",  8, 10, 14,  "FakeUstr\0\0cdef", STATUS_SUCCESS},
 
    { 4,  8, 14,     "Fake0123abcdef",    "Ustr\0",  8,  8, 14,    "FakeUstrabcdef", STATUS_SUCCESS},
    { 4,  7, 14,     "Fake0123abcdef",    "Ustr\0",  4,  7, 14,    "Fake0123abcdef", STATUS_BUFFER_TOO_SMALL},
    { 4,  0, 14,     "Fake0123abcdef",    "Ustr\0",  4,  0, 14,    "Fake0123abcdef", STATUS_BUFFER_TOO_SMALL},
    { 4, 14, 14,     "Fake0123abcdef",    "Ustr\0",  8, 14, 14,  "FakeUstr\0\0cdef", STATUS_SUCCESS},
    { 4, 14, 14,     "Fake0123abcdef",        NULL,  4, 14, 14,    "Fake0123abcdef", STATUS_SUCCESS},
    { 4, 14, 14,                 NULL,        NULL,  4, 14, 14,                NULL, STATUS_SUCCESS},
    { 4, 14, 14,     "Fake0123abcdef", "U\0stri\0", 10, 14, 14, "FakeU\0stri\0\0ef", STATUS_SUCCESS},
    { 6, 14, 16, "Te\0\0stabcdefghij",  "St\0\0ri",  8, 14, 16, "Te\0\0stSt\0\0efghij", STATUS_SUCCESS},
}

Definition at line 1031 of file rtlstr.c.

Referenced by test_RtlAppendUnicodeToString().

app_ustr2str

const app_ustr2str_t app_ustr2str[]

static

Initial value:

= {
    { 4, 12, 14,     "Fake0123abcdef", 4, 6, 8,   "UstrZYXW",  8, 12, 14,   "FakeUstr\0\0cdef", STATUS_SUCCESS},
    { 4, 11, 14,     "Fake0123abcdef", 4, 6, 8,   "UstrZYXW",  8, 11, 14,   "FakeUstr\0\0cdef", STATUS_SUCCESS},
    { 4, 10, 14,     "Fake0123abcdef", 4, 6, 8,   "UstrZYXW",  8, 10, 14,   "FakeUstr\0\0cdef", STATUS_SUCCESS},
 
    { 4,  8, 14,     "Fake0123abcdef", 4, 6, 8,   "UstrZYXW",  8,  8, 14,     "FakeUstrabcdef", STATUS_SUCCESS},
    { 4,  7, 14,     "Fake0123abcdef", 4, 6, 8,   "UstrZYXW",  4,  7, 14,     "Fake0123abcdef", STATUS_BUFFER_TOO_SMALL},
    { 4,  0, 14,     "Fake0123abcdef", 0, 0, 8,   "UstrZYXW",  4,  0, 14,     "Fake0123abcdef", STATUS_SUCCESS},
    { 4, 14, 14,     "Fake0123abcdef", 0, 0, 8,   "UstrZYXW",  4, 14, 14,     "Fake0123abcdef", STATUS_SUCCESS},
    { 4, 14, 14,     "Fake0123abcdef", 0, 0, 8,         NULL,  4, 14, 14,     "Fake0123abcdef", STATUS_SUCCESS},
    { 4, 14, 14,                 NULL, 0, 0, 8,         NULL,  4, 14, 14,                 NULL, STATUS_SUCCESS},
    { 6, 14, 16, "Te\0\0stabcdefghij", 6, 8, 8, "St\0\0riZY", 12, 14, 16, "Te\0\0stSt\0\0ri\0\0ij", STATUS_SUCCESS},
}

Definition at line 1105 of file rtlstr.c.

Referenced by test_RtlAppendUnicodeStringToString().

BOOLEAN

BOOLEAN

Definition at line 41 of file rtlstr.c.

dupl_ustr

const dupl_ustr_t dupl_ustr[]

static

Definition at line 340 of file rtlstr.c.

Referenced by test_RtlDuplicateUnicodeString().

find_ch_in_ustr

const find_ch_in_ustr_t find_ch_in_ustr[]

static

Definition at line 1181 of file rtlstr.c.

Referenced by test_RtlFindCharInUnicodeString().

hash_test

const struct hash_unicodestring_test hash_test[]

static

Initial value:

= {
    { L"T",         FALSE, 0x00000054 },
    { L"Test",      FALSE, 0x766bb952 },
    { L"TeSt",      FALSE, 0x764bb172 },
    { L"test",      FALSE, 0x4745d132 },
    { L"test",      TRUE,  0x6689c132 },
    { L"TEST",      TRUE,  0x6689c132 },
    { L"TEST",      FALSE, 0x6689c132 },
    { L"t\xe9st",   FALSE, 0x8845cfb6 },
    { L"t\xe9st",   TRUE,  0xa789bfb6 },
    { L"T\xc9ST",   TRUE,  0xa789bfb6 },
    { L"T\xc9ST",   FALSE, 0xa789bfb6 },
    { L"abcdef",    FALSE, 0x971318c3 },
    { { 0 } }
}

Definition at line 1989 of file rtlstr.c.

Referenced by test_RtlHashUnicodeString().

hntdll

HMODULE hntdll = 0

static

Definition at line 40 of file rtlstr.c.

Referenced by InitFunctionPtrs().

int

int

Definition at line 66 of file rtlstr.c.

INT

const STRING *static UNICODE_STRING *static GUID *static UNICODE_STRING *static INT

Definition at line 74 of file rtlstr.c.

int2str

const int2str_t int2str[]

static

Definition at line 1534 of file rtlstr.c.

Referenced by one_RtlIntegerToChar_test(), one_RtlIntegerToUnicodeString_test(), test_RtlIntegerToChar(), and test_RtlIntegerToUnicodeString().

LONG

UNICODE_STRING *static LONG

Definition at line 64 of file rtlstr.c.

LPCSTR

LPCSTR

Definition at line 42 of file rtlstr.c.

LPCWSTR

LPCWSTR

Definition at line 45 of file rtlstr.c.

LPWSTR

va_list LPWSTR

Definition at line 78 of file rtlstr.c.

Referenced by test_RtlGUIDFromString().

PCANSI_STRING

PCANSI_STRING

Definition at line 41 of file rtlstr.c.

PCHAR

PCHAR

Definition at line 62 of file rtlstr.c.

Referenced by RtlInitLargeAnsiString().

SIZE_T

const WCHAR SIZE_T

Definition at line 48 of file rtlstr.c.

str2int

const str2int_t str2int[]

static

Definition at line 1296 of file rtlstr.c.

Referenced by test_RtlCharToInteger(), and test_RtlUnicodeStringToInteger().

szGuid

const WCHAR szGuid[]

static

Initial value:

= { '{','0','1','0','2','0','3','0','4','-',
  '0','5','0','6','-'  ,'0','7','0','8','-','0','9','0','A','-',
  '0','B','0','C','0','D','0','E','0','F','0','A','}','\0' }

Definition at line 1928 of file rtlstr.c.

Referenced by ATL::CComBSTR::CComBSTR(), CreateTipText(), do_enum(), CCategoryMgr::FindClosestCategory(), FindProviderIndex(), InitProbeListPage(), CCategoryMgr::RegisterCategory(), CShellLink::SetAdvertiseInfo(), test_RtlGUIDFromString(), test_RtlStringFromGUID(), and CCategoryMgr::UnregisterCategory().

szGuid2

const WCHAR szGuid2[]

static

Initial value:

= { '{','0','1','0','2','0','3','0','4','-',
  '0','5','0','6','-'  ,'0','7','0','8','-','0','9','0','A','-',
  '0','B','0','C','0','D','0','E','0','F','0','A',']','\0' }

Definition at line 1931 of file rtlstr.c.

Referenced by test_RtlGUIDFromString().

ULONG

va_list ULONG

Definition at line 46 of file rtlstr.c.

unicode_to_utf8

const struct unicode_to_utf8_test unicode_to_utf8[]

static

Definition at line 2057 of file rtlstr.c.

Referenced by test_RtlUnicodeToUTF8N().

ustr2astr

const ustr2astr_t ustr2astr[]

static

Initial value:

= {
    { 10, 12, 12, "------------",  0,  0,  0, "",       TRUE,  0, 1, 1, "",       STATUS_SUCCESS},
    { 10, 12, 12, "------------", 12, 12, 12, "abcdef", TRUE,  6, 7, 7, "abcdef", STATUS_SUCCESS},
    {  0,  2, 12, "------------", 12, 12, 12, "abcdef", TRUE,  6, 7, 7, "abcdef", STATUS_SUCCESS},
    { 10, 12, 12, NULL,           12, 12, 12, "abcdef", TRUE,  6, 7, 7, "abcdef", STATUS_SUCCESS},
    {  0,  0, 12, "------------", 12, 12, 12, "abcdef", FALSE, 6, 0, 0, "",       STATUS_BUFFER_OVERFLOW, 1},
    {  0,  1, 12, "------------", 12, 12, 12, "abcdef", FALSE, 0, 1, 1, "",       STATUS_BUFFER_OVERFLOW},
    {  0,  2, 12, "------------", 12, 12, 12, "abcdef", FALSE, 1, 2, 2, "a",      STATUS_BUFFER_OVERFLOW},
    {  0,  3, 12, "------------", 12, 12, 12, "abcdef", FALSE, 2, 3, 3, "ab",     STATUS_BUFFER_OVERFLOW},
    {  0,  5, 12, "------------", 12, 12, 12, "abcdef", FALSE, 4, 5, 5, "abcd",   STATUS_BUFFER_OVERFLOW},
    {  8,  5, 12, "------------", 12, 12, 12, "abcdef", FALSE, 4, 5, 5, "abcd",   STATUS_BUFFER_OVERFLOW},
    {  8,  6, 12, "------------", 12, 12, 12, "abcdef", FALSE, 5, 6, 6, "abcde",  STATUS_BUFFER_OVERFLOW},
    {  8,  7, 12, "------------", 12, 12, 12, "abcdef", FALSE, 6, 7, 7, "abcdef", STATUS_SUCCESS},
    {  8,  7, 12, "------------",  0, 12, 12,  NULL,    FALSE, 0, 7, 0, "",       STATUS_SUCCESS},
 
 
 
 
}

Definition at line 801 of file rtlstr.c.

Referenced by test_RtlUnicodeStringToAnsiString().

utf8_to_unicode

const struct utf8_to_unicode_test utf8_to_unicode[]

static

Definition at line 2338 of file rtlstr.c.

Referenced by test_RtlUTF8ToUnicodeN().