some ntdll functions (3) - part 2: tests

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hello

Here are the tests for some ntdll functions.
These tests require the functions implemented in
part 1 of this patch (see part1: functions).

Changelog:

	* dlls/ntdll/tests/Makefile.in,
	  dlls/ntdll/tests/rtlstr.c,
	  dlls/ntdll/tests/rtl.c:
	Thomas Mertes <thomas.mertes@gmx.at>
	- Tests for RtlCompareMemoryUlong,
	  RtlUniform, RtlDowncaseUnicodeString,
	  RtlAppendUnicodeStringToString

Greetings
Thomas Mertes

-- 
+++ GMX - Mail, Messaging & more  http://www.gmx.net +++
Bitte lächeln! Fotogalerie online mit GMX ohne eigene Homepage!
diff -urN old_wine-20030318/dlls/ntdll/tests/Makefile.in new_wine-20030318/dlls/ntdll/tests/Makefile.in
--- old_wine-20030318/dlls/ntdll/tests/Makefile.in	Tue Mar 18 19:27:19 2003
+++ new_wine-20030318/dlls/ntdll/tests/Makefile.in	Fri Mar 21 01:59:25 2003
@@ -9,6 +9,7 @@
 	error.c \
 	generated.c \
 	large_int.c \
+	rtl.c \
 	rtlbitmap.c \
 	rtlstr.c \
 	string.c
diff -urN old_wine-20030318/dlls/ntdll/tests/rtl.c new_wine-20030318/dlls/ntdll/tests/rtl.c
--- old_wine-20030318/dlls/ntdll/tests/rtl.c	Thu Jan  1 01:00:00 1970
+++ new_wine-20030318/dlls/ntdll/tests/rtl.c	Fri Mar 21 01:59:08 2003
@@ -0,0 +1,335 @@
+/* Unit test suite for Rtl* API functions
+ *
+ * Copyright 2003 Thomas Mertes
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * NOTES
+ * We use function pointers here as there is no import library for NTDLL on
+ * windows.
+ */
+
+#include <stdlib.h>
+
+#include "winbase.h"
+#include "wine/test.h"
+#include "winnt.h"
+#include "winnls.h"
+#include "winternl.h"
+
+/* Function ptrs for ntdll calls */
+static HMODULE hntdll = 0;
+static SIZE_T    (WINAPI *pRtlCompareMemoryUlong)(PULONG, SIZE_T, ULONG);
+static ULONG     (WINAPI *pRtlUniform)(PULONG);
+
+
+static void InitFunctionPtrs(void)
+{
+    hntdll = LoadLibraryA("ntdll.dll");
+    ok(hntdll != 0, "LoadLibrary failed");
+    if (hntdll) {
+	pRtlCompareMemoryUlong = (void *)GetProcAddress(hntdll, "RtlCompareMemoryUlong");
+	pRtlUniform = (void *)GetProcAddress(hntdll, "RtlUniform");
+    } /* if */
+}
+
+
+static void test_RtlCompareMemoryUlong(void)
+{
+    ULONG a[10];
+    ULONG result;
+
+    a[0]= 0x0123;
+    a[1]= 0x4567;
+    a[2]= 0x89ab;
+    a[3]= 0xcdef;
+    result = pRtlCompareMemoryUlong(a, 0, 0x0123);
+    ok(result == 0, "RtlCompareMemoryUlong(%p, 0, 0x0123) returns %lu, expected 0\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 3, 0x0123);
+    ok(result == 0, "RtlCompareMemoryUlong(%p, 3, 0x0123) returns %lu, expected 0\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 4, 0x0123);
+    ok(result == 4, "RtlCompareMemoryUlong(%p, 4, 0x0123) returns %lu, expected 4\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 5, 0x0123);
+    ok(result == 4, "RtlCompareMemoryUlong(%p, 5, 0x0123) returns %lu, expected 4\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 7, 0x0123);
+    ok(result == 4, "RtlCompareMemoryUlong(%p, 7, 0x0123) returns %lu, expected 4\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 8, 0x0123);
+    ok(result == 4, "RtlCompareMemoryUlong(%p, 8, 0x0123) returns %lu, expected 4\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 9, 0x0123);
+    ok(result == 4, "RtlCompareMemoryUlong(%p, 9, 0x0123) returns %lu, expected 4\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 4, 0x0127);
+    ok(result == 0, "RtlCompareMemoryUlong(%p, 4, 0x0127) returns %lu, expected 0\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 4, 0x7123);
+    ok(result == 0, "RtlCompareMemoryUlong(%p, 4, 0x7123) returns %lu, expected 0\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 16, 0x4567);
+    ok(result == 0, "RtlCompareMemoryUlong(%p, 16, 0x4567) returns %lu, expected 0\n", a, result);
+
+    a[1]= 0x0123;
+    result = pRtlCompareMemoryUlong(a, 3, 0x0123);
+    ok(result == 0, "RtlCompareMemoryUlong(%p, 3, 0x0123) returns %lu, expected 0\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 4, 0x0123);
+    ok(result == 4, "RtlCompareMemoryUlong(%p, 4, 0x0123) returns %lu, expected 4\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 5, 0x0123);
+    ok(result == 4, "RtlCompareMemoryUlong(%p, 5, 0x0123) returns %lu, expected 4\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 7, 0x0123);
+    ok(result == 4, "RtlCompareMemoryUlong(%p, 7, 0x0123) returns %lu, expected 4\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 8, 0x0123);
+    ok(result == 8, "RtlCompareMemoryUlong(%p, 8, 0x0123) returns %lu, expected 8\n", a, result);
+    result = pRtlCompareMemoryUlong(a, 9, 0x0123);
+    ok(result == 8, "RtlCompareMemoryUlong(%p, 9, 0x0123) returns %lu, expected 8\n", a, result);
+}
+
+
+static void test_RtlUniform(void)
+{
+    ULONGLONG num;
+    ULONG seed;
+    ULONG seed_bak;
+    ULONG expected;
+    ULONG result;
+
+/*
+ * According to the documentation RtlUniform is using D.H. Lehmer's 1948
+ * algorithm. This algorithm is:
+ *
+ * seed = (seed * const_1 + const_2) % const_3;
+ *
+ * According to the documentation the random number is distributed over
+ * [0..MAXLONG]. Therefore const_3 is MAXLONG + 1:
+ *
+ * seed = (seed * const_1 + const_2) % (MAXLONG + 1);
+ *
+ * Because MAXLONG is 0xfffffff (which is 0x10000000 - 1) the algorithm
+ * can be expressed as:
+ *
+ * seed = (seed * const_1 + const_2) & MAXLONG;
+ *
+ * To find out const_2 we just call RtlUniform with seed set to 0:
+ */
+    seed = 0;
+    expected = 0x7fffffc3;
+    result = pRtlUniform(&seed);
+    ok(result == expected,
+        "RtlUniform(&seed (seed == 0)) returns %lx, expected %lx",
+        result, expected);
+/*
+ * The algorithm is now:
+ *
+ * seed = (seed * const_1 + 0x7fffffc3) & MAXLONG;
+ *
+ * To find out const_1 we can use:
+ *
+ * const_1 = RtlUniform(1) - 0x7fffffc3;
+ *
+ * If that does not work a search loop can try all possible values of
+ * const_1 and compare to the result to RtlUniform(1).
+ * This way we find out that const_1 is 0xffffffed.
+ *
+ * For seed = 1 the const_2 is 0x7fffffc4:
+ */
+    seed = 1;
+    expected = seed * 0xffffffed + 0x7fffffc3 + 1;
+    result = pRtlUniform(&seed);
+    ok(result == expected,
+        "RtlUniform(&seed (seed == 1)) returns %lx, expected %lx",
+        result, expected);
+/*
+ * For seed = 2 the const_2 is 0x7fffffc3:
+ */
+    seed = 2;
+    expected = seed * 0xffffffed + 0x7fffffc3;
+    result = pRtlUniform(&seed);
+    ok(result == expected,
+        "RtlUniform(&seed (seed == 2)) returns %lx, expected %lx",
+        result, expected);
+/*
+ * More tests show that if seed is odd the result must be incremented by 1:
+ */
+    seed = 3;
+    expected = seed * 0xffffffed + 0x7fffffc3 + (seed & 1);
+    result = pRtlUniform(&seed);
+    ok(result == expected,
+        "RtlUniform(&seed (seed == 2)) returns %lx, expected %lx",
+        result, expected);
+
+    seed = 0x6bca1aa;
+    expected = seed * 0xffffffed + 0x7fffffc3;
+    result = pRtlUniform(&seed);
+    ok(result == expected,
+        "RtlUniform(&seed (seed == 0x6bca1aa)) returns %lx, expected %lx",
+        result, expected);
+
+    seed = 0x6bca1ab;
+    expected = seed * 0xffffffed + 0x7fffffc3 + 1;
+    result = pRtlUniform(&seed);
+    ok(result == expected,
+        "RtlUniform(&seed (seed == 0x6bca1ab)) returns %lx, expected %lx",
+        result, expected);
+/*
+ * When seed is 0x6bca1ac there is an exception:
+ */
+    seed = 0x6bca1ac;
+    expected = seed * 0xffffffed + 0x7fffffc3 + 2;
+    result = pRtlUniform(&seed);
+    ok(result == expected,
+        "RtlUniform(&seed (seed == 0x6bca1ac)) returns %lx, expected %lx",
+        result, expected);
+/*
+ * Note that up to here const_3 is not used
+ * (the highest bit of the result is not set).
+ *
+ * Starting with 0x6bca1ad: If seed is even the result must be incremented by 1:
+ */
+    seed = 0x6bca1ad;
+    expected = (seed * 0xffffffed + 0x7fffffc3) & MAXLONG;
+    result = pRtlUniform(&seed);
+    ok(result == expected,
+        "RtlUniform(&seed (seed == 0x6bca1ad)) returns %lx, expected %lx",
+        result, expected);
+
+    seed = 0x6bca1ae;
+    expected = (seed * 0xffffffed + 0x7fffffc3 + 1) & MAXLONG;
+    result = pRtlUniform(&seed);
+    ok(result == expected,
+        "RtlUniform(&seed (seed == 0x6bca1ae)) returns %lx, expected %lx",
+        result, expected);
+/*
+ * There are several ranges where for odd or even seed the result must be
+ * incremented by 1. You can see this ranges in the following test.
+ *
+ * For a full test use one of the following loop heads:
+ *
+ *  for (num = 0; num <= 0xffffffff; num++) {
+ *      seed = num;
+ *      ...
+ *
+ *  seed = 0;
+ *  for (num = 0; num <= 0xffffffff; num++) {
+ *      ...
+ */
+    seed = 0;
+    for (num = 0; num <= 100000; num++) {
+
+	expected = seed * 0xffffffed + 0x7fffffc3;
+	if (seed < 0x6bca1ac) {
+	    expected = expected + (seed & 1);
+	} else if (seed == 0x6bca1ac) {
+	    expected = (expected + 2) & MAXLONG;
+	} else if (seed < 0xd79435c) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0x1435e50b) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0x1af286ba) { 
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0x21af2869) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0x286bca18) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0x2f286bc7) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0x35e50d77) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0x3ca1af26) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0x435e50d5) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0x4a1af284) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0x50d79433) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0x579435e2) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0x5e50d792) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0x650d7941) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0x6bca1af0) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0x7286bc9f) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0x79435e4e) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0x7ffffffd) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0x86bca1ac) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed == 0x86bca1ac) {
+	    expected = (expected + 1) & MAXLONG;
+	} else if (seed < 0x8d79435c) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0x9435e50b) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0x9af286ba) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0xa1af2869) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0xa86bca18) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0xaf286bc7) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed == 0xaf286bc7) {
+	    expected = (expected + 2) & MAXLONG;
+	} else if (seed < 0xb5e50d77) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0xbca1af26) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0xc35e50d5) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0xca1af284) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0xd0d79433) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0xd79435e2) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0xde50d792) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0xe50d7941) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0xebca1af0) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0xf286bc9f) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else if (seed < 0xf9435e4e) {
+	    expected = expected + (seed & 1);
+	} else if (seed < 0xfffffffd) {
+	    expected = (expected + (~seed & 1)) & MAXLONG;
+	} else {
+	    expected = expected + (seed & 1);
+	} /* if */
+        seed_bak = seed;
+        result = pRtlUniform(&seed);
+        ok(result == expected,
+                "test: %llu RtlUniform(&seed (seed == %lx)) returns %lx, expected %lx",
+                num, seed_bak, result, expected);
+        ok(seed == expected,
+                "test: %llu RtlUniform(&seed (seed == %lx)) sets seed to %lx, expected %lx",
+                num, seed_bak, seed, expected);
+    } /* for */
+/*
+ * Further investigation shows: In the different regions the highest bit
+ * is set or cleared when even or odd seeds need an increment by 1.
+ * This leads to the simplified RtlUniform of wine (see dlls/ntdll/rtl.c).
+ */
+}
+
+
+START_TEST(rtl)
+{
+    InitFunctionPtrs();
+
+    test_RtlCompareMemoryUlong();
+    test_RtlUniform();
+}
+
diff -urN old_wine-20030318/dlls/ntdll/tests/rtlstr.c new_wine-20030318/dlls/ntdll/tests/rtlstr.c
--- old_wine-20030318/dlls/ntdll/tests/rtlstr.c	Wed Feb 19 04:40:14 2003
+++ new_wine-20030318/dlls/ntdll/tests/rtlstr.c	Fri Mar 21 01:59:00 2003
@@ -35,9 +35,11 @@
 
 /* Function ptrs for ntdll calls */
 static HMODULE hntdll = 0;
+static NTSTATUS (WINAPI *pRtlAppendUnicodeStringToString)(UNICODE_STRING *, const UNICODE_STRING *);
 static NTSTATUS (WINAPI *pRtlCharToInteger)(char *, ULONG, int *);
 static VOID     (WINAPI *pRtlCopyString)(STRING *, const STRING *);
 static BOOLEAN  (WINAPI *pRtlCreateUnicodeString)(PUNICODE_STRING, LPCWSTR);
+static NTSTATUS (WINAPI *pRtlDowncaseUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);
 static BOOLEAN  (WINAPI *pRtlEqualUnicodeString)(const UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);
 static VOID     (WINAPI *pRtlFreeAnsiString)(PSTRING);
 static VOID     (WINAPI *pRtlInitAnsiString)(PSTRING, LPCSTR);
@@ -91,9 +93,11 @@
     hntdll = LoadLibraryA("ntdll.dll");
     ok(hntdll != 0, "LoadLibrary failed");
     if (hntdll) {
+	pRtlAppendUnicodeStringToString = (void *)GetProcAddress(hntdll, "RtlAppendUnicodeStringToString");
 	pRtlCharToInteger = (void *)GetProcAddress(hntdll, "RtlCharToInteger");
 	pRtlCopyString = (void *)GetProcAddress(hntdll, "RtlCopyString");
 	pRtlCreateUnicodeString = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeString");
+	pRtlDowncaseUnicodeString = (void *)GetProcAddress(hntdll, "RtlDowncaseUnicodeString");
 	pRtlEqualUnicodeString = (void *)GetProcAddress(hntdll, "RtlEqualUnicodeString");
 	pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString");
 	pRtlInitAnsiString = (void *)GetProcAddress(hntdll, "RtlInitAnsiString");
@@ -305,6 +309,190 @@
 }
 
 
+static void test_RtlDowncaseUnicodeString(void)
+{
+    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 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 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 0x400: lower_ch = 0x0; break;
+		default: lower_ch = ch; break;
+	    } /* switch */
+	} /* if */
+	source_buf[i] = ch;
+	result_buf[i] = '\0';
+	lower_buf[i] = lower_ch;
+    } /* for */
+    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,
+	   "RtlDowncaseUnicodeString works wrong: '%c'[=0x%x] is converted to '%c'[=0x%x], expected: '%c'[=0x%x]",
+	   source_str.Buffer[i], source_str.Buffer[i],
+	   result_str.Buffer[i], result_str.Buffer[i],
+	   lower_str.Buffer[i], lower_str.Buffer[i]);
+    } /* for */
+}
+
+
+static void test_RtlAppendUnicodeStringToString(void)
+{
+    CHAR dest_buf[257];
+    CHAR src_buf[257];
+    UNICODE_STRING dest_str;
+    UNICODE_STRING src_str;
+    NTSTATUS result;
+
+    strcpy(dest_buf, "ThisisafakeU0123456789abcdefghij");
+    strcpy(src_buf, "nicodeStringZYXWVUTS");
+    dest_str.Length = 12;
+    dest_str.MaximumLength = 26;
+    dest_str.Buffer = (WCHAR *) dest_buf;
+    src_str.Length = 12;
+    src_str.MaximumLength = 12;
+    src_str.Buffer = (WCHAR *) src_buf;
+    result = pRtlAppendUnicodeStringToString(&dest_str, &src_str);
+    ok(result == STATUS_SUCCESS,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has result %lx",
+       result);
+    ok(memcmp(dest_buf, "ThisisafakeUnicodeString\0\0efghij", 32) == 0,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has dest \"%s\"",
+       dest_buf);
+
+    strcpy(dest_buf, "ThisisafakeU0123456789abcdefghij");
+    dest_str.Length = 12;
+    dest_str.MaximumLength = 25;
+    result = pRtlAppendUnicodeStringToString(&dest_str, &src_str);
+    ok(result == STATUS_SUCCESS,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has result %lx",
+       result);
+    ok(memcmp(dest_buf, "ThisisafakeUnicodeString\0\0efghij", 32) == 0,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has dest \"%s\"",
+       dest_buf);
+
+    strcpy(dest_buf, "ThisisafakeU0123456789abcdefghij");
+    dest_str.Length = 12;
+    dest_str.MaximumLength = 24;
+    result = pRtlAppendUnicodeStringToString(&dest_str, &src_str);
+    ok(result == STATUS_SUCCESS,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has result %lx",
+       result);
+    ok(memcmp(dest_buf, "ThisisafakeUnicodeStringcdefghij", 32) == 0,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has dest \"%s\"",
+       dest_buf);
+
+    strcpy(dest_buf, "ThisisafakeU0123456789abcdefghij");
+    dest_str.Length = 12;
+    dest_str.MaximumLength = 23;
+    result = pRtlAppendUnicodeStringToString(&dest_str, &src_str);
+    ok(result == STATUS_BUFFER_TOO_SMALL,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has result %lx",
+       result);
+    ok(memcmp(dest_buf, "ThisisafakeU0123456789abcdefghij", 32) == 0,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has dest \"%s\"",
+       dest_buf);
+
+    strcpy(dest_buf, "ThisisafakeU0123456789abcdefghij");
+    dest_str.Length = 12;
+    dest_str.MaximumLength = 0;
+    src_str.Length = 0;
+    src_str.MaximumLength = 0;
+    result = pRtlAppendUnicodeStringToString(&dest_str, &src_str);
+    ok(result == STATUS_SUCCESS,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has result %lx",
+       result);
+    ok(memcmp(dest_buf, "ThisisafakeU0123456789abcdefghij", 32) == 0,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has dest \"%s\"",
+       dest_buf);
+
+    strcpy(dest_buf, "ThisisafakeU0123456789abcdefghij");
+    dest_str.Length = 12;
+    dest_str.MaximumLength = 22;
+    src_str.Length = 0;
+    src_str.MaximumLength = 0;
+    result = pRtlAppendUnicodeStringToString(&dest_str, &src_str);
+    ok(result == STATUS_SUCCESS,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has result %lx",
+       result);
+    ok(memcmp(dest_buf, "ThisisafakeU0123456789abcdefghij", 32) == 0,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has dest \"%s\"",
+       dest_buf);
+
+    strcpy(dest_buf, "ThisisafakeU0123456789abcdefghij");
+    dest_str.Length = 12;
+    dest_str.MaximumLength = 22;
+    src_str.Length = 0;
+    src_str.MaximumLength = 0;
+    src_str.Buffer = NULL;
+    result = pRtlAppendUnicodeStringToString(&dest_str, &src_str);
+    ok(result == STATUS_SUCCESS,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has result %lx",
+       result);
+    ok(memcmp(dest_buf, "ThisisafakeU0123456789abcdefghij", 32) == 0,
+       "call failed: RtlAppendUnicodeStringToString(dest, src) has dest \"%s\"",
+       dest_buf);
+}
+
+
 typedef struct {
     int base;
     char *str;
@@ -321,6 +509,14 @@
     { 0, "-+214",                 0, STATUS_SUCCESS},
     { 0, "++214",                 0, STATUS_SUCCESS},
     { 0, "+-214",                 0, STATUS_SUCCESS},
+    { 0, "\001\002\003\00411",   11, STATUS_SUCCESS}, /* whitespace char  1 to  4 */
+    { 0, "\005\006\007\01012",   12, STATUS_SUCCESS}, /* whitespace char  5 to  8 */
+    { 0, "\011\012\013\01413",   13, STATUS_SUCCESS}, /* whitespace char  9 to 12 */
+    { 0, "\015\016\017\02014",   14, STATUS_SUCCESS}, /* whitespace char 13 to 16 */
+    { 0, "\021\022\023\02415",   15, STATUS_SUCCESS}, /* whitespace char 17 to 20 */
+    { 0, "\025\026\027\03016",   16, STATUS_SUCCESS}, /* whitespace char 21 to 24 */
+    { 0, "\031\032\033\03417",   17, STATUS_SUCCESS}, /* whitespace char 25 to 28 */
+    { 0, "\035\036\037\04018",   18, STATUS_SUCCESS}, /* whitespace char 29 to 32 */
     { 0, " \n \r \t214",        214, STATUS_SUCCESS},
     { 0, " \n \r \t+214",       214, STATUS_SUCCESS}, /* Signs can be used after whitespace */
     { 0, " \n \r \t-214",      -214, STATUS_SUCCESS},
@@ -772,9 +968,11 @@
 	test_RtlIntegerToChar();
 	test_RtlUpperChar();
 	test_RtlUpperString();
+	test_RtlAppendUnicodeStringToString();
     } /* if */
 	/*
 	 * test_RtlUpcaseUnicodeChar();
 	 * test_RtlUpcaseUnicodeString();
+	 * test_RtlDowncaseUnicodeString();
 	 */
 }

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux