--- /dev/null
+/* Unit test suite for Ntdll atom API functions
+ *
+ * Copyright 2003 Gyorgy 'Nog' Jeney
+ *
+ * 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.
+ */
+
+#define _WIN32_WINNT 0x0501
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "windows.h"
+#include "ntstatus.h"
+#include "wine/test.h"
+#include "wine/unicode.h"
+#include "winternl.h"
+
+/* Function pointers for ntdll calls */
+static HMODULE hntdll = 0;
+static NTSTATUS (WINAPI *pRtlCreateAtomTable)(ULONG,PRTL_ATOM_TABLE);
+static NTSTATUS (WINAPI *pRtlDestroyAtomTable)(RTL_ATOM_TABLE);
+static NTSTATUS (WINAPI *pRtlEmptyAtomTable)(RTL_ATOM_TABLE,BOOLEAN);
+static NTSTATUS (WINAPI *pRtlAddAtomToAtomTable)(RTL_ATOM_TABLE,PCWSTR,PRTL_ATOM);
+static NTSTATUS (WINAPI *pRtlDeleteAtomFromAtomTable)(RTL_ATOM_TABLE,RTL_ATOM);
+static NTSTATUS (WINAPI *pRtlLookupAtomInAtomTable)(RTL_ATOM_TABLE,PCWSTR,PRTL_ATOM);
+static NTSTATUS (WINAPI *pRtlPinAtomInAtomTable)(RTL_ATOM_TABLE,RTL_ATOM);
+static NTSTATUS (WINAPI *pRtlQueryAtomInAtomTable)(RTL_ATOM_TABLE,RTL_ATOM,PULONG,PULONG,PWSTR,PULONG);
+
+static const WCHAR EmptyAtom[] = {0};
+static const WCHAR testAtom1[] = {'H','e','l','l','o',' ','W','o','r','l','d',0};
+static const WCHAR testAtom2[] = {'H','e','l','l','o',' ','W','o','r','l','d','2',0};
+static const WCHAR testAtom3[] = {'H','e','l','l','o',' ','W','o','r','l','d','3',0};
+
+static const WCHAR testAtom1Cap[] = {'H','E','L','L','O',' ','W','O','R','L','D',0};
+static const WCHAR testAtom1Low[] = {'h','e','l','l','o',' ','w','o','r','l','d',0};
+
+static const WCHAR testAtomInt[] = {'#','1','3','2',0};
+static const WCHAR testAtomIntInv[] = {'#','2','3','4','z',0};
+static const WCHAR testAtomOTT[] = {'#','1','2','3',0};
+
+static void InitFunctionPtr(void)
+{
+ hntdll = LoadLibraryA("ntdll.dll");
+ ok(hntdll != 0, "Unable to load ntdll.dll\n");
+
+ if (hntdll)
+ {
+ pRtlCreateAtomTable = (void *)GetProcAddress(hntdll, "RtlCreateAtomTable");
+ pRtlDestroyAtomTable = (void *)GetProcAddress(hntdll, "RtlDestroyAtomTable");
+ pRtlEmptyAtomTable = (void *)GetProcAddress(hntdll, "RtlEmptyAtomTable");
+ pRtlAddAtomToAtomTable = (void *)GetProcAddress(hntdll, "RtlAddAtomToAtomTable");
+ pRtlDeleteAtomFromAtomTable = (void *)GetProcAddress(hntdll, "RtlDeleteAtomFromAtomTable");
+ pRtlLookupAtomInAtomTable = (void *)GetProcAddress(hntdll, "RtlLookupAtomInAtomTable");
+ pRtlPinAtomInAtomTable = (void *)GetProcAddress(hntdll, "RtlPinAtomInAtomTable");
+ pRtlQueryAtomInAtomTable = (void *)GetProcAddress(hntdll, "RtlQueryAtomInAtomTable");
+ }
+}
+
+static DWORD RtlAtomTestThread(LPVOID Table)
+{
+ RTL_ATOM_TABLE AtomTable = *(PRTL_ATOM_TABLE)Table;
+ RTL_ATOM Atom;
+ NTSTATUS res;
+ ULONG RefCount = 0, PinCount = 0, Len = 0;
+ WCHAR Name[64];
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &Atom);
+ ok(!res, "Unable to find atom from another thread, retval: %lx\n", res);
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom2, &Atom);
+ ok(!res, "Unable to lookup pinned atom in table, retval: %lx\n", res);
+
+ res = pRtlQueryAtomInAtomTable(AtomTable, Atom, &RefCount, &PinCount, Name, &Len);
+ ok(res == STATUS_BUFFER_TOO_SMALL, "We got wrong retval: %lx\n", res);
+
+ Len = 64;
+ res = pRtlQueryAtomInAtomTable(AtomTable, Atom, &RefCount, &PinCount, Name, &Len);
+ ok(!res, "Failed with longenough buffer, retval: %lx\n", res);
+ ok(RefCount == 1, "Refcount was not 1 but %lx\n", RefCount);
+ ok(PinCount == 1, "Pincount was not 1 but %lx\n", PinCount);
+ ok(!strcmpW(Name, testAtom2), "We found wrong atom!!\n");
+ ok((strlenW(testAtom2) * sizeof(WCHAR)) == Len, "Returned wrong length %ld\n", Len);
+
+ Len = 64;
+ res = pRtlQueryAtomInAtomTable(AtomTable, Atom, NULL, NULL, Name, &Len);
+ ok(!res, "RtlQueryAtomInAtomTable with optional args invalid failed, retval: %lx\n", res);
+ ok(!strcmpW(Name, testAtom2), "Found Wrong atom!\n");
+ ok((strlenW(testAtom2) * sizeof(WCHAR)) == Len, "Returned wrong length %ld\n", Len);
+
+ res = pRtlPinAtomInAtomTable(AtomTable, Atom);
+ ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res);
+
+ return 0;
+}
+
+static void test_NtAtom(void)
+{
+ RTL_ATOM_TABLE AtomTable = NULL;
+ NTSTATUS res;
+ RTL_ATOM Atom1, Atom2, Atom3, testEAtom, testAtom;
+ HANDLE testThread;
+ ULONG RefCount = 0, PinCount = 0, Len = 0;
+ WCHAR Name[64];
+
+ /* If we pass a non-null string to create atom table, then it thinks that we
+ * have passed it an already allocated atom table */
+ res = pRtlCreateAtomTable(0, &AtomTable);
+ ok(!res, "RtlCreateAtomTable should succeed with an atom table size of 0\n");
+
+ if (!res)
+ {
+ res = pRtlDestroyAtomTable(AtomTable);
+ ok(!res, "We could create the atom table, but we couldn't destroy it! retval: %lx\n", res);
+ }
+
+ AtomTable = NULL;
+ res = pRtlCreateAtomTable(37, &AtomTable);
+ ok(!res, "We're unable to create an atom table with a valid table size retval: %lx\n", res);
+ if (!res)
+ {
+ res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom1);
+ ok(!res, "We were unable to add a simple atom to the atom table, retval: %lx\n", res);
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1Cap, &testAtom);
+ ok(!res, "We were unable to find capital version of the atom, retval: %lx\n", res);
+ ok(Atom1 == testAtom, "Found wrong atom in table when querying capital atom\n");
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1Low, &testAtom);
+ ok(!res, "Unable to find lowercase version of the atom, retval: %lx\n", res);
+ ok(testAtom == Atom1, "Found wrong atom when querying lowercase atom\n");
+
+ res = pRtlAddAtomToAtomTable(AtomTable, EmptyAtom, &testEAtom);
+ ok(res == STATUS_OBJECT_NAME_INVALID, "Got wrong retval, retval: %lx\n", res);
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
+ ok(!res, "Failed to find totally legitimate atom, retval: %lx\n", res);
+ ok(testAtom == Atom1, "Found wrong atom!\n");
+
+ res = pRtlAddAtomToAtomTable(AtomTable, testAtom2, &Atom2);
+ ok(!res, "Unable to add other legitimate atom to table, retval: %lx\n", res);
+
+ res = pRtlPinAtomInAtomTable(AtomTable, Atom2);
+ ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res);
+
+ testThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)RtlAtomTestThread, &AtomTable, 0, NULL);
+ WaitForSingleObject(testThread, INFINITE);
+
+ Len = 64;
+ res = pRtlQueryAtomInAtomTable(AtomTable, Atom2, &RefCount, &PinCount, Name, &Len);
+ ok(!res, "Unable to query atom in atom table, retval: %lx\n", res);
+ ok(RefCount == 1, "RefCount is not 1 but %lx\n", RefCount);
+ ok(PinCount == 1, "PinCount is not 1 but %lx\n", PinCount);
+ ok(!strcmpW(Name, testAtom2), "We found wrong atom\n");
+ ok((strlenW(testAtom2) * sizeof(WCHAR)) == Len, "Returned wrong length %ld\n", Len);
+
+ res = pRtlEmptyAtomTable(AtomTable, FALSE);
+ ok(!res, "Unable to empty atom table, retval %lx\n", res);
+
+ Len = 64;
+ res = pRtlQueryAtomInAtomTable(AtomTable, Atom2, &RefCount, &PinCount, Name, &Len);
+ ok(!res, "It seems RtlEmptyAtomTable deleted our pinned atom eaven though we asked it not to, retval: %lx\n", res);
+ ok(RefCount == 1, "RefCount is not 1 but %lx\n", RefCount);
+ ok(PinCount == 1, "PinCount is not 1 but %lx\n", PinCount);
+ ok(!strcmpW(Name, testAtom2), "We found wrong atom\n");
+ ok((strlenW(testAtom2) * sizeof(WCHAR)) == Len, "Returned wrong length %ld\n", Len);
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom2, &testAtom);
+ ok(!res, "We can't find our pinned atom!! retval: %lx\n", res);
+ ok(testAtom == Atom2, "We found wrong atom!!!\n");
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
+ ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "We found the atom in our table eaven though we asked RtlEmptyAtomTable to remove it, retval: %lx\n", res);
+
+ res = pRtlAddAtomToAtomTable(AtomTable, testAtom3, &Atom3);
+ ok(!res, "Unable to add atom to table, retval: %lx\n", res);
+
+ res = pRtlEmptyAtomTable(AtomTable, TRUE);
+ ok(!res, "Unable to empty atom table, retval: %lx\n", res);
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom2, &testAtom);
+ ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "The pinned atom should be removed, retval: %lx\n", res);
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom3, &testAtom);
+ ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "Non pinned atom should also be removed, retval: %lx\n", res);
+
+ res = pRtlDestroyAtomTable(AtomTable);
+ ok(!res, "Can't destroy atom table, retval: %lx\n", res);
+ }
+
+ AtomTable = NULL;
+ res = pRtlCreateAtomTable(37, &AtomTable);
+ ok(!res, "Unable to create atom table, retval: %lx\n", res);
+
+ if (!res)
+ {
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
+ ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "Didn't get expected retval with querying an empty atom table, retval: %lx\n", res);
+
+ res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom1);
+ ok(!res, "Unable to add atom to atom table, retval %lx\n", res);
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
+ ok(!res, "Can't find previously added atom in table, retval: %lx\n", res);
+ ok(testAtom == Atom1, "Found wrong atom! retval: %lx\n", res);
+
+ res = pRtlDeleteAtomFromAtomTable(AtomTable, Atom1);
+ ok(!res, "Unable to delete atom from table, retval: %lx\n", res);
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
+ ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "Able to find previously deleted atom in table, retval: %lx\n", res);
+
+ res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom1);
+ ok(!res, "Unable to add atom to atom table, retval: %lx\n", res);
+
+ Len = 0;
+ res = pRtlQueryAtomInAtomTable(AtomTable, Atom1, NULL, NULL, Name, &Len);
+ ok(res == STATUS_BUFFER_TOO_SMALL, "Got wrong retval, retval: %lx\n", res);
+ ok((strlenW(testAtom1) * sizeof(WCHAR)) == Len, "Got wrong length %lx\n", Len);
+
+ res = pRtlPinAtomInAtomTable(AtomTable, Atom1);
+ ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res);
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
+ ok(!res, "Unable to find atom in atom table, retval: %lx\n", res);
+ ok(testAtom == Atom1, "Wrong atom found\n");
+
+ res = pRtlDeleteAtomFromAtomTable(AtomTable, Atom1);
+ ok(res == STATUS_WAS_LOCKED, "Unable to delete atom from table, retval: %lx\n", res);
+
+ res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
+ ok(!res, "Able to find deleted atom in table\n");
+
+ res = pRtlDestroyAtomTable(AtomTable);
+ ok(!res, "Unable to destroy atom table\n");
+ }
+}
+
+/* Test Adding integer atoms to atom table */
+static void test_NtIntAtom(void)
+{
+ NTSTATUS res;
+ RTL_ATOM_TABLE AtomTable;
+ RTL_ATOM testAtom;
+ ULONG RefCount = 0, PinCount = 0;
+ int i;
+ WCHAR Name[64];
+ ULONG Len;
+
+ AtomTable = NULL;
+ res = pRtlCreateAtomTable(37, &AtomTable);
+ ok(!res, "Unable to create atom table, %lx\n", res);
+
+ if (!res)
+ {
+ /* According to the kernel32 functions, integer atoms are only allowd from
+ * 0x0001 to 0xbfff and not 0xc000 to 0xffff, which is correct */
+ res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)0, &testAtom);
+ ok(res == STATUS_INVALID_PARAMETER, "Didn't get expected result from adding 0 int atom, retval: %lx\n", res);
+ for (i = 1; i <= 0xbfff; i++)
+ {
+ res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)i, &testAtom);
+ ok(!res, "Unable to add valid integer atom %i, retval: %lx\n", i, res);
+ }
+
+ for (i = 1; i <= 0xbfff; i++)
+ {
+ res = pRtlLookupAtomInAtomTable(AtomTable, (PWSTR)i, &testAtom);
+ ok(!res, "Unable to find int atom %i, retval: %lx\n", i, res);
+ if (!res)
+ {
+ res = pRtlPinAtomInAtomTable(AtomTable, testAtom);
+ ok(!res, "Unable to pin int atom %i, retval: %lx\n", i, res);
+ }
+ }
+
+ for (i = 0xc000; i <= 0xffff; i++)
+ {
+ res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)i, &testAtom);
+ ok(res, "Able to illeageal integer atom %i, retval: %lx\n", i, res);
+ }
+
+ res = pRtlDestroyAtomTable(AtomTable);
+ ok(!res, "Unable to destroy atom table, retval: %lx\n", res);
+ }
+
+ AtomTable = NULL;
+ res = pRtlCreateAtomTable(37, &AtomTable);
+ ok(!res, "Unable to create atom table, %lx\n", res);
+ if (!res)
+ {
+ res = pRtlLookupAtomInAtomTable(AtomTable, (PWSTR)123, &testAtom);
+ ok(!res, "Unable to query atom in atom table, retval: %lx\n", res);
+
+ res = pRtlAddAtomToAtomTable(AtomTable, testAtomInt, &testAtom);
+ ok(!res, "Unable to add int atom to table, retval: %lx\n", res);
+
+ res = pRtlAddAtomToAtomTable(AtomTable, testAtomIntInv, &testAtom);
+ ok(!res, "Unable to add int atom to table, retval: %lx\n", res);
+
+ res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)123, &testAtom);
+ ok(!res, "Unable to add int atom to table, retval: %lx\n", res);
+
+ res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)123, &testAtom);
+ ok(!res, "Unable to re-add int atom to table, retval: %lx\n", res);
+
+ Len = 64;
+ res = pRtlQueryAtomInAtomTable(AtomTable, testAtom, &RefCount, &PinCount, Name, &Len);
+ ok(!res, "Unable to query atom in atom table, retval: %lx\n", res);
+ ok(PinCount == 1, "Expected pincount 1 but got %lx\n", PinCount);
+ ok(RefCount == 1, "Expected refcount 1 but got %lx\n", RefCount);
+ ok(!strcmpW(testAtomOTT, Name), "Got wrong atom name\n");
+ ok((strlenW(testAtomOTT) * sizeof(WCHAR)) == Len, "Got wrong len %ld\n", Len);
+
+ res = pRtlPinAtomInAtomTable(AtomTable, testAtom);
+ ok(!res, "Unable to pin int atom, retval: %lx\n", res);
+
+ res = pRtlPinAtomInAtomTable(AtomTable, testAtom);
+ ok(!res, "Unable to pin int atom, retval: %lx\n", res);
+
+ res = pRtlQueryAtomInAtomTable(AtomTable, testAtom, &RefCount, &PinCount, NULL, NULL);
+ ok(!res, "Unable to query atom in atom table, retval: %lx\n", res);
+ ok(PinCount == 1, "Expected pincount 1 but got %lx\n", PinCount);
+ ok(RefCount == 1, "Expected refcount 1 but got %lx\n", RefCount);
+
+ res = pRtlDestroyAtomTable(AtomTable);
+ ok(!res, "Unable to destroy atom table, retval: %lx\n", res);
+ }
+}
+
+/* Tests to see how the pincount and refcount actually works */
+static void test_NtRefPinAtom(void)
+{
+ RTL_ATOM_TABLE AtomTable;
+ RTL_ATOM Atom;
+ ULONG PinCount = 0, RefCount = 0;
+ NTSTATUS res;
+
+ AtomTable = NULL;
+ res = pRtlCreateAtomTable(37, &AtomTable);
+ ok(!res, "Unable to create atom table, %lx\n", res);
+
+ if (!res)
+ {
+ res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom);
+ ok(!res, "Unable to add our atom to the atom table, retval: %lx\n", res);
+
+ res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom);
+ ok(!res, "Unable to add our atom to the atom table, retval: %lx\n", res);
+
+ res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom);
+ ok(!res, "Unable to add our atom to the atom table, retval: %lx\n", res);
+
+ res = pRtlQueryAtomInAtomTable(AtomTable, Atom, &RefCount, &PinCount, NULL, NULL);
+ ok(!res, "Unable to query atom in atom table, retval: %lx\n", res);
+ ok(PinCount == 0, "Expected pincount 0 but got %lx\n", PinCount);
+ ok(RefCount == 3, "Expected refcount 3 but got %lx\n", RefCount);
+
+ res = pRtlPinAtomInAtomTable(AtomTable, Atom);
+ ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res);
+
+ res = pRtlPinAtomInAtomTable(AtomTable, Atom);
+ ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res);
+
+ res = pRtlPinAtomInAtomTable(AtomTable, Atom);
+ ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res);
+
+ res = pRtlQueryAtomInAtomTable(AtomTable, Atom, &RefCount, &PinCount, NULL, NULL);
+ ok(!res, "Unable to query atom in atom table, retval: %lx\n", res);
+ ok(PinCount == 1, "Expected pincount 1 but got %lx\n", PinCount);
+ ok(RefCount == 3, "Expected refcount 3 but got %lx\n", RefCount);
+
+ res = pRtlDestroyAtomTable(AtomTable);
+ ok(!res, "Unable to destroy atom table, retval: %lx\n", res);
+ }
+}
+
+START_TEST(atom)
+{
+ InitFunctionPtr();
+ if (pRtlCreateAtomTable)
+ {
+ test_NtAtom();
+ test_NtIntAtom();
+ test_NtRefPinAtom();
+ }
+}
--- /dev/null
+/*
+ * Unit test suite for ntdll path functions
+ *
+ * Copyright 2003 Eric Pouech
+ *
+ * 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
+ */
+
+#include <stdio.h>
+
+#include "ntdll_test.h"
+#include "wine/unicode.h"
+
+static NTSTATUS (WINAPI *pRtlMultiByteToUnicodeN)( LPWSTR dst, DWORD dstlen, LPDWORD reslen,
+ LPCSTR src, DWORD srclen );
+static NTSTATUS (WINAPI *pRtlCreateEnvironment)(BOOLEAN, PWSTR*);
+static NTSTATUS (WINAPI *pRtlDestroyEnvironment)(PWSTR);
+static NTSTATUS (WINAPI *pRtlQueryEnvironmentVariable_U)(PWSTR, PUNICODE_STRING, PUNICODE_STRING);
+static void (WINAPI *pRtlSetCurrentEnvironment)(PWSTR, PWSTR*);
+static NTSTATUS (WINAPI *pRtlSetEnvironmentVariable)(PWSTR*, PUNICODE_STRING, PUNICODE_STRING);
+static NTSTATUS (WINAPI *pRtlExpandEnvironmentStrings_U)(LPWSTR, PUNICODE_STRING, PUNICODE_STRING, PULONG);
+
+static WCHAR small_env[] = {'f','o','o','=','t','o','t','o',0,
+ 'f','o','=','t','i','t','i',0,
+ 'f','o','o','o','=','t','u','t','u',0,
+ 's','r','=','a','n','=','o','u','o',0,
+ 'g','=','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
+ 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
+ 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
+ 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
+ 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
+ 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
+ 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
+ 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
+ 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
+ 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',0,
+ '=','o','O','H','=','I','I','I',0,
+ 'n','u','l','=',0,
+ 0};
+
+static void testQuery(void)
+{
+ struct test
+ {
+ const char *var;
+ int len;
+ NTSTATUS status;
+ const char *val;
+ };
+
+ static const struct test tests[] =
+ {
+ {"foo", 256, STATUS_SUCCESS, "toto"},
+ {"FoO", 256, STATUS_SUCCESS, "toto"},
+ {"foo=", 256, STATUS_VARIABLE_NOT_FOUND, NULL},
+ {"foo ", 256, STATUS_VARIABLE_NOT_FOUND, NULL},
+ {"foo", 1, STATUS_BUFFER_TOO_SMALL, "toto"},
+ {"foo", 3, STATUS_BUFFER_TOO_SMALL, "toto"},
+ {"foo", 4, STATUS_SUCCESS, "toto"},
+ {"fooo", 256, STATUS_SUCCESS, "tutu"},
+ {"f", 256, STATUS_VARIABLE_NOT_FOUND, NULL},
+ {"g", 256, STATUS_SUCCESS, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"},
+ {"sr=an", 256, STATUS_VARIABLE_NOT_FOUND, NULL},
+ {"sr", 256, STATUS_SUCCESS, "an=ouo"},
+ {"=oOH", 256, STATUS_SUCCESS, "III"},
+ {"", 256, STATUS_VARIABLE_NOT_FOUND, NULL},
+ {"nul", 256, STATUS_SUCCESS, ""},
+ {NULL, 0, 0, NULL}
+ };
+
+ WCHAR bn[257];
+ WCHAR bv[257];
+ UNICODE_STRING name;
+ UNICODE_STRING value;
+ const struct test* test;
+ NTSTATUS nts;
+
+ for (test = tests; test->var; test++)
+ {
+ name.Length = strlen(test->var) * 2;
+ name.MaximumLength = name.Length + 2;
+ name.Buffer = bn;
+ value.Length = 0;
+ value.MaximumLength = test->len * 2;
+ value.Buffer = bv;
+ bv[test->len] = '@';
+
+ pRtlMultiByteToUnicodeN( bn, sizeof(bn), NULL, test->var, strlen(test->var)+1 );
+ nts = pRtlQueryEnvironmentVariable_U(small_env, &name, &value);
+ ok( nts == test->status, "[%d]: Wrong status for '%s', expecting %lx got %lx\n",
+ test - tests, test->var, test->status, nts );
+ if (nts == test->status) switch (nts)
+ {
+ case STATUS_SUCCESS:
+ pRtlMultiByteToUnicodeN( bn, sizeof(bn), NULL, test->val, strlen(test->val)+1 );
+ ok( value.Length == strlen(test->val) * sizeof(WCHAR), "Wrong length %d/%d for %s\n",
+ value.Length, strlen(test->val) * sizeof(WCHAR), test->var );
+ ok((value.Length == strlen(test->val) * sizeof(WCHAR) && strncmpW(bv, bn, test->len) == 0) ||
+ strcmpW(bv, bn) == 0,
+ "Wrong result for %s/%d\n", test->var, test->len);
+ ok(bv[test->len] == '@', "Writing too far away in the buffer for %s/%d\n", test->var, test->len);
+ break;
+ case STATUS_BUFFER_TOO_SMALL:
+ ok( value.Length == strlen(test->val) * sizeof(WCHAR),
+ "Wrong returned length %d/%d (too small buffer) for %s\n",
+ value.Length, strlen(test->val) * sizeof(WCHAR), test->var );
+ break;
+ }
+ }
+}
+
+static void testSetHelper(LPWSTR* env, const char* var, const char* val, NTSTATUS ret)
+{
+ WCHAR bvar[256], bval1[256], bval2[256];
+ UNICODE_STRING uvar;
+ UNICODE_STRING uval;
+ NTSTATUS nts;
+
+ uvar.Length = strlen(var) * sizeof(WCHAR);
+ uvar.MaximumLength = uvar.Length + sizeof(WCHAR);
+ uvar.Buffer = bvar;
+ pRtlMultiByteToUnicodeN( bvar, sizeof(bvar), NULL, var, strlen(var)+1 );
+ if (val)
+ {
+ uval.Length = strlen(val) * sizeof(WCHAR);
+ uval.MaximumLength = uval.Length + sizeof(WCHAR);
+ uval.Buffer = bval1;
+ pRtlMultiByteToUnicodeN( bval1, sizeof(bval1), NULL, val, strlen(val)+1 );
+ }
+ nts = pRtlSetEnvironmentVariable(env, &uvar, val ? &uval : NULL);
+ ok(nts == ret, "Setting var %s=%s (%lx/%lx)\n", var, val, nts, ret);
+ if (nts == STATUS_SUCCESS)
+ {
+ uval.Length = 0;
+ uval.MaximumLength = sizeof(bval2);
+ uval.Buffer = bval2;
+ nts = pRtlQueryEnvironmentVariable_U(*env, &uvar, &uval);
+ switch (nts)
+ {
+ case STATUS_SUCCESS:
+ ok(strcmpW(bval1, bval2) == 0, "Cannot get value written to environment\n");
+ break;
+ case STATUS_VARIABLE_NOT_FOUND:
+ ok(val == NULL, "Couldn't find variable, but didn't delete it. val = %s\n", val);
+ break;
+ default:
+ ok(0, "Wrong ret %lu for %s\n", nts, var);
+ break;
+ }
+ }
+}
+
+static void testSet(void)
+{
+ LPWSTR env;
+ char tmp[16];
+ int i;
+
+ ok(pRtlCreateEnvironment(FALSE, &env) == STATUS_SUCCESS, "Creating environment\n");
+ memmove(env, small_env, sizeof(small_env));
+
+ testSetHelper(&env, "cat", "dog", STATUS_SUCCESS);
+ testSetHelper(&env, "cat", "horse", STATUS_SUCCESS);
+ testSetHelper(&env, "cat", "zz", STATUS_SUCCESS);
+ testSetHelper(&env, "cat", NULL, STATUS_SUCCESS);
+ testSetHelper(&env, "cat", NULL, STATUS_VARIABLE_NOT_FOUND);
+ testSetHelper(&env, "foo", "meouw", STATUS_SUCCESS);
+ testSetHelper(&env, "me=too", "also", STATUS_INVALID_PARAMETER);
+ testSetHelper(&env, "me", "too=also", STATUS_SUCCESS);
+ testSetHelper(&env, "=too", "also", STATUS_SUCCESS);
+ testSetHelper(&env, "=", "also", STATUS_SUCCESS);
+
+ for (i = 0; i < 128; i++)
+ {
+ sprintf(tmp, "zork%03d", i);
+ testSetHelper(&env, tmp, "is alive", STATUS_SUCCESS);
+ }
+
+ for (i = 0; i < 128; i++)
+ {
+ sprintf(tmp, "zork%03d", i);
+ testSetHelper(&env, tmp, NULL, STATUS_SUCCESS);
+ }
+ testSetHelper(&env, "fOo", NULL, STATUS_SUCCESS);
+
+ ok(pRtlDestroyEnvironment(env) == STATUS_SUCCESS, "Destroying environment\n");
+}
+
+static void testExpand(void)
+{
+ static const struct test
+ {
+ const char *src;
+ const char *dst;
+ } tests[] =
+ {
+ {"hello%foo%world", "hellototoworld"},
+ {"hello%=oOH%world", "helloIIIworld"},
+ {"hello%foo", "hello%foo"},
+ {"hello%bar%world", "hello%bar%world"},
+ /*
+ * {"hello%foo%world%=oOH%eeck", "hellototoworldIIIeeck"},
+ * Interestingly enough, with a 8 WCHAR buffers, we get on 2k:
+ * helloIII
+ * so it seems like strings overflowing the buffer are written
+ * (troncated) but the write cursor is not advanced :-/
+ */
+ {NULL, NULL}
+ };
+
+ const struct test* test;
+ NTSTATUS nts;
+ UNICODE_STRING us_src, us_dst;
+ WCHAR src[256], dst[256], rst[256];
+ ULONG ul;
+
+ for (test = tests; test->src; test++)
+ {
+ pRtlMultiByteToUnicodeN(src, sizeof(src), NULL, test->src, strlen(test->src)+1);
+ pRtlMultiByteToUnicodeN(rst, sizeof(rst), NULL, test->dst, strlen(test->dst)+1);
+
+ us_src.Length = strlen(test->src) * sizeof(WCHAR);
+ us_src.MaximumLength = us_src.Length + 2;
+ us_src.Buffer = src;
+
+ us_dst.Length = 0;
+ us_dst.MaximumLength = 0;
+ us_dst.Buffer = NULL;
+
+ nts = pRtlExpandEnvironmentStrings_U(small_env, &us_src, &us_dst, &ul);
+ ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR),
+ "Wrong returned length for %s: %lu <> %u\n",
+ test->src, ul, strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR));
+
+ us_dst.Length = 0;
+ us_dst.MaximumLength = sizeof(dst);
+ us_dst.Buffer = dst;
+
+ nts = pRtlExpandEnvironmentStrings_U(small_env, &us_src, &us_dst, &ul);
+ ok(nts == STATUS_SUCCESS, "Call failed (%lu)\n", nts);
+ ok(ul == us_dst.Length + sizeof(WCHAR),
+ "Wrong returned length for %s: %lu <> %u\n",
+ test->src, ul, us_dst.Length + sizeof(WCHAR));
+ ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR),
+ "Wrong returned length for %s: %lu <> %u\n",
+ test->src, ul, strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR));
+ ok(strcmpW(dst, rst) == 0, "Wrong result for %s: expecting %s\n",
+ test->src, test->dst);
+
+ us_dst.Length = 0;
+ us_dst.MaximumLength = 8 * sizeof(WCHAR);
+ us_dst.Buffer = dst;
+ dst[8] = '-';
+ nts = pRtlExpandEnvironmentStrings_U(small_env, &us_src, &us_dst, &ul);
+ ok(nts == STATUS_BUFFER_TOO_SMALL, "Call failed (%lu)\n", nts);
+ ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR),
+ "Wrong returned length for %s (with buffer too small): %lu <> %u\n",
+ test->src, ul, strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR));
+ ok(strncmpW(dst, rst, 8) == 0,
+ "Wrong result for %s (with buffer too small): expecting %s\n",
+ test->src, test->dst);
+ ok(dst[8] == '-', "Writing too far in buffer (got %c/%d)\n", dst[8], dst[8]);
+ }
+
+}
+
+START_TEST(env)
+{
+ HMODULE mod = GetModuleHandleA("ntdll.dll");
+
+ pRtlMultiByteToUnicodeN = (void *)GetProcAddress(mod,"RtlMultiByteToUnicodeN");
+ pRtlCreateEnvironment = (void*)GetProcAddress(mod, "RtlCreateEnvironment");
+ pRtlDestroyEnvironment = (void*)GetProcAddress(mod, "RtlDestroyEnvironment");
+ pRtlQueryEnvironmentVariable_U = (void*)GetProcAddress(mod, "RtlQueryEnvironmentVariable_U");
+ pRtlSetCurrentEnvironment = (void*)GetProcAddress(mod, "RtlSetCurrentEnvironment");
+ pRtlSetEnvironmentVariable = (void*)GetProcAddress(mod, "RtlSetEnvironmentVariable");
+ pRtlExpandEnvironmentStrings_U = (void*)GetProcAddress(mod, "RtlExpandEnvironmentStrings_U");
+
+ if (pRtlQueryEnvironmentVariable_U)
+ testQuery();
+ if (pRtlSetEnvironmentVariable)
+ testSet();
+ if (pRtlExpandEnvironmentStrings_U)
+ testExpand();
+}
--- /dev/null
+/*
+ * Unit tests for RtlNtStatusToDosError function
+ *
+ * Copyright (c) 2002 Andriy Palamarchuk
+ *
+ * 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
+ */
+
+#define _WIN32_WINNT 0x0501
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "ntstatus.h"
+#define WIN32_NO_STATUS
+
+#include "wine/test.h"
+
+#include "windows.h"
+
+#include "windef.h"
+#include "winbase.h"
+#include "rpcnterr.h"
+#include "winreg.h"
+#include "winternl.h"
+
+/* FIXME!!! this test checks only mappings, defined by MSDN:
+ * http://support.microsoft.com/default.aspx?scid=KB;EN-US;q113996&
+ * It is necessary to add other mappings and to test them up to Windows XP.
+ *
+ * Some Windows platforms don't know about all the mappings, and in such
+ * cases they return somewhat strange results (Win98) or a generic error
+ * like ERROR_MR_MID_NOT_FOUND (NT4). Our tests have to know about these to
+ * not fail, but we would very much prefer Wine not to return such garbage.
+ * To you can pass the 'strict' option to this test to force it to only check
+ * results against the first listed value. This test should pass in strict
+ * mode on the latest Windows platform (currently XP) and in Wine.
+ * (of course older Windows platforms will fail to pass the strict mode)
+ */
+
+static ULONG (WINAPI *statustodoserror)(NTSTATUS Status);
+static int strict;
+
+static int prepare_test(void)
+{
+ HMODULE ntdll;
+ int argc;
+ char** argv;
+
+ ntdll = LoadLibraryA("ntdll.dll");
+ statustodoserror = (void*)GetProcAddress(ntdll, "RtlNtStatusToDosError");
+ if (!statustodoserror)
+ return 0;
+
+ argc = winetest_get_mainargs(&argv);
+ strict=(argc >= 3 && strcmp(argv[2],"strict")==0);
+ return 1;
+}
+
+static void cmp_call(NTSTATUS win_nt, ULONG win32, const char* message)
+{
+ ULONG err;
+
+ err = statustodoserror(win_nt);
+ ok(err == win32,
+ "%s (%lx): got %ld, expected %ld\n",
+ message, win_nt, err, win32);
+}
+
+static void cmp_call2(NTSTATUS win_nt, ULONG win32, const char* message)
+{
+ ULONG err;
+
+ err = statustodoserror(win_nt);
+ ok(err == win32 ||
+ (!strict && err == ERROR_MR_MID_NOT_FOUND),
+ "%s (%lx): got %ld, expected %ld (or MID_NOT_FOUND)\n",
+ message, win_nt, err, win32);
+}
+
+static void cmp_call3(NTSTATUS win_nt, ULONG win32_1, ULONG win32_2, const char* message)
+{
+ ULONG err;
+
+ err = statustodoserror(win_nt);
+ ok(err == win32_1 || (!strict && err == win32_2),
+ "%s (%lx): got %ld, expected %ld or %ld\n",
+ message, win_nt, err, win32_1, win32_2);
+}
+
+static void cmp_call4(NTSTATUS win_nt, ULONG win32_1, ULONG win32_2, const char* message)
+{
+ ULONG err;
+
+ err = statustodoserror(win_nt);
+ ok(err == win32_1 ||
+ (!strict && (err == win32_2 || err == ERROR_MR_MID_NOT_FOUND)),
+ "%s (%lx): got %ld, expected %ld or %ld\n",
+ message, win_nt, err, win32_1, win32_2);
+}
+
+#define cmp(status, error) \
+ cmp_call(status, error, #status)
+#define cmp2(status, error) \
+ cmp_call2(status, error, #status)
+#define cmp3(status, error1, error2) \
+ cmp_call3(status, error1, error2, #status)
+#define cmp4(status, error1, error2) \
+ cmp_call4(status, error1, error2, #status)
+
+static void run_error_tests(void)
+{
+ cmp(STATUS_DATATYPE_MISALIGNMENT, ERROR_NOACCESS);
+ cmp(STATUS_ACCESS_VIOLATION, ERROR_NOACCESS);
+ cmp2(STATUS_DATATYPE_MISALIGNMENT_ERROR, ERROR_NOACCESS);
+ cmp(STATUS_CTL_FILE_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
+ cmp(STATUS_PORT_ALREADY_SET, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_SECTION_NOT_IMAGE, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_BAD_WORKING_SET_LIMIT, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_WORKING_SET_LIMIT_RANGE, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INCOMPATIBLE_FILE_MAP, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_PORT_DISCONNECTED, ERROR_INVALID_HANDLE);
+ cmp(STATUS_NOT_LOCKED, ERROR_NOT_LOCKED);
+ cmp(STATUS_NOT_MAPPED_VIEW, ERROR_INVALID_ADDRESS);
+ cmp(STATUS_UNABLE_TO_FREE_VM, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_UNABLE_TO_DELETE_SECTION, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_MORE_PROCESSING_REQUIRED, ERROR_MORE_DATA);
+ cmp(STATUS_INVALID_CID, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_STACK_OVERFLOW, ERROR_STACK_OVERFLOW);
+ cmp(STATUS_BAD_INITIAL_STACK, ERROR_STACK_OVERFLOW);
+ cmp(STATUS_INVALID_VOLUME_LABEL, ERROR_LABEL_TOO_LONG);
+ cmp(STATUS_SECTION_NOT_EXTENDED, ERROR_OUTOFMEMORY);
+ cmp(STATUS_NOT_MAPPED_DATA, ERROR_INVALID_ADDRESS);
+ cmp2(STATUS_NO_LDT, ERROR_INVALID_THREAD_ID);
+ cmp(STATUS_INFO_LENGTH_MISMATCH, ERROR_BAD_LENGTH);
+ cmp(STATUS_INVALID_INFO_CLASS, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_SUSPEND_COUNT_EXCEEDED, ERROR_SIGNAL_REFUSED);
+ cmp(STATUS_NOTIFY_ENUM_DIR, ERROR_NOTIFY_ENUM_DIR);
+ cmp(STATUS_REGISTRY_RECOVERED, ERROR_REGISTRY_RECOVERED);
+ cmp(STATUS_REGISTRY_IO_FAILED, ERROR_REGISTRY_IO_FAILED);
+ cmp(STATUS_NOT_REGISTRY_FILE, ERROR_NOT_REGISTRY_FILE);
+ cmp(STATUS_KEY_DELETED, ERROR_KEY_DELETED);
+ cmp(STATUS_NO_LOG_SPACE, ERROR_NO_LOG_SPACE);
+ cmp(STATUS_KEY_HAS_CHILDREN, ERROR_KEY_HAS_CHILDREN);
+ cmp(STATUS_CHILD_MUST_BE_VOLATILE, ERROR_CHILD_MUST_BE_VOLATILE);
+ cmp(STATUS_REGISTRY_CORRUPT, ERROR_BADDB);
+ cmp(STATUS_DLL_NOT_FOUND, ERROR_MOD_NOT_FOUND);
+ cmp(STATUS_DLL_INIT_FAILED, ERROR_DLL_INIT_FAILED);
+ cmp2(STATUS_INVALID_IMPORT_OF_NON_DLL, ERROR_INVALID_IMPORT_OF_NON_DLL);
+ cmp(STATUS_ORDINAL_NOT_FOUND, ERROR_INVALID_ORDINAL);
+ cmp(STATUS_DRIVER_ORDINAL_NOT_FOUND, ERROR_INVALID_ORDINAL);
+ cmp2(STATUS_DRIVER_UNABLE_TO_LOAD, ERROR_BAD_DRIVER);
+ cmp(STATUS_ENTRYPOINT_NOT_FOUND, ERROR_PROC_NOT_FOUND);
+ cmp(STATUS_DRIVER_ENTRYPOINT_NOT_FOUND, ERROR_PROC_NOT_FOUND);
+ cmp(STATUS_PENDING, ERROR_IO_PENDING);
+ cmp(STATUS_MORE_ENTRIES, ERROR_MORE_DATA);
+ cmp(STATUS_INTEGER_OVERFLOW, ERROR_ARITHMETIC_OVERFLOW);
+ cmp(STATUS_BUFFER_OVERFLOW, ERROR_MORE_DATA);
+ cmp(STATUS_NO_MORE_FILES, ERROR_NO_MORE_FILES);
+ cmp(STATUS_NO_INHERITANCE, ERROR_NO_INHERITANCE);
+ cmp(STATUS_NO_MORE_EAS, ERROR_NO_MORE_ITEMS);
+ cmp(STATUS_NO_MORE_ENTRIES, ERROR_NO_MORE_ITEMS);
+ cmp(STATUS_GUIDS_EXHAUSTED, ERROR_NO_MORE_ITEMS);
+ cmp(STATUS_AGENTS_EXHAUSTED, ERROR_NO_MORE_ITEMS);
+ cmp(STATUS_UNSUCCESSFUL, ERROR_GEN_FAILURE);
+ cmp(STATUS_TOO_MANY_LINKS, ERROR_TOO_MANY_LINKS);
+ cmp(STATUS_NOT_IMPLEMENTED, ERROR_INVALID_FUNCTION);
+ cmp(STATUS_ILLEGAL_FUNCTION, ERROR_INVALID_FUNCTION);
+ cmp(STATUS_IN_PAGE_ERROR, ERROR_SWAPERROR);
+ cmp(STATUS_PAGEFILE_QUOTA, ERROR_PAGEFILE_QUOTA);
+ cmp(STATUS_COMMITMENT_LIMIT, ERROR_COMMITMENT_LIMIT);
+ cmp(STATUS_SECTION_TOO_BIG, ERROR_NOT_ENOUGH_MEMORY);
+ cmp(RPC_NT_SS_IN_NULL_CONTEXT, ERROR_INVALID_HANDLE);
+ cmp(RPC_NT_INVALID_BINDING, ERROR_INVALID_HANDLE);
+ cmp(STATUS_INVALID_HANDLE, ERROR_INVALID_HANDLE);
+ cmp(STATUS_OBJECT_TYPE_MISMATCH, ERROR_INVALID_HANDLE);
+ cmp(STATUS_FILE_CLOSED, ERROR_INVALID_HANDLE);
+ cmp(STATUS_INVALID_PORT_HANDLE, ERROR_INVALID_HANDLE);
+ cmp(STATUS_HANDLE_NOT_CLOSABLE, ERROR_INVALID_HANDLE);
+ cmp(STATUS_NOT_COMMITTED, ERROR_INVALID_ADDRESS);
+ cmp(STATUS_PARTIAL_COPY, ERROR_PARTIAL_COPY);
+ cmp(STATUS_LPC_REPLY_LOST, ERROR_INTERNAL_ERROR);
+ cmp(STATUS_INVALID_PARAMETER, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_1, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_2, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_3, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_4, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_5, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_6, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_7, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_8, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_9, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_10, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_11, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_12, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PARAMETER_MIX, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_INVALID_PAGE_PROTECTION, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_SECTION_PROTECTION, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_RESOURCE_DATA_NOT_FOUND, ERROR_RESOURCE_DATA_NOT_FOUND);
+ cmp(STATUS_RESOURCE_TYPE_NOT_FOUND, ERROR_RESOURCE_TYPE_NOT_FOUND);
+ cmp(STATUS_RESOURCE_NAME_NOT_FOUND, ERROR_RESOURCE_NAME_NOT_FOUND);
+ cmp(STATUS_RESOURCE_LANG_NOT_FOUND, ERROR_RESOURCE_LANG_NOT_FOUND);
+ cmp(STATUS_NO_SUCH_DEVICE, ERROR_FILE_NOT_FOUND);
+ cmp(STATUS_NO_SUCH_FILE, ERROR_FILE_NOT_FOUND);
+ cmp(STATUS_INVALID_DEVICE_REQUEST, ERROR_INVALID_FUNCTION);
+ cmp2(STATUS_VOLUME_NOT_UPGRADED, ERROR_INVALID_FUNCTION);
+ cmp(STATUS_END_OF_FILE, ERROR_HANDLE_EOF);
+ cmp(STATUS_FILE_FORCED_CLOSED, ERROR_HANDLE_EOF);
+ cmp(STATUS_WRONG_VOLUME, ERROR_WRONG_DISK);
+ cmp(STATUS_NO_MEDIA, ERROR_NO_MEDIA_IN_DRIVE);
+ cmp(STATUS_NO_MEDIA_IN_DEVICE, ERROR_NOT_READY);
+ cmp(STATUS_VOLUME_DISMOUNTED, ERROR_NOT_READY);
+ cmp(STATUS_NONEXISTENT_SECTOR, ERROR_SECTOR_NOT_FOUND);
+ cmp(STATUS_WORKING_SET_QUOTA, ERROR_WORKING_SET_QUOTA);
+ cmp(STATUS_NO_MEMORY, ERROR_NOT_ENOUGH_MEMORY);
+ cmp(STATUS_CONFLICTING_ADDRESSES, ERROR_INVALID_ADDRESS);
+ cmp(STATUS_INVALID_SYSTEM_SERVICE, ERROR_INVALID_FUNCTION);
+ cmp(STATUS_THREAD_IS_TERMINATING, ERROR_ACCESS_DENIED);
+ cmp(STATUS_PROCESS_IS_TERMINATING, ERROR_ACCESS_DENIED);
+ cmp(STATUS_INVALID_LOCK_SEQUENCE, ERROR_ACCESS_DENIED);
+ cmp(STATUS_INVALID_VIEW_SIZE, ERROR_ACCESS_DENIED);
+ cmp(STATUS_ALREADY_COMMITTED, ERROR_ACCESS_DENIED);
+ cmp(STATUS_ACCESS_DENIED, ERROR_ACCESS_DENIED);
+ cmp(STATUS_FILE_IS_A_DIRECTORY, ERROR_ACCESS_DENIED);
+ cmp(STATUS_CANNOT_DELETE, ERROR_ACCESS_DENIED);
+ cmp(STATUS_INVALID_COMPUTER_NAME, ERROR_INVALID_COMPUTERNAME);
+ cmp(STATUS_FILE_DELETED, ERROR_ACCESS_DENIED);
+ cmp2(STATUS_FILE_RENAMED, ERROR_ACCESS_DENIED);
+ cmp(STATUS_DELETE_PENDING, ERROR_ACCESS_DENIED);
+ cmp(STATUS_PORT_CONNECTION_REFUSED, ERROR_ACCESS_DENIED);
+ cmp(STATUS_NO_SUCH_PRIVILEGE, ERROR_NO_SUCH_PRIVILEGE);
+ cmp(STATUS_PRIVILEGE_NOT_HELD, ERROR_PRIVILEGE_NOT_HELD);
+ cmp(STATUS_CANNOT_IMPERSONATE, ERROR_CANNOT_IMPERSONATE);
+ cmp(STATUS_LOGON_FAILURE, ERROR_LOGON_FAILURE);
+ cmp2(STATUS_MUTUAL_AUTHENTICATION_FAILED, ERROR_MUTUAL_AUTH_FAILED);
+ cmp2(STATUS_TIME_DIFFERENCE_AT_DC, ERROR_TIME_SKEW);
+ cmp2(STATUS_PKINIT_FAILURE, ERROR_PKINIT_FAILURE);
+ cmp2(STATUS_SMARTCARD_SUBSYSTEM_FAILURE, ERROR_SMARTCARD_SUBSYSTEM_FAILURE);
+ cmp2(STATUS_DOWNGRADE_DETECTED, ERROR_DOWNGRADE_DETECTED);
+ cmp2(STATUS_SMARTCARD_CERT_REVOKED, SEC_E_SMARTCARD_CERT_REVOKED);
+ cmp2(STATUS_ISSUING_CA_UNTRUSTED, SEC_E_ISSUING_CA_UNTRUSTED);
+ cmp2(STATUS_REVOCATION_OFFLINE_C, SEC_E_REVOCATION_OFFLINE_C);
+ cmp2(STATUS_PKINIT_CLIENT_FAILURE, SEC_E_PKINIT_CLIENT_FAILURE);
+ cmp2(STATUS_SMARTCARD_CERT_EXPIRED, SEC_E_SMARTCARD_CERT_EXPIRED);
+ cmp2(STATUS_NO_KERB_KEY, SEC_E_NO_KERB_KEY);
+ cmp2(STATUS_CURRENT_DOMAIN_NOT_ALLOWED, ERROR_CURRENT_DOMAIN_NOT_ALLOWED);
+ cmp2(STATUS_SMARTCARD_WRONG_PIN, SCARD_W_WRONG_CHV);
+ cmp2(STATUS_SMARTCARD_CARD_BLOCKED, SCARD_W_CHV_BLOCKED);
+ cmp2(STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED,SCARD_W_CARD_NOT_AUTHENTICATED);
+ cmp2(STATUS_SMARTCARD_NO_CARD, SCARD_E_NO_SMARTCARD);
+ cmp2(STATUS_SMARTCARD_NO_KEY_CONTAINER, NTE_NO_KEY);
+ cmp2(STATUS_SMARTCARD_NO_CERTIFICATE, SCARD_E_NO_SUCH_CERTIFICATE);
+ cmp2(STATUS_SMARTCARD_NO_KEYSET, NTE_BAD_KEYSET);
+ cmp2(STATUS_SMARTCARD_IO_ERROR, SCARD_E_COMM_DATA_LOST);
+ cmp(STATUS_ACCOUNT_RESTRICTION, ERROR_ACCOUNT_RESTRICTION);
+ cmp(STATUS_INVALID_LOGON_HOURS, ERROR_INVALID_LOGON_HOURS);
+ cmp(STATUS_INVALID_WORKSTATION, ERROR_INVALID_WORKSTATION);
+ cmp(STATUS_BUFFER_TOO_SMALL, ERROR_INSUFFICIENT_BUFFER);
+ cmp(STATUS_UNABLE_TO_DECOMMIT_VM, ERROR_INVALID_ADDRESS);
+ cmp(STATUS_DISK_CORRUPT_ERROR, ERROR_DISK_CORRUPT);
+ cmp(STATUS_FT_MISSING_MEMBER, ERROR_IO_DEVICE);
+ cmp(STATUS_FT_ORPHANING, ERROR_IO_DEVICE);
+ cmp(STATUS_VARIABLE_NOT_FOUND, ERROR_ENVVAR_NOT_FOUND);
+ cmp(STATUS_OBJECT_NAME_INVALID, ERROR_INVALID_NAME);
+ cmp(STATUS_OBJECT_NAME_NOT_FOUND, ERROR_FILE_NOT_FOUND);
+ cmp(STATUS_OBJECT_NAME_COLLISION, ERROR_ALREADY_EXISTS);
+ cmp(STATUS_OBJECT_PATH_INVALID, ERROR_BAD_PATHNAME);
+ cmp(STATUS_OBJECT_PATH_NOT_FOUND, ERROR_PATH_NOT_FOUND);
+ cmp(STATUS_DFS_EXIT_PATH_FOUND, ERROR_PATH_NOT_FOUND);
+ cmp2(STATUS_DFS_UNAVAILABLE, ERROR_CONNECTION_UNAVAIL);
+ cmp(STATUS_OBJECT_PATH_SYNTAX_BAD, ERROR_BAD_PATHNAME);
+ cmp(STATUS_NAME_TOO_LONG, ERROR_FILENAME_EXCED_RANGE);
+ cmp(STATUS_DATA_OVERRUN, ERROR_IO_DEVICE);
+ cmp(STATUS_DATA_LATE_ERROR, ERROR_IO_DEVICE);
+ cmp(STATUS_DATA_ERROR, ERROR_CRC);
+ cmp(STATUS_CRC_ERROR, ERROR_CRC);
+ cmp(STATUS_SHARING_VIOLATION, ERROR_SHARING_VIOLATION);
+ cmp(STATUS_QUOTA_EXCEEDED, ERROR_NOT_ENOUGH_QUOTA);
+ cmp(STATUS_MUTANT_NOT_OWNED, ERROR_NOT_OWNER);
+ cmp(STATUS_SEMAPHORE_LIMIT_EXCEEDED, ERROR_TOO_MANY_POSTS);
+ cmp(STATUS_DISK_FULL, ERROR_DISK_FULL);
+ cmp(STATUS_LOCK_NOT_GRANTED, ERROR_LOCK_VIOLATION);
+ cmp(STATUS_FILE_LOCK_CONFLICT, ERROR_LOCK_VIOLATION);
+ cmp(STATUS_NOT_A_DIRECTORY, ERROR_DIRECTORY);
+ cmp2(STATUS_CANNOT_MAKE, ERROR_CANNOT_MAKE);
+ cmp(STATUS_UNKNOWN_REVISION, ERROR_UNKNOWN_REVISION);
+ cmp(STATUS_REVISION_MISMATCH, ERROR_REVISION_MISMATCH);
+ cmp(STATUS_INVALID_OWNER, ERROR_INVALID_OWNER);
+ cmp(STATUS_INVALID_PRIMARY_GROUP, ERROR_INVALID_PRIMARY_GROUP);
+ cmp(STATUS_NO_IMPERSONATION_TOKEN, ERROR_NO_IMPERSONATION_TOKEN);
+ cmp(STATUS_CANT_DISABLE_MANDATORY, ERROR_CANT_DISABLE_MANDATORY);
+ cmp(STATUS_NO_LOGON_SERVERS, ERROR_NO_LOGON_SERVERS);
+ cmp(STATUS_DOMAIN_CONTROLLER_NOT_FOUND, ERROR_DOMAIN_CONTROLLER_NOT_FOUND);
+ cmp(STATUS_NO_SUCH_LOGON_SESSION, ERROR_NO_SUCH_LOGON_SESSION);
+ cmp(STATUS_INVALID_ACCOUNT_NAME, ERROR_INVALID_ACCOUNT_NAME);
+ cmp(STATUS_USER_EXISTS, ERROR_USER_EXISTS);
+ cmp(STATUS_NO_SUCH_USER, ERROR_NO_SUCH_USER);
+ cmp(STATUS_GROUP_EXISTS, ERROR_GROUP_EXISTS);
+ cmp(STATUS_NO_SUCH_GROUP, ERROR_NO_SUCH_GROUP);
+ cmp(STATUS_SPECIAL_GROUP, ERROR_SPECIAL_GROUP);
+ cmp(STATUS_MEMBER_IN_GROUP, ERROR_MEMBER_IN_GROUP);
+ cmp(STATUS_MEMBER_NOT_IN_GROUP, ERROR_MEMBER_NOT_IN_GROUP);
+ cmp(STATUS_LAST_ADMIN, ERROR_LAST_ADMIN);
+ cmp(STATUS_WRONG_PASSWORD, ERROR_INVALID_PASSWORD);
+ cmp(STATUS_WRONG_PASSWORD_CORE, ERROR_INVALID_PASSWORD);
+ cmp(STATUS_ILL_FORMED_PASSWORD, ERROR_ILL_FORMED_PASSWORD);
+ cmp(STATUS_PASSWORD_RESTRICTION, ERROR_PASSWORD_RESTRICTION);
+ cmp(STATUS_PASSWORD_EXPIRED, ERROR_PASSWORD_EXPIRED);
+ cmp(STATUS_PASSWORD_MUST_CHANGE, ERROR_PASSWORD_MUST_CHANGE);
+ cmp(STATUS_ACCOUNT_DISABLED, ERROR_ACCOUNT_DISABLED);
+ cmp(STATUS_ACCOUNT_LOCKED_OUT, ERROR_ACCOUNT_LOCKED_OUT);
+ cmp(STATUS_NONE_MAPPED, ERROR_NONE_MAPPED);
+ cmp(STATUS_TOO_MANY_LUIDS_REQUESTED, ERROR_TOO_MANY_LUIDS_REQUESTED);
+ cmp(STATUS_LUIDS_EXHAUSTED, ERROR_LUIDS_EXHAUSTED);
+ cmp(STATUS_INVALID_SUB_AUTHORITY, ERROR_INVALID_SUB_AUTHORITY);
+ cmp(STATUS_INVALID_ACL, ERROR_INVALID_ACL);
+ cmp(STATUS_INVALID_SID, ERROR_INVALID_SID);
+ cmp(STATUS_INVALID_SECURITY_DESCR, ERROR_INVALID_SECURITY_DESCR);
+ cmp(STATUS_PROCEDURE_NOT_FOUND, ERROR_PROC_NOT_FOUND);
+ cmp(STATUS_BAD_INITIAL_PC, ERROR_BAD_EXE_FORMAT);
+ cmp(STATUS_INVALID_FILE_FOR_SECTION, ERROR_BAD_EXE_FORMAT);
+ cmp(STATUS_INVALID_IMAGE_FORMAT, ERROR_BAD_EXE_FORMAT);
+ cmp(STATUS_IMAGE_MP_UP_MISMATCH, ERROR_BAD_EXE_FORMAT);
+ cmp(STATUS_INVALID_IMAGE_NOT_MZ, ERROR_BAD_EXE_FORMAT);
+ cmp(STATUS_IMAGE_CHECKSUM_MISMATCH, ERROR_BAD_EXE_FORMAT);
+ cmp(STATUS_INVALID_IMAGE_PROTECT, ERROR_BAD_EXE_FORMAT);
+ cmp(STATUS_INVALID_IMAGE_LE_FORMAT, ERROR_BAD_EXE_FORMAT);
+ cmp(STATUS_INVALID_IMAGE_NE_FORMAT, ERROR_BAD_EXE_FORMAT);
+ cmp(STATUS_INVALID_IMAGE_WIN_16, ERROR_BAD_EXE_FORMAT);
+ cmp2(STATUS_INVALID_IMAGE_WIN_32, ERROR_BAD_EXE_FORMAT);
+ cmp2(STATUS_INVALID_IMAGE_WIN_64, ERROR_BAD_EXE_FORMAT);
+ cmp(STATUS_NO_TOKEN, ERROR_NO_TOKEN);
+ cmp(STATUS_RANGE_NOT_LOCKED, ERROR_NOT_LOCKED);
+ cmp(STATUS_SERVER_DISABLED, ERROR_SERVER_DISABLED);
+ cmp(STATUS_SERVER_NOT_DISABLED, ERROR_SERVER_NOT_DISABLED);
+ cmp(STATUS_INVALID_ID_AUTHORITY, ERROR_INVALID_ID_AUTHORITY);
+ cmp(STATUS_ALLOTTED_SPACE_EXCEEDED, ERROR_ALLOTTED_SPACE_EXCEEDED);
+ cmp(STATUS_TOO_MANY_PAGING_FILES, ERROR_NOT_ENOUGH_MEMORY);
+ cmp(STATUS_INSUFFICIENT_RESOURCES, ERROR_NO_SYSTEM_RESOURCES);
+ cmp(STATUS_INSUFF_SERVER_RESOURCES, ERROR_NOT_ENOUGH_SERVER_MEMORY);
+ cmp(STATUS_FILE_INVALID, ERROR_FILE_INVALID);
+ cmp(STATUS_MAPPED_FILE_SIZE_ZERO, ERROR_FILE_INVALID);
+ cmp(STATUS_DEVICE_PAPER_EMPTY, ERROR_OUT_OF_PAPER);
+ cmp(STATUS_DEVICE_POWERED_OFF, ERROR_NOT_READY);
+ cmp(STATUS_DEVICE_OFF_LINE, ERROR_NOT_READY);
+ cmp(STATUS_DEVICE_DATA_ERROR, ERROR_CRC);
+ cmp(STATUS_DEVICE_NOT_READY, ERROR_NOT_READY);
+ cmp3(STATUS_DEVICE_NOT_CONNECTED, ERROR_DEVICE_NOT_CONNECTED, ERROR_NOT_READY);
+ cmp(STATUS_DEVICE_POWER_FAILURE, ERROR_NOT_READY);
+ cmp2(STATUS_NOT_FOUND, ERROR_NOT_FOUND);
+ cmp2(STATUS_NO_MATCH, ERROR_NO_MATCH);
+ cmp2(STATUS_PROPSET_NOT_FOUND, ERROR_SET_NOT_FOUND);
+ cmp(STATUS_DEVICE_BUSY, ERROR_BUSY);
+ cmp(STATUS_FREE_VM_NOT_AT_BASE, ERROR_INVALID_ADDRESS);
+ cmp(STATUS_MEMORY_NOT_ALLOCATED, ERROR_INVALID_ADDRESS);
+ cmp(STATUS_NOT_SAME_DEVICE, ERROR_NOT_SAME_DEVICE);
+ cmp(STATUS_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
+ cmp(STATUS_REMOTE_NOT_LISTENING, ERROR_REM_NOT_LIST);
+ cmp(STATUS_DUPLICATE_NAME, ERROR_DUP_NAME);
+ cmp(STATUS_BAD_NETWORK_PATH, ERROR_BAD_NETPATH);
+ cmp(STATUS_NETWORK_BUSY, ERROR_NETWORK_BUSY);
+ cmp2(STATUS_ONLY_IF_CONNECTED, ERROR_ONLY_IF_CONNECTED);
+ cmp(STATUS_DEVICE_DOES_NOT_EXIST, ERROR_DEV_NOT_EXIST);
+ cmp(STATUS_TOO_MANY_COMMANDS, ERROR_TOO_MANY_CMDS);
+ cmp(STATUS_ADAPTER_HARDWARE_ERROR, ERROR_ADAP_HDW_ERR);
+ cmp(STATUS_REDIRECTOR_NOT_STARTED, ERROR_PATH_NOT_FOUND);
+ cmp(STATUS_INVALID_EA_NAME, ERROR_INVALID_EA_NAME);
+ cmp(STATUS_EA_LIST_INCONSISTENT, ERROR_EA_LIST_INCONSISTENT);
+ cmp(STATUS_EA_TOO_LARGE, ERROR_EA_LIST_INCONSISTENT);
+ cmp(STATUS_INVALID_EA_FLAG, ERROR_EA_LIST_INCONSISTENT);
+ cmp2(STATUS_EAS_NOT_SUPPORTED, ERROR_EAS_NOT_SUPPORTED);
+ cmp(STATUS_FILE_CORRUPT_ERROR, ERROR_FILE_CORRUPT);
+ cmp(STATUS_EA_CORRUPT_ERROR, ERROR_FILE_CORRUPT);
+ cmp(STATUS_NONEXISTENT_EA_ENTRY, ERROR_FILE_CORRUPT);
+ cmp(STATUS_NO_EAS_ON_FILE, ERROR_FILE_CORRUPT);
+ cmp2(STATUS_NOT_A_REPARSE_POINT, ERROR_NOT_A_REPARSE_POINT);
+ cmp4(STATUS_IO_REPARSE_TAG_INVALID, ERROR_REPARSE_TAG_INVALID, ERROR_INVALID_PARAMETER);
+ cmp4(STATUS_IO_REPARSE_TAG_MISMATCH, ERROR_REPARSE_TAG_MISMATCH, ERROR_INVALID_PARAMETER);
+ cmp2(STATUS_IO_REPARSE_TAG_NOT_HANDLED, ERROR_CANT_ACCESS_FILE);
+ cmp2(STATUS_REPARSE_POINT_NOT_RESOLVED, ERROR_CANT_RESOLVE_FILENAME);
+ cmp2(STATUS_DIRECTORY_IS_A_REPARSE_POINT, ERROR_BAD_PATHNAME);
+ cmp2(STATUS_REPARSE_ATTRIBUTE_CONFLICT, ERROR_REPARSE_ATTRIBUTE_CONFLICT);
+ cmp4(STATUS_IO_REPARSE_DATA_INVALID, ERROR_INVALID_REPARSE_DATA, ERROR_INVALID_PARAMETER);
+ cmp2(STATUS_FILE_IS_OFFLINE, ERROR_FILE_OFFLINE);
+ cmp2(STATUS_REMOTE_STORAGE_NOT_ACTIVE, ERROR_REMOTE_STORAGE_NOT_ACTIVE);
+ cmp2(STATUS_REMOTE_STORAGE_MEDIA_ERROR, ERROR_REMOTE_STORAGE_MEDIA_ERROR);
+ cmp2(STATUS_NO_TRACKING_SERVICE, ERROR_NO_TRACKING_SERVICE);
+ cmp2(STATUS_JOURNAL_DELETE_IN_PROGRESS, ERROR_JOURNAL_DELETE_IN_PROGRESS);
+ cmp2(STATUS_JOURNAL_NOT_ACTIVE, ERROR_JOURNAL_NOT_ACTIVE);
+ cmp2(STATUS_JOURNAL_ENTRY_DELETED, ERROR_JOURNAL_ENTRY_DELETED);
+ cmp(STATUS_INVALID_NETWORK_RESPONSE, ERROR_BAD_NET_RESP);
+ cmp(STATUS_USER_SESSION_DELETED, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_UNEXPECTED_NETWORK_ERROR, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_BAD_REMOTE_ADAPTER, ERROR_BAD_REM_ADAP);
+ cmp(STATUS_PRINT_QUEUE_FULL, ERROR_PRINTQ_FULL);
+ cmp(STATUS_NO_SPOOL_SPACE, ERROR_NO_SPOOL_SPACE);
+ cmp(STATUS_PRINT_CANCELLED, ERROR_PRINT_CANCELLED);
+ cmp(STATUS_NETWORK_NAME_DELETED, ERROR_NETNAME_DELETED);
+ cmp(STATUS_NETWORK_ACCESS_DENIED, ERROR_NETWORK_ACCESS_DENIED);
+ cmp(STATUS_BAD_DEVICE_TYPE, ERROR_BAD_DEV_TYPE);
+ cmp(STATUS_BAD_NETWORK_NAME, ERROR_BAD_NET_NAME);
+ cmp(STATUS_TOO_MANY_NAMES, ERROR_TOO_MANY_NAMES);
+ cmp(STATUS_TOO_MANY_GUIDS_REQUESTED, ERROR_TOO_MANY_NAMES);
+ cmp(STATUS_TOO_MANY_ADDRESSES, ERROR_TOO_MANY_NAMES);
+ cmp(STATUS_TOO_MANY_NODES, ERROR_TOO_MANY_NAMES);
+ cmp(STATUS_TOO_MANY_SESSIONS, ERROR_TOO_MANY_SESS);
+ cmp(STATUS_SHARING_PAUSED, ERROR_SHARING_PAUSED);
+ cmp(STATUS_REQUEST_NOT_ACCEPTED, ERROR_REQ_NOT_ACCEP);
+ cmp(STATUS_REDIRECTOR_PAUSED, ERROR_REDIR_PAUSED);
+ cmp(STATUS_NET_WRITE_FAULT, ERROR_NET_WRITE_FAULT);
+ cmp(STATUS_VIRTUAL_CIRCUIT_CLOSED, ERROR_VC_DISCONNECTED);
+ cmp(STATUS_INVALID_PIPE_STATE, ERROR_BAD_PIPE);
+ cmp(STATUS_INVALID_READ_MODE, ERROR_BAD_PIPE);
+ cmp(STATUS_PIPE_CLOSING, ERROR_NO_DATA);
+ cmp(STATUS_PIPE_EMPTY, ERROR_NO_DATA);
+ cmp(STATUS_PIPE_CONNECTED, ERROR_PIPE_CONNECTED);
+ cmp(STATUS_PIPE_DISCONNECTED, ERROR_PIPE_NOT_CONNECTED);
+ cmp(STATUS_PIPE_LISTENING, ERROR_PIPE_LISTENING);
+ cmp(STATUS_PIPE_NOT_AVAILABLE, ERROR_PIPE_BUSY);
+ cmp(STATUS_INSTANCE_NOT_AVAILABLE, ERROR_PIPE_BUSY);
+ cmp(STATUS_PIPE_BUSY, ERROR_PIPE_BUSY);
+ cmp(STATUS_PIPE_BROKEN, ERROR_BROKEN_PIPE);
+ cmp(STATUS_DIRECTORY_NOT_EMPTY, ERROR_DIR_NOT_EMPTY);
+ cmp(STATUS_TOO_MANY_OPENED_FILES, ERROR_TOO_MANY_OPEN_FILES);
+ cmp(STATUS_IO_TIMEOUT, ERROR_SEM_TIMEOUT);
+ cmp(STATUS_CANCELLED, ERROR_OPERATION_ABORTED);
+ cmp(STATUS_UNRECOGNIZED_MEDIA, ERROR_UNRECOGNIZED_MEDIA);
+ cmp(STATUS_INVALID_LEVEL, ERROR_INVALID_LEVEL);
+ cmp(STATUS_UNRECOGNIZED_VOLUME, ERROR_UNRECOGNIZED_VOLUME);
+ cmp(STATUS_MEDIA_WRITE_PROTECTED, ERROR_WRITE_PROTECT);
+ cmp(STATUS_TOO_LATE, ERROR_WRITE_PROTECT);
+ cmp(STATUS_SUCCESS, NO_ERROR);
+ cmp(STATUS_FULLSCREEN_MODE, ERROR_FULLSCREEN_MODE);
+ cmp(STATUS_END_OF_MEDIA, ERROR_END_OF_MEDIA);
+ cmp(STATUS_EOM_OVERFLOW, ERROR_EOM_OVERFLOW);
+ cmp(STATUS_BEGINNING_OF_MEDIA, ERROR_BEGINNING_OF_MEDIA);
+ cmp(STATUS_MEDIA_CHANGED, ERROR_MEDIA_CHANGED);
+ cmp(STATUS_BUS_RESET, ERROR_BUS_RESET);
+ cmp(STATUS_FILEMARK_DETECTED, ERROR_FILEMARK_DETECTED);
+ cmp(STATUS_SETMARK_DETECTED, ERROR_SETMARK_DETECTED);
+ cmp(STATUS_NO_DATA_DETECTED, ERROR_NO_DATA_DETECTED);
+ cmp(STATUS_PARTITION_FAILURE, ERROR_PARTITION_FAILURE);
+ cmp(STATUS_INVALID_BLOCK_LENGTH, ERROR_INVALID_BLOCK_LENGTH);
+ cmp(STATUS_DEVICE_NOT_PARTITIONED, ERROR_DEVICE_NOT_PARTITIONED);
+ cmp(STATUS_UNABLE_TO_LOCK_MEDIA, ERROR_UNABLE_TO_LOCK_MEDIA);
+ cmp(STATUS_UNABLE_TO_UNLOAD_MEDIA, ERROR_UNABLE_TO_UNLOAD_MEDIA);
+ cmp(STATUS_UNMAPPABLE_CHARACTER, ERROR_NO_UNICODE_TRANSLATION);
+ cmp(STATUS_NOT_ALL_ASSIGNED, ERROR_NOT_ALL_ASSIGNED);
+ cmp(STATUS_SOME_NOT_MAPPED, ERROR_SOME_NOT_MAPPED);
+ cmp(STATUS_NO_QUOTAS_FOR_ACCOUNT, ERROR_NO_QUOTAS_FOR_ACCOUNT);
+ cmp(STATUS_LOCAL_USER_SESSION_KEY, ERROR_LOCAL_USER_SESSION_KEY);
+ cmp(STATUS_NULL_LM_PASSWORD, ERROR_NULL_LM_PASSWORD);
+ cmp(STATUS_BAD_INHERITANCE_ACL, ERROR_BAD_INHERITANCE_ACL);
+ cmp(STATUS_INVALID_GROUP_ATTRIBUTES, ERROR_INVALID_GROUP_ATTRIBUTES);
+ cmp(STATUS_BAD_IMPERSONATION_LEVEL, ERROR_BAD_IMPERSONATION_LEVEL);
+ cmp(STATUS_CANT_OPEN_ANONYMOUS, ERROR_CANT_OPEN_ANONYMOUS);
+ cmp(STATUS_BAD_VALIDATION_CLASS, ERROR_BAD_VALIDATION_CLASS);
+ cmp(STATUS_BAD_TOKEN_TYPE, ERROR_BAD_TOKEN_TYPE);
+ cmp2(STATUS_BAD_MASTER_BOOT_RECORD, ERROR_INVALID_PARAMETER);
+ cmp(STATUS_NO_SECURITY_ON_OBJECT, ERROR_NO_SECURITY_ON_OBJECT);
+ cmp(STATUS_CANT_ACCESS_DOMAIN_INFO, ERROR_CANT_ACCESS_DOMAIN_INFO);
+ cmp(STATUS_INVALID_SERVER_STATE, ERROR_INVALID_SERVER_STATE);
+ cmp(STATUS_INVALID_DOMAIN_STATE, ERROR_INVALID_DOMAIN_STATE);
+ cmp(STATUS_INVALID_DOMAIN_ROLE, ERROR_INVALID_DOMAIN_ROLE);
+ cmp(STATUS_NO_SUCH_DOMAIN, ERROR_NO_SUCH_DOMAIN);
+ cmp(STATUS_DOMAIN_EXISTS, ERROR_DOMAIN_EXISTS);
+ cmp(STATUS_DOMAIN_LIMIT_EXCEEDED, ERROR_DOMAIN_LIMIT_EXCEEDED);
+ cmp2(STATUS_OPLOCK_NOT_GRANTED, ERROR_OPLOCK_NOT_GRANTED);
+ cmp2(STATUS_INVALID_OPLOCK_PROTOCOL, ERROR_INVALID_OPLOCK_PROTOCOL);
+ cmp(STATUS_INTERNAL_DB_CORRUPTION, ERROR_INTERNAL_DB_CORRUPTION);
+ cmp(STATUS_INTERNAL_ERROR, ERROR_INTERNAL_ERROR);
+ cmp(STATUS_GENERIC_NOT_MAPPED, ERROR_GENERIC_NOT_MAPPED);
+ cmp(STATUS_BAD_DESCRIPTOR_FORMAT, ERROR_BAD_DESCRIPTOR_FORMAT);
+ cmp(STATUS_NOT_LOGON_PROCESS, ERROR_NOT_LOGON_PROCESS);
+ cmp(STATUS_LOGON_SESSION_EXISTS, ERROR_LOGON_SESSION_EXISTS);
+ cmp(STATUS_NO_SUCH_PACKAGE, ERROR_NO_SUCH_PACKAGE);
+ cmp(STATUS_BAD_LOGON_SESSION_STATE, ERROR_BAD_LOGON_SESSION_STATE);
+ cmp(STATUS_LOGON_SESSION_COLLISION, ERROR_LOGON_SESSION_COLLISION);
+ cmp(STATUS_INVALID_LOGON_TYPE, ERROR_INVALID_LOGON_TYPE);
+ cmp(STATUS_RXACT_INVALID_STATE, ERROR_RXACT_INVALID_STATE);
+ cmp(STATUS_RXACT_COMMIT_FAILURE, ERROR_RXACT_COMMIT_FAILURE);
+ cmp(STATUS_SPECIAL_ACCOUNT, ERROR_SPECIAL_ACCOUNT);
+ cmp(STATUS_SPECIAL_USER, ERROR_SPECIAL_USER);
+ cmp(STATUS_MEMBERS_PRIMARY_GROUP, ERROR_MEMBERS_PRIMARY_GROUP);
+ cmp(STATUS_TOKEN_ALREADY_IN_USE, ERROR_TOKEN_ALREADY_IN_USE);
+ cmp(STATUS_NO_SUCH_ALIAS, ERROR_NO_SUCH_ALIAS);
+ cmp(STATUS_MEMBER_NOT_IN_ALIAS, ERROR_MEMBER_NOT_IN_ALIAS);
+ cmp(STATUS_MEMBER_IN_ALIAS, ERROR_MEMBER_IN_ALIAS);
+ cmp(STATUS_ALIAS_EXISTS, ERROR_ALIAS_EXISTS);
+ cmp(STATUS_LOGON_NOT_GRANTED, ERROR_LOGON_NOT_GRANTED);
+ cmp(STATUS_TOO_MANY_SECRETS, ERROR_TOO_MANY_SECRETS);
+ cmp(STATUS_SECRET_TOO_LONG, ERROR_SECRET_TOO_LONG);
+ cmp(STATUS_INTERNAL_DB_ERROR, ERROR_INTERNAL_DB_ERROR);
+ cmp(STATUS_TOO_MANY_CONTEXT_IDS, ERROR_TOO_MANY_CONTEXT_IDS);
+ cmp(STATUS_LOGON_TYPE_NOT_GRANTED, ERROR_LOGON_TYPE_NOT_GRANTED);
+ cmp(STATUS_NT_CROSS_ENCRYPTION_REQUIRED, ERROR_NT_CROSS_ENCRYPTION_REQUIRED);
+ cmp(STATUS_NO_SUCH_MEMBER, ERROR_NO_SUCH_MEMBER);
+ cmp(STATUS_INVALID_MEMBER, ERROR_INVALID_MEMBER);
+ cmp(STATUS_TOO_MANY_SIDS, ERROR_TOO_MANY_SIDS);
+ cmp(STATUS_LM_CROSS_ENCRYPTION_REQUIRED, ERROR_LM_CROSS_ENCRYPTION_REQUIRED);
+ cmp(STATUS_MESSAGE_NOT_FOUND, ERROR_MR_MID_NOT_FOUND);
+ cmp(STATUS_LOCAL_DISCONNECT, ERROR_NETNAME_DELETED);
+ cmp(STATUS_REMOTE_DISCONNECT, ERROR_NETNAME_DELETED);
+ cmp(STATUS_REMOTE_RESOURCES, ERROR_REM_NOT_LIST);
+ cmp(STATUS_LINK_FAILED, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_LINK_TIMEOUT, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_INVALID_CONNECTION, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_INVALID_ADDRESS, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_IO_DEVICE_ERROR, ERROR_IO_DEVICE);
+ cmp(STATUS_DEVICE_PROTOCOL_ERROR, ERROR_IO_DEVICE);
+ cmp(STATUS_DRIVER_INTERNAL_ERROR, ERROR_IO_DEVICE);
+ cmp(STATUS_INVALID_DEVICE_STATE, ERROR_BAD_COMMAND);
+ cmp(STATUS_DEVICE_CONFIGURATION_ERROR, ERROR_INVALID_PARAMETER);
+ cmp2(STATUS_SOURCE_ELEMENT_EMPTY, ERROR_SOURCE_ELEMENT_EMPTY);
+ cmp2(STATUS_DESTINATION_ELEMENT_FULL, ERROR_DESTINATION_ELEMENT_FULL);
+ cmp2(STATUS_ILLEGAL_ELEMENT_ADDRESS, ERROR_ILLEGAL_ELEMENT_ADDRESS);
+ cmp2(STATUS_MAGAZINE_NOT_PRESENT, ERROR_MAGAZINE_NOT_PRESENT);
+ cmp2(STATUS_REINITIALIZATION_NEEDED, ERROR_DEVICE_REINITIALIZATION_NEEDED);
+ cmp2(STATUS_DEVICE_REQUIRES_CLEANING, ERROR_DEVICE_REQUIRES_CLEANING);
+ cmp2(STATUS_DEVICE_DOOR_OPEN, ERROR_DEVICE_DOOR_OPEN);
+ cmp2(STATUS_TRANSPORT_FULL, ERROR_TRANSPORT_FULL);
+ cmp2(STATUS_CLEANER_CARTRIDGE_INSTALLED, ERROR_CLEANER_CARTRIDGE_INSTALLED);
+ cmp2(STATUS_REG_NAT_CONSUMPTION, ERROR_REG_NAT_CONSUMPTION);
+ cmp4(STATUS_ENCRYPTION_FAILED, ERROR_ACCESS_DENIED, ERROR_ENCRYPTION_FAILED);
+ cmp4(STATUS_DECRYPTION_FAILED, ERROR_ACCESS_DENIED, ERROR_DECRYPTION_FAILED);
+ cmp4(STATUS_NO_RECOVERY_POLICY, ERROR_ACCESS_DENIED, ERROR_NO_RECOVERY_POLICY);
+ cmp4(STATUS_NO_EFS, ERROR_ACCESS_DENIED, ERROR_NO_EFS);
+ cmp4(STATUS_WRONG_EFS, ERROR_ACCESS_DENIED, ERROR_WRONG_EFS);
+ cmp4(STATUS_NO_USER_KEYS, ERROR_ACCESS_DENIED, ERROR_NO_USER_KEYS);
+ cmp2(STATUS_FILE_NOT_ENCRYPTED, ERROR_FILE_NOT_ENCRYPTED);
+ cmp2(STATUS_NOT_EXPORT_FORMAT, ERROR_NOT_EXPORT_FORMAT);
+ cmp2(STATUS_FILE_ENCRYPTED, ERROR_FILE_ENCRYPTED);
+ cmp2(STATUS_EFS_ALG_BLOB_TOO_BIG, ERROR_EFS_ALG_BLOB_TOO_BIG);
+ cmp(STATUS_INVALID_USER_BUFFER, ERROR_INVALID_USER_BUFFER);
+ cmp(STATUS_SERIAL_NO_DEVICE_INITED, ERROR_SERIAL_NO_DEVICE);
+ cmp(STATUS_SHARED_IRQ_BUSY, ERROR_IRQ_BUSY);
+ cmp(STATUS_SERIAL_MORE_WRITES, ERROR_MORE_WRITES);
+ cmp(STATUS_SERIAL_COUNTER_TIMEOUT, ERROR_COUNTER_TIMEOUT);
+ cmp(STATUS_FLOPPY_ID_MARK_NOT_FOUND, ERROR_FLOPPY_ID_MARK_NOT_FOUND);
+ cmp(STATUS_FLOPPY_WRONG_CYLINDER, ERROR_FLOPPY_WRONG_CYLINDER);
+ cmp(STATUS_FLOPPY_UNKNOWN_ERROR, ERROR_FLOPPY_UNKNOWN_ERROR);
+ cmp(STATUS_FLOPPY_BAD_REGISTERS, ERROR_FLOPPY_BAD_REGISTERS);
+ cmp(STATUS_DISK_RECALIBRATE_FAILED, ERROR_DISK_RECALIBRATE_FAILED);
+ cmp(STATUS_DISK_OPERATION_FAILED, ERROR_DISK_OPERATION_FAILED);
+ cmp(STATUS_DISK_RESET_FAILED, ERROR_DISK_RESET_FAILED);
+ cmp(STATUS_EVENTLOG_FILE_CORRUPT, ERROR_EVENTLOG_FILE_CORRUPT);
+ cmp(STATUS_EVENTLOG_CANT_START, ERROR_EVENTLOG_CANT_START);
+ cmp(STATUS_NETLOGON_NOT_STARTED, ERROR_NETLOGON_NOT_STARTED);
+ cmp(STATUS_ACCOUNT_EXPIRED, ERROR_ACCOUNT_EXPIRED);
+ cmp(STATUS_NETWORK_CREDENTIAL_CONFLICT, ERROR_SESSION_CREDENTIAL_CONFLICT);
+ cmp(STATUS_REMOTE_SESSION_LIMIT, ERROR_REMOTE_SESSION_LIMIT_EXCEEDED);
+ cmp(STATUS_INVALID_BUFFER_SIZE, ERROR_INVALID_USER_BUFFER);
+ cmp(STATUS_INVALID_ADDRESS_COMPONENT, ERROR_INVALID_NETNAME);
+ cmp(STATUS_INVALID_ADDRESS_WILDCARD, ERROR_INVALID_NETNAME);
+ cmp(STATUS_ADDRESS_ALREADY_EXISTS, ERROR_DUP_NAME);
+ cmp(STATUS_ADDRESS_CLOSED, ERROR_NETNAME_DELETED);
+ cmp(STATUS_CONNECTION_DISCONNECTED, ERROR_NETNAME_DELETED);
+ cmp(STATUS_CONNECTION_RESET, ERROR_NETNAME_DELETED);
+ cmp(STATUS_TRANSACTION_ABORTED, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_TRANSACTION_TIMED_OUT, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_TRANSACTION_NO_RELEASE, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_TRANSACTION_NO_MATCH, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_TRANSACTION_RESPONDED, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_TRANSACTION_INVALID_ID, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_TRANSACTION_INVALID_TYPE, ERROR_UNEXP_NET_ERR);
+ cmp(STATUS_NOT_SERVER_SESSION, ERROR_NOT_SUPPORTED);
+ cmp(STATUS_NOT_CLIENT_SESSION, ERROR_NOT_SUPPORTED);
+ cmp(STATUS_USER_MAPPED_FILE, ERROR_USER_MAPPED_FILE);
+ cmp(STATUS_PLUGPLAY_NO_DEVICE, ERROR_SERVICE_DISABLED);
+ cmp2(STATUS_WMI_GUID_NOT_FOUND, ERROR_WMI_GUID_NOT_FOUND);
+ cmp2(STATUS_WMI_INSTANCE_NOT_FOUND, ERROR_WMI_INSTANCE_NOT_FOUND);
+ cmp2(STATUS_WMI_ITEMID_NOT_FOUND, ERROR_WMI_ITEMID_NOT_FOUND);
+ cmp2(STATUS_WMI_TRY_AGAIN, ERROR_WMI_TRY_AGAIN);
+ cmp2(STATUS_WMI_READ_ONLY, ERROR_WMI_READ_ONLY);
+ cmp2(STATUS_WMI_SET_FAILURE, ERROR_WMI_SET_FAILURE);
+ cmp2(STATUS_WMI_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
+ cmp2(STATUS_WMI_GUID_DISCONNECTED, ERROR_WMI_GUID_DISCONNECTED);
+ cmp2(STATUS_WMI_ALREADY_DISABLED, ERROR_WMI_ALREADY_DISABLED);
+ cmp2(STATUS_WMI_ALREADY_ENABLED, ERROR_WMI_ALREADY_ENABLED);
+ cmp2(STATUS_COPY_PROTECTION_FAILURE, STG_E_STATUS_COPY_PROTECTION_FAILURE);
+ cmp2(STATUS_CSS_AUTHENTICATION_FAILURE, STG_E_CSS_AUTHENTICATION_FAILURE);
+ cmp2(STATUS_CSS_KEY_NOT_PRESENT, STG_E_CSS_KEY_NOT_PRESENT);
+ cmp2(STATUS_CSS_KEY_NOT_ESTABLISHED, STG_E_CSS_KEY_NOT_ESTABLISHED);
+ cmp2(STATUS_CSS_SCRAMBLED_SECTOR, STG_E_CSS_SCRAMBLED_SECTOR);
+ cmp2(STATUS_CSS_REGION_MISMATCH, STG_E_CSS_REGION_MISMATCH);
+ cmp2(STATUS_CSS_RESETS_EXHAUSTED, STG_E_RESETS_EXHAUSTED);
+ cmp(RPC_NT_SERVER_UNAVAILABLE, RPC_S_SERVER_UNAVAILABLE);
+ cmp(RPC_NT_INVALID_STRING_BINDING, RPC_S_INVALID_STRING_BINDING);
+ cmp(RPC_NT_WRONG_KIND_OF_BINDING, RPC_S_WRONG_KIND_OF_BINDING);
+ cmp(RPC_NT_PROTSEQ_NOT_SUPPORTED, RPC_S_PROTSEQ_NOT_SUPPORTED);
+ cmp(RPC_NT_INVALID_RPC_PROTSEQ, RPC_S_INVALID_RPC_PROTSEQ);
+ cmp(RPC_NT_INVALID_STRING_UUID, RPC_S_INVALID_STRING_UUID);
+ cmp(RPC_NT_INVALID_ENDPOINT_FORMAT, RPC_S_INVALID_ENDPOINT_FORMAT);
+ cmp(RPC_NT_INVALID_NET_ADDR, RPC_S_INVALID_NET_ADDR);
+ cmp(RPC_NT_NO_ENDPOINT_FOUND, RPC_S_NO_ENDPOINT_FOUND);
+ cmp(RPC_NT_INVALID_TIMEOUT, RPC_S_INVALID_TIMEOUT);
+ cmp(RPC_NT_OBJECT_NOT_FOUND, RPC_S_OBJECT_NOT_FOUND);
+ cmp(RPC_NT_ALREADY_REGISTERED, RPC_S_ALREADY_REGISTERED);
+ cmp(RPC_NT_TYPE_ALREADY_REGISTERED, RPC_S_TYPE_ALREADY_REGISTERED);
+ cmp(RPC_NT_ALREADY_LISTENING, RPC_S_ALREADY_LISTENING);
+ cmp(RPC_NT_NO_PROTSEQS_REGISTERED, RPC_S_NO_PROTSEQS_REGISTERED);
+ cmp(RPC_NT_NOT_LISTENING, RPC_S_NOT_LISTENING);
+ cmp(RPC_NT_UNKNOWN_MGR_TYPE, RPC_S_UNKNOWN_MGR_TYPE);
+ cmp(RPC_NT_UNKNOWN_IF, RPC_S_UNKNOWN_IF);
+ cmp(RPC_NT_NO_BINDINGS, RPC_S_NO_BINDINGS);
+ cmp(RPC_NT_NO_MORE_BINDINGS, RPC_S_NO_MORE_BINDINGS);
+ cmp(RPC_NT_NO_PROTSEQS, RPC_S_NO_PROTSEQS);
+ cmp(RPC_NT_CANT_CREATE_ENDPOINT, RPC_S_CANT_CREATE_ENDPOINT);
+ cmp(RPC_NT_OUT_OF_RESOURCES, RPC_S_OUT_OF_RESOURCES);
+ cmp(RPC_NT_SERVER_TOO_BUSY, RPC_S_SERVER_TOO_BUSY);
+ cmp(RPC_NT_INVALID_NETWORK_OPTIONS, RPC_S_INVALID_NETWORK_OPTIONS);
+ cmp(RPC_NT_NO_CALL_ACTIVE, RPC_S_NO_CALL_ACTIVE);
+ cmp(RPC_NT_CALL_FAILED, RPC_S_CALL_FAILED);
+ cmp(RPC_NT_CALL_FAILED_DNE, RPC_S_CALL_FAILED_DNE);
+ cmp(RPC_NT_PROTOCOL_ERROR, RPC_S_PROTOCOL_ERROR);
+ cmp(RPC_NT_UNSUPPORTED_TRANS_SYN, RPC_S_UNSUPPORTED_TRANS_SYN);
+ cmp(RPC_NT_UNSUPPORTED_TYPE, RPC_S_UNSUPPORTED_TYPE);
+ cmp(RPC_NT_INVALID_TAG, RPC_S_INVALID_TAG);
+ cmp(RPC_NT_INVALID_BOUND, RPC_S_INVALID_BOUND);
+ cmp(RPC_NT_NO_ENTRY_NAME, RPC_S_NO_ENTRY_NAME);
+ cmp(RPC_NT_INVALID_NAME_SYNTAX, RPC_S_INVALID_NAME_SYNTAX);
+ cmp(RPC_NT_UNSUPPORTED_NAME_SYNTAX, RPC_S_UNSUPPORTED_NAME_SYNTAX);
+ cmp(RPC_NT_UUID_NO_ADDRESS, RPC_S_UUID_NO_ADDRESS);
+ cmp(RPC_NT_DUPLICATE_ENDPOINT, RPC_S_DUPLICATE_ENDPOINT);
+ cmp(RPC_NT_UNKNOWN_AUTHN_TYPE, RPC_S_UNKNOWN_AUTHN_TYPE);
+ cmp(RPC_NT_MAX_CALLS_TOO_SMALL, RPC_S_MAX_CALLS_TOO_SMALL);
+ cmp(RPC_NT_STRING_TOO_LONG, RPC_S_STRING_TOO_LONG);
+ cmp(RPC_NT_PROTSEQ_NOT_FOUND, RPC_S_PROTSEQ_NOT_FOUND);
+ cmp(RPC_NT_PROCNUM_OUT_OF_RANGE, RPC_S_PROCNUM_OUT_OF_RANGE);
+ cmp(RPC_NT_BINDING_HAS_NO_AUTH, RPC_S_BINDING_HAS_NO_AUTH);
+ cmp(RPC_NT_UNKNOWN_AUTHN_SERVICE, RPC_S_UNKNOWN_AUTHN_SERVICE);
+ cmp(RPC_NT_UNKNOWN_AUTHN_LEVEL, RPC_S_UNKNOWN_AUTHN_LEVEL);
+ cmp(RPC_NT_INVALID_AUTH_IDENTITY, RPC_S_INVALID_AUTH_IDENTITY);
+ cmp(RPC_NT_UNKNOWN_AUTHZ_SERVICE, RPC_S_UNKNOWN_AUTHZ_SERVICE);
+ cmp(EPT_NT_INVALID_ENTRY, EPT_S_INVALID_ENTRY);
+ cmp(EPT_NT_CANT_PERFORM_OP, EPT_S_CANT_PERFORM_OP);
+ cmp(EPT_NT_NOT_REGISTERED, EPT_S_NOT_REGISTERED);
+ cmp(RPC_NT_NOTHING_TO_EXPORT, RPC_S_NOTHING_TO_EXPORT);
+ cmp(RPC_NT_INCOMPLETE_NAME, RPC_S_INCOMPLETE_NAME);
+ cmp(RPC_NT_INVALID_VERS_OPTION, RPC_S_INVALID_VERS_OPTION);
+ cmp(RPC_NT_NO_MORE_MEMBERS, RPC_S_NO_MORE_MEMBERS);
+ cmp(RPC_NT_NOT_ALL_OBJS_UNEXPORTED, RPC_S_NOT_ALL_OBJS_UNEXPORTED);
+ cmp(RPC_NT_INTERFACE_NOT_FOUND, RPC_S_INTERFACE_NOT_FOUND);
+ cmp(RPC_NT_ENTRY_ALREADY_EXISTS, RPC_S_ENTRY_ALREADY_EXISTS);
+ cmp(RPC_NT_ENTRY_NOT_FOUND, RPC_S_ENTRY_NOT_FOUND);
+ cmp(RPC_NT_NAME_SERVICE_UNAVAILABLE, RPC_S_NAME_SERVICE_UNAVAILABLE);
+ cmp(RPC_NT_INVALID_NAF_ID, RPC_S_INVALID_NAF_ID);
+ cmp(RPC_NT_CANNOT_SUPPORT, RPC_S_CANNOT_SUPPORT);
+ cmp(RPC_NT_NO_CONTEXT_AVAILABLE, RPC_S_NO_CONTEXT_AVAILABLE);
+ cmp(RPC_NT_INTERNAL_ERROR, RPC_S_INTERNAL_ERROR);
+ cmp(RPC_NT_ZERO_DIVIDE, RPC_S_ZERO_DIVIDE);
+ cmp(RPC_NT_ADDRESS_ERROR, RPC_S_ADDRESS_ERROR);
+ cmp(RPC_NT_FP_DIV_ZERO, RPC_S_FP_DIV_ZERO);
+ cmp(RPC_NT_FP_UNDERFLOW, RPC_S_FP_UNDERFLOW);
+ cmp(RPC_NT_FP_OVERFLOW, RPC_S_FP_OVERFLOW);
+ cmp(RPC_NT_NO_MORE_ENTRIES, RPC_X_NO_MORE_ENTRIES);
+ cmp(RPC_NT_SS_CHAR_TRANS_OPEN_FAIL, RPC_X_SS_CHAR_TRANS_OPEN_FAIL);
+ cmp(RPC_NT_SS_CHAR_TRANS_SHORT_FILE, RPC_X_SS_CHAR_TRANS_SHORT_FILE);
+ cmp(RPC_NT_SS_CONTEXT_MISMATCH, ERROR_INVALID_HANDLE);
+ cmp(RPC_NT_SS_CONTEXT_DAMAGED, RPC_X_SS_CONTEXT_DAMAGED);
+ cmp(RPC_NT_SS_HANDLES_MISMATCH, RPC_X_SS_HANDLES_MISMATCH);
+ cmp(RPC_NT_SS_CANNOT_GET_CALL_HANDLE, RPC_X_SS_CANNOT_GET_CALL_HANDLE);
+ cmp(RPC_NT_NULL_REF_POINTER, RPC_X_NULL_REF_POINTER);
+ cmp(RPC_NT_ENUM_VALUE_OUT_OF_RANGE, RPC_X_ENUM_VALUE_OUT_OF_RANGE);
+ cmp(RPC_NT_BYTE_COUNT_TOO_SMALL, RPC_X_BYTE_COUNT_TOO_SMALL);
+ cmp(RPC_NT_BAD_STUB_DATA, RPC_X_BAD_STUB_DATA);
+ cmp(RPC_NT_INVALID_OBJECT, RPC_S_INVALID_OBJECT);
+ cmp(STATUS_NO_TRUST_LSA_SECRET, ERROR_NO_TRUST_LSA_SECRET);
+ cmp(STATUS_NO_TRUST_SAM_ACCOUNT, ERROR_NO_TRUST_SAM_ACCOUNT);
+ cmp(STATUS_TRUSTED_DOMAIN_FAILURE, ERROR_TRUSTED_DOMAIN_FAILURE);
+ cmp(STATUS_TRUSTED_RELATIONSHIP_FAILURE, ERROR_TRUSTED_RELATIONSHIP_FAILURE);
+ cmp(STATUS_TRUST_FAILURE, ERROR_TRUST_FAILURE);
+ cmp(RPC_NT_CALL_IN_PROGRESS, RPC_S_CALL_IN_PROGRESS);
+ cmp(STATUS_LOG_FILE_FULL, ERROR_LOG_FILE_FULL);
+ cmp(STATUS_EVENTLOG_FILE_CHANGED, ERROR_EVENTLOG_FILE_CHANGED);
+ cmp(STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT, ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT);
+ cmp(STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT, ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT);
+ cmp(STATUS_NOLOGON_SERVER_TRUST_ACCOUNT, ERROR_NOLOGON_SERVER_TRUST_ACCOUNT);
+ cmp(STATUS_DOMAIN_TRUST_INCONSISTENT, ERROR_DOMAIN_TRUST_INCONSISTENT);
+ cmp(STATUS_NO_USER_SESSION_KEY, ERROR_NO_USER_SESSION_KEY);
+ cmp(STATUS_POSSIBLE_DEADLOCK, ERROR_POSSIBLE_DEADLOCK);
+ cmp(STATUS_IMAGE_ALREADY_LOADED, ERROR_SERVICE_ALREADY_RUNNING);
+ cmp(RPC_NT_GROUP_MEMBER_NOT_FOUND, RPC_S_GROUP_MEMBER_NOT_FOUND);
+ cmp(RPC_NT_NO_INTERFACES, RPC_S_NO_INTERFACES);
+ cmp(RPC_NT_CALL_CANCELLED, RPC_S_CALL_CANCELLED);
+ cmp(RPC_NT_BINDING_INCOMPLETE, RPC_S_BINDING_INCOMPLETE);
+ cmp(RPC_NT_COMM_FAILURE, RPC_S_COMM_FAILURE);
+ cmp(RPC_NT_UNSUPPORTED_AUTHN_LEVEL, RPC_S_UNSUPPORTED_AUTHN_LEVEL);
+ cmp(RPC_NT_NO_PRINC_NAME, RPC_S_NO_PRINC_NAME);
+ cmp(RPC_NT_NOT_RPC_ERROR, RPC_S_NOT_RPC_ERROR);
+ cmp(RPC_NT_UUID_LOCAL_ONLY, RPC_S_UUID_LOCAL_ONLY);
+ cmp(RPC_NT_SEC_PKG_ERROR, RPC_S_SEC_PKG_ERROR);
+ cmp(RPC_NT_NOT_CANCELLED, RPC_S_NOT_CANCELLED);
+ cmp(RPC_NT_INVALID_ES_ACTION, RPC_X_INVALID_ES_ACTION);
+ cmp(RPC_NT_WRONG_ES_VERSION, RPC_X_WRONG_ES_VERSION);
+ cmp(RPC_NT_WRONG_STUB_VERSION, RPC_X_WRONG_STUB_VERSION);
+ cmp(RPC_NT_INVALID_PIPE_OBJECT, RPC_X_INVALID_PIPE_OBJECT);
+ cmp(RPC_NT_INVALID_PIPE_OPERATION, RPC_X_INVALID_PIPE_OPERATION);
+ cmp(RPC_NT_WRONG_PIPE_VERSION, RPC_X_WRONG_PIPE_VERSION);
+ cmp(EPT_NT_CANT_CREATE, EPT_S_CANT_CREATE);
+ cmp(RPC_NT_SEND_INCOMPLETE, RPC_S_SEND_INCOMPLETE);
+ cmp2(RPC_NT_INVALID_ASYNC_HANDLE, RPC_S_INVALID_ASYNC_HANDLE);
+ cmp2(RPC_NT_INVALID_ASYNC_CALL, RPC_S_INVALID_ASYNC_CALL);
+ cmp2(RPC_NT_PIPE_CLOSED, RPC_X_PIPE_CLOSED);
+ cmp2(RPC_NT_PIPE_EMPTY, RPC_X_PIPE_EMPTY);
+ cmp2(RPC_NT_PIPE_DISCIPLINE_ERROR, RPC_X_PIPE_DISCIPLINE_ERROR);
+ cmp(STATUS_NO_BROWSER_SERVERS_FOUND, ERROR_NO_BROWSER_SERVERS_FOUND);
+ cmp(STATUS_MAPPED_ALIGNMENT, ERROR_MAPPED_ALIGNMENT);
+ cmp(STATUS_CONNECTION_IN_USE, ERROR_DEVICE_IN_USE);
+ cmp(STATUS_VERIFY_REQUIRED, ERROR_MEDIA_CHANGED);
+ cmp(STATUS_ALREADY_DISCONNECTED, ERROR_ACTIVE_CONNECTIONS);
+ cmp(STATUS_CONNECTION_REFUSED, ERROR_CONNECTION_REFUSED);
+ cmp(STATUS_GRACEFUL_DISCONNECT, ERROR_GRACEFUL_DISCONNECT);
+ cmp(STATUS_ADDRESS_ALREADY_ASSOCIATED, ERROR_ADDRESS_ALREADY_ASSOCIATED);
+ cmp(STATUS_ADDRESS_NOT_ASSOCIATED, ERROR_ADDRESS_NOT_ASSOCIATED);
+ cmp(STATUS_CONNECTION_INVALID, ERROR_CONNECTION_INVALID);
+ cmp(STATUS_CONNECTION_ACTIVE, ERROR_CONNECTION_ACTIVE);
+ cmp(STATUS_NETWORK_UNREACHABLE, ERROR_NETWORK_UNREACHABLE);
+ cmp(STATUS_HOST_UNREACHABLE, ERROR_HOST_UNREACHABLE);
+ cmp2(STATUS_HOST_DOWN, ERROR_HOST_DOWN);
+ cmp(STATUS_PROTOCOL_UNREACHABLE, ERROR_PROTOCOL_UNREACHABLE);
+ cmp(STATUS_PORT_UNREACHABLE, ERROR_PORT_UNREACHABLE);
+ cmp(STATUS_REQUEST_ABORTED, ERROR_REQUEST_ABORTED);
+ cmp(STATUS_CONNECTION_ABORTED, ERROR_CONNECTION_ABORTED);
+ cmp(STATUS_CONNECTION_COUNT_LIMIT, ERROR_CONNECTION_COUNT_LIMIT);
+ cmp(STATUS_PATH_NOT_COVERED, ERROR_HOST_UNREACHABLE);
+ cmp(STATUS_LOGIN_TIME_RESTRICTION, ERROR_LOGIN_TIME_RESTRICTION);
+ cmp(STATUS_LOGIN_WKSTA_RESTRICTION, ERROR_LOGIN_WKSTA_RESTRICTION);
+ cmp(STATUS_LICENSE_QUOTA_EXCEEDED, ERROR_LICENSE_QUOTA_EXCEEDED);
+ cmp(STATUS_RESOURCE_NOT_OWNED, ERROR_NOT_OWNER);
+ cmp(STATUS_DUPLICATE_OBJECTID, STATUS_DUPLICATE_OBJECTID);
+ cmp(STATUS_OBJECTID_EXISTS, STATUS_OBJECTID_EXISTS);
+ cmp2(STATUS_OBJECTID_NOT_FOUND, ERROR_FILE_NOT_FOUND);
+ cmp2(STATUS_MFT_TOO_FRAGMENTED, ERROR_DISK_TOO_FRAGMENTED);
+ cmp(SEC_E_INSUFFICIENT_MEMORY, ERROR_NO_SYSTEM_RESOURCES);
+ cmp(SEC_E_INVALID_HANDLE, ERROR_INVALID_HANDLE);
+ cmp(SEC_E_UNSUPPORTED_FUNCTION, ERROR_INVALID_FUNCTION);
+ cmp(SEC_E_TARGET_UNKNOWN, ERROR_BAD_NETPATH);
+ cmp(SEC_E_INTERNAL_ERROR, ERROR_INTERNAL_ERROR);
+ cmp(SEC_E_SECPKG_NOT_FOUND, ERROR_NO_SUCH_PACKAGE);
+ cmp(SEC_E_NOT_OWNER, ERROR_NOT_OWNER);
+ cmp(SEC_E_CANNOT_INSTALL, ERROR_NO_SUCH_PACKAGE);
+ cmp(SEC_E_INVALID_TOKEN, ERROR_INVALID_PARAMETER);
+ cmp(SEC_E_CANNOT_PACK, ERROR_INVALID_PARAMETER);
+ cmp(SEC_E_QOP_NOT_SUPPORTED, ERROR_NOT_SUPPORTED);
+ cmp(SEC_E_NO_IMPERSONATION, ERROR_CANNOT_IMPERSONATE);
+ cmp2(SEC_E_MULTIPLE_ACCOUNTS, ERROR_CANNOT_IMPERSONATE);
+ cmp(SEC_E_LOGON_DENIED, ERROR_LOGON_FAILURE);
+ cmp(SEC_E_UNKNOWN_CREDENTIALS, ERROR_INVALID_PARAMETER);
+ cmp2(SEC_E_INCOMPLETE_CREDENTIALS, ERROR_INVALID_PARAMETER);
+ cmp(SEC_E_NO_CREDENTIALS, ERROR_NO_SUCH_LOGON_SESSION);
+ cmp(SEC_E_MESSAGE_ALTERED, ERROR_ACCESS_DENIED);
+ cmp(SEC_E_OUT_OF_SEQUENCE, ERROR_ACCESS_DENIED);
+ cmp(SEC_E_NO_AUTHENTICATING_AUTHORITY, ERROR_NO_LOGON_SERVERS);
+ cmp(SEC_E_BAD_PKGID, ERROR_NO_SUCH_PACKAGE);
+ cmp4(SEC_E_WRONG_PRINCIPAL, ERROR_WRONG_TARGET_NAME, 1462);
+ cmp2(SEC_E_INCOMPLETE_MESSAGE, ERROR_INVALID_USER_BUFFER);
+ cmp2(SEC_E_BUFFER_TOO_SMALL, ERROR_INSUFFICIENT_BUFFER);
+ cmp2(SEC_E_UNTRUSTED_ROOT, ERROR_TRUST_FAILURE);
+ cmp2(SEC_E_ILLEGAL_MESSAGE, ERROR_INVALID_PARAMETER);
+ cmp2(SEC_E_CERT_UNKNOWN, ERROR_INVALID_PARAMETER);
+ cmp2(SEC_E_CERT_EXPIRED, ERROR_PASSWORD_EXPIRED);
+ cmp2(SEC_E_ENCRYPT_FAILURE, ERROR_ENCRYPTION_FAILED);
+ cmp2(SEC_E_DECRYPT_FAILURE, ERROR_DECRYPTION_FAILED);
+ cmp2(SEC_E_ALGORITHM_MISMATCH, ERROR_INVALID_FUNCTION);
+ cmp2(SEC_E_CONTEXT_EXPIRED, ERROR_CONTEXT_EXPIRED);
+ cmp2(STATUS_BAD_BINDINGS, SEC_E_BAD_BINDINGS);
+ cmp2(TRUST_E_CERT_SIGNATURE, ERROR_MUTUAL_AUTH_FAILED);
+ cmp2(CRYPT_E_REVOKED, ERROR_MUTUAL_AUTH_FAILED);
+ cmp2(CRYPT_E_NO_REVOCATION_CHECK, ERROR_MUTUAL_AUTH_FAILED);
+ cmp2(CRYPT_E_REVOCATION_OFFLINE, ERROR_MUTUAL_AUTH_FAILED);
+ cmp2(STATUS_SHUTDOWN_IN_PROGRESS, ERROR_SHUTDOWN_IN_PROGRESS);
+ cmp2(STATUS_SERVER_SHUTDOWN_IN_PROGRESS, ERROR_SERVER_SHUTDOWN_IN_PROGRESS);
+ cmp4(STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY, ERROR_DS_MEMBERSHIP_EVALUATED_LOCALLY, 1922);
+ cmp4(STATUS_DS_NO_ATTRIBUTE_OR_VALUE, ERROR_DS_NO_ATTRIBUTE_OR_VALUE, 1923);
+ cmp4(STATUS_DS_INVALID_ATTRIBUTE_SYNTAX, ERROR_DS_INVALID_ATTRIBUTE_SYNTAX, 1924);
+ cmp4(STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED, ERROR_DS_ATTRIBUTE_TYPE_UNDEFINED, 1925);
+ cmp4(STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS, ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS, 1926);
+ cmp4(STATUS_DS_BUSY, ERROR_DS_BUSY, 1927);
+ cmp4(STATUS_DS_UNAVAILABLE, ERROR_DS_UNAVAILABLE, 1928);
+ cmp4(STATUS_DS_NO_RIDS_ALLOCATED, ERROR_DS_NO_RIDS_ALLOCATED, 1929);
+ cmp4(STATUS_DS_NO_MORE_RIDS, ERROR_DS_NO_MORE_RIDS, 1930);
+ cmp4(STATUS_DS_INCORRECT_ROLE_OWNER, ERROR_DS_INCORRECT_ROLE_OWNER, 1931);
+ cmp4(STATUS_DS_RIDMGR_INIT_ERROR, ERROR_DS_RIDMGR_INIT_ERROR, 1932);
+ cmp4(STATUS_DS_OBJ_CLASS_VIOLATION, ERROR_DS_OBJ_CLASS_VIOLATION, 1933);
+ cmp4(STATUS_DS_CANT_ON_NON_LEAF, ERROR_DS_CANT_ON_NON_LEAF, 1934);
+ cmp4(STATUS_DS_CANT_ON_RDN, ERROR_DS_CANT_ON_RDN, 1935);
+ cmp4(STATUS_DS_CROSS_DOM_MOVE_FAILED, ERROR_DS_CROSS_DOM_MOVE_ERROR, 1937);
+ cmp4(STATUS_DS_GC_NOT_AVAILABLE, ERROR_DS_GC_NOT_AVAILABLE, 1938);
+ cmp2(STATUS_DS_CANT_MOD_OBJ_CLASS, ERROR_DS_CANT_MOD_OBJ_CLASS);
+ cmp2(STATUS_DS_ADMIN_LIMIT_EXCEEDED, ERROR_DS_ADMIN_LIMIT_EXCEEDED);
+ cmp2(STATUS_DIRECTORY_SERVICE_REQUIRED, ERROR_DS_DS_REQUIRED);
+ cmp2(STATUS_DS_SAM_INIT_FAILURE, ERROR_DS_SAM_INIT_FAILURE);
+ cmp2(STATUS_DS_CANT_START, ERROR_DS_CANT_START);
+ cmp2(STATUS_DS_INIT_FAILURE, ERROR_DS_INIT_FAILURE);
+ cmp2(STATUS_SAM_INIT_FAILURE, ERROR_SAM_INIT_FAILURE);
+ cmp2(STATUS_DS_SENSITIVE_GROUP_VIOLATION, ERROR_DS_SENSITIVE_GROUP_VIOLATION);
+ cmp2(STATUS_DS_CANT_MOD_PRIMARYGROUPID, ERROR_DS_CANT_MOD_PRIMARYGROUPID);
+ cmp2(STATUS_DS_INVALID_GROUP_TYPE, ERROR_DS_INVALID_GROUP_TYPE);
+ cmp2(STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN, ERROR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN);
+ cmp2(STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN, ERROR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN);
+ cmp2(STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER, ERROR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER);
+ cmp2(STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER, ERROR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER);
+ cmp2(STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER, ERROR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER);
+ cmp2(STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER, ERROR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER);
+ cmp2(STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER, ERROR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER);
+ cmp2(STATUS_DS_HAVE_PRIMARY_MEMBERS, ERROR_DS_HAVE_PRIMARY_MEMBERS);
+ cmp2(STATUS_DS_GC_REQUIRED, ERROR_DS_GC_REQUIRED);
+ cmp2(STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY, ERROR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY);
+ cmp2(STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS, ERROR_DS_NO_FPO_IN_UNIVERSAL_GROUPS);
+ cmp2(STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED,ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED);
+ cmp2(STATUS_SAM_NEED_BOOTKEY_PASSWORD, ERROR_DS_SAM_NEED_BOOTKEY_PASSWORD);
+ cmp2(STATUS_SAM_NEED_BOOTKEY_FLOPPY, ERROR_DS_SAM_NEED_BOOTKEY_FLOPPY);
+ cmp2(STATUS_DS_INIT_FAILURE_CONSOLE, ERROR_DS_INIT_FAILURE_CONSOLE);
+ cmp2(STATUS_DS_SAM_INIT_FAILURE_CONSOLE, ERROR_DS_SAM_INIT_FAILURE_CONSOLE);
+ cmp2(STATUS_UNFINISHED_CONTEXT_DELETED, SEC_E_UNFINISHED_CONTEXT_DELETED);
+ cmp2(STATUS_NO_TGT_REPLY, SEC_E_NO_TGT_REPLY);
+ cmp2(STATUS_NO_IP_ADDRESSES, SEC_E_NO_IP_ADDRESSES);
+ cmp2(STATUS_WRONG_CREDENTIAL_HANDLE, SEC_E_WRONG_CREDENTIAL_HANDLE);
+ cmp2(STATUS_CRYPTO_SYSTEM_INVALID, SEC_E_CRYPTO_SYSTEM_INVALID);
+ cmp2(STATUS_MAX_REFERRALS_EXCEEDED, SEC_E_MAX_REFERRALS_EXCEEDED);
+ cmp2(STATUS_MUST_BE_KDC, SEC_E_MUST_BE_KDC);
+ cmp2(STATUS_STRONG_CRYPTO_NOT_SUPPORTED, SEC_E_STRONG_CRYPTO_NOT_SUPPORTED);
+ cmp2(STATUS_TOO_MANY_PRINCIPALS, SEC_E_TOO_MANY_PRINCIPALS);
+ cmp2(STATUS_NO_PA_DATA, SEC_E_NO_PA_DATA);
+ cmp2(STATUS_PKINIT_NAME_MISMATCH, SEC_E_PKINIT_NAME_MISMATCH);
+ cmp2(STATUS_SMARTCARD_LOGON_REQUIRED, SEC_E_SMARTCARD_LOGON_REQUIRED);
+ cmp2(STATUS_KDC_INVALID_REQUEST, SEC_E_KDC_INVALID_REQUEST);
+ cmp2(STATUS_KDC_UNABLE_TO_REFER, SEC_E_KDC_UNABLE_TO_REFER);
+ cmp2(STATUS_KDC_UNKNOWN_ETYPE, SEC_E_KDC_UNKNOWN_ETYPE);
+ cmp2(STATUS_UNSUPPORTED_PREAUTH, SEC_E_UNSUPPORTED_PREAUTH);
+ cmp4(STATUS_SHARED_POLICY, ERROR_SHARED_POLICY, 1939);
+ cmp4(STATUS_POLICY_OBJECT_NOT_FOUND, ERROR_POLICY_OBJECT_NOT_FOUND, 1940);
+ cmp4(STATUS_POLICY_ONLY_IN_DS, ERROR_POLICY_ONLY_IN_DS, 1941);
+ cmp4(STATUS_DEVICE_REMOVED, ERROR_DEVICE_REMOVED, 617);
+ cmp2(STATUS_RETRY, ERROR_RETRY);
+ cmp2(STATUS_NOT_SUPPORTED_ON_SBS, ERROR_NOT_SUPPORTED_ON_SBS);
+ cmp2(STATUS_DRIVER_BLOCKED_CRITICAL, ERROR_DRIVER_BLOCKED);
+ cmp2(STATUS_DRIVER_BLOCKED, ERROR_DRIVER_BLOCKED);
+ cmp2(STATUS_PRENT4_MACHINE_ACCOUNT, ERROR_DS_MACHINE_ACCOUNT_CREATED_PRENT4);
+ cmp2(STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER,ERROR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER);
+ cmp2(STATUS_DS_SHUTTING_DOWN, ERROR_DS_SHUTTING_DOWN);
+ cmp2(STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT, ERROR_ACCESS_DISABLED_BY_POLICY);
+ cmp2(STATUS_ACCESS_DISABLED_BY_POLICY_PATH, ERROR_ACCESS_DISABLED_BY_POLICY);
+ cmp2(STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER, ERROR_ACCESS_DISABLED_BY_POLICY);
+ cmp2(STATUS_ACCESS_DISABLED_BY_POLICY_OTHER, ERROR_ACCESS_DISABLED_BY_POLICY);
+ cmp2(STATUS_FAIL_CHECK, ERROR_INVALID_PARAMETER);
+ cmp2(STATUS_CTX_CLOSE_PENDING, ERROR_CTX_CLOSE_PENDING);
+ cmp2(STATUS_CTX_NO_OUTBUF, ERROR_CTX_NO_OUTBUF);
+ cmp2(STATUS_CTX_MODEM_INF_NOT_FOUND, ERROR_CTX_MODEM_INF_NOT_FOUND);
+ cmp2(STATUS_CTX_INVALID_MODEMNAME, ERROR_CTX_INVALID_MODEMNAME);
+ cmp2(STATUS_CTX_RESPONSE_ERROR, ERROR_CTX_MODEM_RESPONSE_ERROR);
+ cmp2(STATUS_CTX_MODEM_RESPONSE_TIMEOUT, ERROR_CTX_MODEM_RESPONSE_TIMEOUT);
+ cmp2(STATUS_CTX_MODEM_RESPONSE_NO_CARRIER, ERROR_CTX_MODEM_RESPONSE_NO_CARRIER);
+ cmp2(STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE, ERROR_CTX_MODEM_RESPONSE_NO_DIALTONE);
+ cmp2(STATUS_CTX_MODEM_RESPONSE_BUSY, ERROR_CTX_MODEM_RESPONSE_BUSY);
+ cmp2(STATUS_CTX_MODEM_RESPONSE_VOICE, ERROR_CTX_MODEM_RESPONSE_VOICE);
+ cmp2(STATUS_CTX_TD_ERROR, ERROR_CTX_TD_ERROR);
+ cmp2(STATUS_CTX_WINSTATION_NAME_INVALID, ERROR_CTX_WINSTATION_NAME_INVALID);
+ cmp2(STATUS_CTX_WINSTATION_NOT_FOUND, ERROR_CTX_WINSTATION_NOT_FOUND);
+ cmp2(STATUS_CTX_WINSTATION_NAME_COLLISION, ERROR_CTX_WINSTATION_ALREADY_EXISTS);
+ cmp2(STATUS_CTX_WINSTATION_BUSY, ERROR_CTX_WINSTATION_BUSY);
+ cmp2(STATUS_CTX_GRAPHICS_INVALID, ERROR_CTX_GRAPHICS_INVALID);
+ cmp2(STATUS_CTX_BAD_VIDEO_MODE, ERROR_CTX_BAD_VIDEO_MODE);
+ cmp2(STATUS_CTX_NOT_CONSOLE, ERROR_CTX_NOT_CONSOLE);
+ cmp2(STATUS_CTX_CLIENT_QUERY_TIMEOUT, ERROR_CTX_CLIENT_QUERY_TIMEOUT);
+ cmp2(STATUS_CTX_CONSOLE_DISCONNECT, ERROR_CTX_CONSOLE_DISCONNECT);
+ cmp2(STATUS_CTX_CONSOLE_CONNECT, ERROR_CTX_CONSOLE_CONNECT);
+ cmp2(STATUS_CTX_SHADOW_DENIED, ERROR_CTX_SHADOW_DENIED);
+ cmp2(STATUS_CTX_SHADOW_INVALID, ERROR_CTX_SHADOW_INVALID);
+ cmp2(STATUS_CTX_SHADOW_DISABLED, ERROR_CTX_SHADOW_DISABLED);
+ cmp2(STATUS_CTX_WINSTATION_ACCESS_DENIED, ERROR_CTX_WINSTATION_ACCESS_DENIED);
+ cmp2(STATUS_CTX_INVALID_PD, ERROR_CTX_INVALID_PD);
+ cmp2(STATUS_CTX_PD_NOT_FOUND, ERROR_CTX_PD_NOT_FOUND);
+ cmp2(STATUS_CTX_INVALID_WD, ERROR_CTX_INVALID_WD);
+ cmp2(STATUS_CTX_WD_NOT_FOUND, ERROR_CTX_WD_NOT_FOUND);
+ cmp2(STATUS_CTX_CLIENT_LICENSE_IN_USE, ERROR_CTX_CLIENT_LICENSE_IN_USE);
+ cmp2(STATUS_CTX_CLIENT_LICENSE_NOT_SET, ERROR_CTX_CLIENT_LICENSE_NOT_SET);
+ cmp2(STATUS_CTX_LICENSE_NOT_AVAILABLE, ERROR_CTX_LICENSE_NOT_AVAILABLE);
+ cmp2(STATUS_CTX_LICENSE_CLIENT_INVALID, ERROR_CTX_LICENSE_CLIENT_INVALID);
+ cmp2(STATUS_CTX_LICENSE_EXPIRED, ERROR_CTX_LICENSE_EXPIRED);
+ cmp2(STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE, ERROR_CTX_SHADOW_ENDED_BY_MODE_CHANGE);
+ cmp2(STATUS_CTX_SHADOW_NOT_RUNNING, ERROR_CTX_SHADOW_NOT_RUNNING);
+ cmp2(STATUS_LICENSE_VIOLATION, ERROR_CTX_LICENSE_NOT_AVAILABLE);
+#if 0
+ /* FIXME - unknown STATUS values, see bug 1001 */
+ cmp(STATUS_ENDPOINT_CLOSED, ERROR_DEV_NOT_EXIST);
+ cmp(STATUS_DISCONNECTED, ERROR_DEV_NOT_EXIST);
+ cmp(STATUS_NONEXISTENT_NET_NAME, ERROR_DEV_NOT_EXIST);
+#endif
+ cmp2(STATUS_NETWORK_SESSION_EXPIRED, ERROR_NO_USER_SESSION_KEY);
+ cmp2(STATUS_FILES_OPEN, ERROR_OPEN_FILES);
+ cmp2(STATUS_SXS_SECTION_NOT_FOUND, ERROR_SXS_SECTION_NOT_FOUND);
+ cmp2(STATUS_SXS_CANT_GEN_ACTCTX, ERROR_SXS_CANT_GEN_ACTCTX);
+ cmp2(STATUS_SXS_INVALID_ACTCTXDATA_FORMAT, ERROR_SXS_INVALID_ACTCTXDATA_FORMAT);
+ cmp2(STATUS_SXS_ASSEMBLY_NOT_FOUND, ERROR_SXS_ASSEMBLY_NOT_FOUND);
+ cmp2(STATUS_SXS_MANIFEST_FORMAT_ERROR, ERROR_SXS_MANIFEST_FORMAT_ERROR);
+ cmp2(STATUS_SXS_MANIFEST_PARSE_ERROR, ERROR_SXS_MANIFEST_PARSE_ERROR);
+ cmp2(STATUS_SXS_ACTIVATION_CONTEXT_DISABLED, ERROR_SXS_ACTIVATION_CONTEXT_DISABLED);
+ cmp2(STATUS_SXS_KEY_NOT_FOUND, ERROR_SXS_KEY_NOT_FOUND);
+ cmp2(STATUS_SXS_WRONG_SECTION_TYPE, ERROR_SXS_WRONG_SECTION_TYPE);
+ cmp2(STATUS_SXS_THREAD_QUERIES_DISABLED, ERROR_SXS_THREAD_QUERIES_DISABLED);
+ cmp2(STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET, ERROR_SXS_PROCESS_DEFAULT_ALREADY_SET);
+ cmp2(STATUS_REDIRECTOR_STARTED, ERROR_SERVICE_ALREADY_RUNNING);
+ cmp2(STATUS_AUDITING_DISABLED, ERROR_AUDITING_DISABLED);
+ cmp2(STATUS_CLUSTER_NODE_ALREADY_UP, ERROR_CLUSTER_NODE_ALREADY_UP);
+ cmp2(STATUS_CLUSTER_NODE_ALREADY_DOWN, ERROR_CLUSTER_NODE_ALREADY_DOWN);
+ cmp2(STATUS_CLUSTER_NETWORK_ALREADY_ONLINE, ERROR_CLUSTER_NETWORK_ALREADY_ONLINE);
+ cmp2(STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE, ERROR_CLUSTER_NETWORK_ALREADY_OFFLINE);
+ cmp2(STATUS_CLUSTER_NODE_ALREADY_MEMBER, ERROR_CLUSTER_NODE_ALREADY_MEMBER);
+ cmp2(STATUS_CLUSTER_INVALID_NODE, ERROR_CLUSTER_INVALID_NODE);
+ cmp2(STATUS_CLUSTER_NODE_EXISTS, ERROR_CLUSTER_NODE_EXISTS);
+ cmp2(STATUS_CLUSTER_JOIN_IN_PROGRESS, ERROR_CLUSTER_JOIN_IN_PROGRESS);
+ cmp2(STATUS_CLUSTER_NODE_NOT_FOUND, ERROR_CLUSTER_NODE_NOT_FOUND);
+ cmp2(STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND, ERROR_CLUSTER_LOCAL_NODE_NOT_FOUND);
+ cmp2(STATUS_CLUSTER_NETWORK_EXISTS, ERROR_CLUSTER_NETWORK_EXISTS);
+ cmp2(STATUS_CLUSTER_NETWORK_NOT_FOUND, ERROR_CLUSTER_NETWORK_NOT_FOUND);
+ cmp2(STATUS_CLUSTER_NETINTERFACE_EXISTS, ERROR_CLUSTER_NETINTERFACE_EXISTS);
+ cmp2(STATUS_CLUSTER_NETINTERFACE_NOT_FOUND, ERROR_CLUSTER_NETINTERFACE_NOT_FOUND);
+ cmp2(STATUS_CLUSTER_INVALID_REQUEST, ERROR_CLUSTER_INVALID_REQUEST);
+ cmp2(STATUS_CLUSTER_INVALID_NETWORK_PROVIDER,ERROR_CLUSTER_INVALID_NETWORK_PROVIDER);
+ cmp2(STATUS_CLUSTER_NODE_DOWN, ERROR_CLUSTER_NODE_DOWN);
+ cmp2(STATUS_CLUSTER_NODE_UNREACHABLE, ERROR_CLUSTER_NODE_UNREACHABLE);
+ cmp2(STATUS_CLUSTER_NODE_NOT_MEMBER, ERROR_CLUSTER_NODE_NOT_MEMBER);
+ cmp2(STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS, ERROR_CLUSTER_JOIN_NOT_IN_PROGRESS);
+ cmp2(STATUS_CLUSTER_INVALID_NETWORK, ERROR_CLUSTER_INVALID_NETWORK);
+ cmp2(STATUS_CLUSTER_NODE_UP, ERROR_CLUSTER_NODE_UP);
+ cmp2(STATUS_CLUSTER_NODE_PAUSED, ERROR_CLUSTER_NODE_PAUSED);
+ cmp2(STATUS_CLUSTER_NODE_NOT_PAUSED, ERROR_CLUSTER_NODE_NOT_PAUSED);
+ cmp2(STATUS_CLUSTER_NO_SECURITY_CONTEXT, ERROR_CLUSTER_NO_SECURITY_CONTEXT);
+ cmp2(STATUS_CLUSTER_NETWORK_NOT_INTERNAL, ERROR_CLUSTER_NETWORK_NOT_INTERNAL);
+}
+
+START_TEST(error)
+{
+ if (prepare_test())
+ run_error_tests();
+}
--- /dev/null
+/* File generated automatically from tools/winapi/test.dat; do not edit! */
+/* This file can be copied, modified and distributed without restriction. */
+
+/*
+ * Unit tests for data structure packing
+ */
+
+#define WINVER 0x0501
+#define _WIN32_IE 0x0501
+#define _WIN32_WINNT 0x0501
+
+#define WINE_NOWINSOCK
+
+#include "ntdll_test.h"
+
+#include "wine/test.h"
+
+/***********************************************************************
+ * Compability macros
+ */
+
+#define DWORD_PTR UINT_PTR
+#define LONG_PTR INT_PTR
+#define ULONG_PTR UINT_PTR
+
+/***********************************************************************
+ * Windows API extension
+ */
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
+# define FIELD_ALIGNMENT(type, field) __alignof(((type*)0)->field)
+#elif defined(__GNUC__)
+# define FIELD_ALIGNMENT(type, field) __alignof__(((type*)0)->field)
+#else
+/* FIXME: Not sure if is possible to do without compiler extension */
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1300) && defined(__cplusplus)
+# define _TYPE_ALIGNMENT(type) __alignof(type)
+#elif defined(__GNUC__)
+# define _TYPE_ALIGNMENT(type) __alignof__(type)
+#else
+/*
+ * FIXME: Not sure if is possible to do without compiler extension
+ * (if type is not just a name that is, if so the normal)
+ * TYPE_ALIGNMENT can be used)
+ */
+#endif
+
+#if defined(TYPE_ALIGNMENT) && defined(_MSC_VER) && _MSC_VER >= 800 && !defined(__cplusplus)
+#pragma warning(disable:4116)
+#endif
+
+#if !defined(TYPE_ALIGNMENT) && defined(_TYPE_ALIGNMENT)
+# define TYPE_ALIGNMENT _TYPE_ALIGNMENT
+#endif
+
+/***********************************************************************
+ * Test helper macros
+ */
+
+#ifdef FIELD_ALIGNMENT
+# define TEST_FIELD_ALIGNMENT(type, field, align) \
+ ok(FIELD_ALIGNMENT(type, field) == align, \
+ "FIELD_ALIGNMENT(" #type ", " #field ") == %d (expected " #align ")\n", \
+ (int)FIELD_ALIGNMENT(type, field))
+#else
+# define TEST_FIELD_ALIGNMENT(type, field, align) do { } while (0)
+#endif
+
+#define TEST_FIELD_OFFSET(type, field, offset) \
+ ok(FIELD_OFFSET(type, field) == offset, \
+ "FIELD_OFFSET(" #type ", " #field ") == %ld (expected " #offset ")\n", \
+ (long int)FIELD_OFFSET(type, field))
+
+#ifdef _TYPE_ALIGNMENT
+#define TEST__TYPE_ALIGNMENT(type, align) \
+ ok(_TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", (int)_TYPE_ALIGNMENT(type))
+#else
+# define TEST__TYPE_ALIGNMENT(type, align) do { } while (0)
+#endif
+
+#ifdef TYPE_ALIGNMENT
+#define TEST_TYPE_ALIGNMENT(type, align) \
+ ok(TYPE_ALIGNMENT(type) == align, "TYPE_ALIGNMENT(" #type ") == %d (expected " #align ")\n", (int)TYPE_ALIGNMENT(type))
+#else
+# define TEST_TYPE_ALIGNMENT(type, align) do { } while (0)
+#endif
+
+#define TEST_TYPE_SIZE(type, size) \
+ ok(sizeof(type) == size, "sizeof(" #type ") == %d (expected " #size ")\n", ((int) sizeof(type)))
+
+/***********************************************************************
+ * Test macros
+ */
+
+#define TEST_FIELD(type, field_type, field_name, field_offset, field_size, field_align) \
+ TEST_TYPE_SIZE(field_type, field_size); \
+ TEST_FIELD_ALIGNMENT(type, field_name, field_align); \
+ TEST_FIELD_OFFSET(type, field_name, field_offset); \
+
+#define TEST_TYPE(type, size, align) \
+ TEST_TYPE_ALIGNMENT(type, align); \
+ TEST_TYPE_SIZE(type, size)
+
+#define TEST_TYPE_POINTER(type, size, align) \
+ TEST__TYPE_ALIGNMENT(*(type)0, align); \
+ TEST_TYPE_SIZE(*(type)0, size)
+
+#define TEST_TYPE_SIGNED(type) \
+ ok((type) -1 < 0, "(" #type ") -1 < 0\n");
+
+#define TEST_TYPE_UNSIGNED(type) \
+ ok((type) -1 > 0, "(" #type ") -1 > 0\n");
+
+static void test_pack_DWORD32(void)
+{
+ /* DWORD32 */
+ TEST_TYPE(DWORD32, 4, 4);
+ TEST_TYPE_UNSIGNED(DWORD32);
+}
+
+static void test_pack_DWORD64(void)
+{
+ /* DWORD64 */
+ TEST_TYPE(DWORD64, 8, 8);
+ TEST_TYPE_UNSIGNED(DWORD64);
+}
+
+static void test_pack_DWORD_PTR(void)
+{
+ /* DWORD_PTR */
+ TEST_TYPE(DWORD_PTR, 4, 4);
+}
+
+static void test_pack_HALF_PTR(void)
+{
+ /* HALF_PTR */
+ TEST_TYPE(HALF_PTR, 2, 2);
+ TEST_TYPE_SIGNED(HALF_PTR);
+}
+
+static void test_pack_INT16(void)
+{
+ /* INT16 */
+ TEST_TYPE(INT16, 2, 2);
+ TEST_TYPE_SIGNED(INT16);
+}
+
+static void test_pack_INT32(void)
+{
+ /* INT32 */
+ TEST_TYPE(INT32, 4, 4);
+ TEST_TYPE_SIGNED(INT32);
+}
+
+static void test_pack_INT64(void)
+{
+ /* INT64 */
+ TEST_TYPE(INT64, 8, 8);
+ TEST_TYPE_SIGNED(INT64);
+}
+
+static void test_pack_INT8(void)
+{
+ /* INT8 */
+ TEST_TYPE(INT8, 1, 1);
+ TEST_TYPE_SIGNED(INT8);
+}
+
+static void test_pack_INT_PTR(void)
+{
+ /* INT_PTR */
+ TEST_TYPE(INT_PTR, 4, 4);
+ TEST_TYPE_SIGNED(INT_PTR);
+}
+
+static void test_pack_LONG32(void)
+{
+ /* LONG32 */
+ TEST_TYPE(LONG32, 4, 4);
+ TEST_TYPE_SIGNED(LONG32);
+}
+
+static void test_pack_LONG64(void)
+{
+ /* LONG64 */
+ TEST_TYPE(LONG64, 8, 8);
+ TEST_TYPE_SIGNED(LONG64);
+}
+
+static void test_pack_LONG_PTR(void)
+{
+ /* LONG_PTR */
+ TEST_TYPE(LONG_PTR, 4, 4);
+ TEST_TYPE_SIGNED(LONG_PTR);
+}
+
+static void test_pack_SIZE_T(void)
+{
+ /* SIZE_T */
+ TEST_TYPE(SIZE_T, 4, 4);
+}
+
+static void test_pack_SSIZE_T(void)
+{
+ /* SSIZE_T */
+ TEST_TYPE(SSIZE_T, 4, 4);
+}
+
+static void test_pack_UHALF_PTR(void)
+{
+ /* UHALF_PTR */
+ TEST_TYPE(UHALF_PTR, 2, 2);
+ TEST_TYPE_UNSIGNED(UHALF_PTR);
+}
+
+static void test_pack_UINT16(void)
+{
+ /* UINT16 */
+ TEST_TYPE(UINT16, 2, 2);
+ TEST_TYPE_UNSIGNED(UINT16);
+}
+
+static void test_pack_UINT32(void)
+{
+ /* UINT32 */
+ TEST_TYPE(UINT32, 4, 4);
+ TEST_TYPE_UNSIGNED(UINT32);
+}
+
+static void test_pack_UINT64(void)
+{
+ /* UINT64 */
+ TEST_TYPE(UINT64, 8, 8);
+ TEST_TYPE_UNSIGNED(UINT64);
+}
+
+static void test_pack_UINT8(void)
+{
+ /* UINT8 */
+ TEST_TYPE(UINT8, 1, 1);
+ TEST_TYPE_UNSIGNED(UINT8);
+}
+
+static void test_pack_UINT_PTR(void)
+{
+ /* UINT_PTR */
+ TEST_TYPE(UINT_PTR, 4, 4);
+ TEST_TYPE_UNSIGNED(UINT_PTR);
+}
+
+static void test_pack_ULONG32(void)
+{
+ /* ULONG32 */
+ TEST_TYPE(ULONG32, 4, 4);
+ TEST_TYPE_UNSIGNED(ULONG32);
+}
+
+static void test_pack_ULONG64(void)
+{
+ /* ULONG64 */
+ TEST_TYPE(ULONG64, 8, 8);
+ TEST_TYPE_UNSIGNED(ULONG64);
+}
+
+static void test_pack_ULONG_PTR(void)
+{
+ /* ULONG_PTR */
+ TEST_TYPE(ULONG_PTR, 4, 4);
+ TEST_TYPE_UNSIGNED(ULONG_PTR);
+}
+
+static void test_pack_ACCESS_ALLOWED_ACE(void)
+{
+ /* ACCESS_ALLOWED_ACE (pack 4) */
+ TEST_TYPE(ACCESS_ALLOWED_ACE, 12, 4);
+ TEST_FIELD(ACCESS_ALLOWED_ACE, ACE_HEADER, Header, 0, 4, 2);
+ TEST_FIELD(ACCESS_ALLOWED_ACE, DWORD, Mask, 4, 4, 4);
+ TEST_FIELD(ACCESS_ALLOWED_ACE, DWORD, SidStart, 8, 4, 4);
+}
+
+static void test_pack_ACCESS_DENIED_ACE(void)
+{
+ /* ACCESS_DENIED_ACE (pack 4) */
+ TEST_TYPE(ACCESS_DENIED_ACE, 12, 4);
+ TEST_FIELD(ACCESS_DENIED_ACE, ACE_HEADER, Header, 0, 4, 2);
+ TEST_FIELD(ACCESS_DENIED_ACE, DWORD, Mask, 4, 4, 4);
+ TEST_FIELD(ACCESS_DENIED_ACE, DWORD, SidStart, 8, 4, 4);
+}
+
+static void test_pack_ACCESS_MASK(void)
+{
+ /* ACCESS_MASK */
+ TEST_TYPE(ACCESS_MASK, 4, 4);
+ TEST_TYPE_UNSIGNED(ACCESS_MASK);
+}
+
+static void test_pack_ACE_HEADER(void)
+{
+ /* ACE_HEADER (pack 4) */
+ TEST_TYPE(ACE_HEADER, 4, 2);
+ TEST_FIELD(ACE_HEADER, BYTE, AceType, 0, 1, 1);
+ TEST_FIELD(ACE_HEADER, BYTE, AceFlags, 1, 1, 1);
+ TEST_FIELD(ACE_HEADER, WORD, AceSize, 2, 2, 2);
+}
+
+static void test_pack_ACL(void)
+{
+ /* ACL (pack 4) */
+ TEST_TYPE(ACL, 8, 2);
+ TEST_FIELD(ACL, BYTE, AclRevision, 0, 1, 1);
+ TEST_FIELD(ACL, BYTE, Sbz1, 1, 1, 1);
+ TEST_FIELD(ACL, WORD, AclSize, 2, 2, 2);
+ TEST_FIELD(ACL, WORD, AceCount, 4, 2, 2);
+ TEST_FIELD(ACL, WORD, Sbz2, 6, 2, 2);
+}
+
+static void test_pack_ACL_REVISION_INFORMATION(void)
+{
+ /* ACL_REVISION_INFORMATION (pack 4) */
+ TEST_TYPE(ACL_REVISION_INFORMATION, 4, 4);
+ TEST_FIELD(ACL_REVISION_INFORMATION, DWORD, AclRevision, 0, 4, 4);
+}
+
+static void test_pack_ACL_SIZE_INFORMATION(void)
+{
+ /* ACL_SIZE_INFORMATION (pack 4) */
+ TEST_TYPE(ACL_SIZE_INFORMATION, 12, 4);
+ TEST_FIELD(ACL_SIZE_INFORMATION, DWORD, AceCount, 0, 4, 4);
+ TEST_FIELD(ACL_SIZE_INFORMATION, DWORD, AclBytesInUse, 4, 4, 4);
+ TEST_FIELD(ACL_SIZE_INFORMATION, DWORD, AclBytesFree, 8, 4, 4);
+}
+
+static void test_pack_BOOLEAN(void)
+{
+ /* BOOLEAN */
+ TEST_TYPE(BOOLEAN, 1, 1);
+ TEST_TYPE_UNSIGNED(BOOLEAN);
+}
+
+static void test_pack_CCHAR(void)
+{
+ /* CCHAR */
+ TEST_TYPE(CCHAR, 1, 1);
+ TEST_TYPE_SIGNED(CCHAR);
+}
+
+static void test_pack_CHAR(void)
+{
+ /* CHAR */
+ TEST_TYPE(CHAR, 1, 1);
+ TEST_TYPE_SIGNED(CHAR);
+}
+
+static void test_pack_DWORDLONG(void)
+{
+ /* DWORDLONG */
+ TEST_TYPE(DWORDLONG, 8, 8);
+ TEST_TYPE_UNSIGNED(DWORDLONG);
+}
+
+static void test_pack_EXCEPTION_POINTERS(void)
+{
+ /* EXCEPTION_POINTERS (pack 4) */
+ TEST_TYPE(EXCEPTION_POINTERS, 8, 4);
+ TEST_FIELD(EXCEPTION_POINTERS, PEXCEPTION_RECORD, ExceptionRecord, 0, 4, 4);
+ TEST_FIELD(EXCEPTION_POINTERS, PCONTEXT, ContextRecord, 4, 4, 4);
+}
+
+static void test_pack_EXCEPTION_RECORD(void)
+{
+ /* EXCEPTION_RECORD (pack 4) */
+ TEST_TYPE(EXCEPTION_RECORD, 80, 4);
+ TEST_FIELD(EXCEPTION_RECORD, DWORD, ExceptionCode, 0, 4, 4);
+ TEST_FIELD(EXCEPTION_RECORD, DWORD, ExceptionFlags, 4, 4, 4);
+ TEST_FIELD(EXCEPTION_RECORD, struct _EXCEPTION_RECORD *, ExceptionRecord, 8, 4, 4);
+ TEST_FIELD(EXCEPTION_RECORD, PVOID, ExceptionAddress, 12, 4, 4);
+ TEST_FIELD(EXCEPTION_RECORD, DWORD, NumberParameters, 16, 4, 4);
+ TEST_FIELD(EXCEPTION_RECORD, ULONG_PTR[EXCEPTION_MAXIMUM_PARAMETERS], ExceptionInformation, 20, 60, 4);
+}
+
+static void test_pack_EXECUTION_STATE(void)
+{
+ /* EXECUTION_STATE */
+ TEST_TYPE(EXECUTION_STATE, 4, 4);
+ TEST_TYPE_UNSIGNED(EXECUTION_STATE);
+}
+
+static void test_pack_FLOATING_SAVE_AREA(void)
+{
+ /* FLOATING_SAVE_AREA (pack 4) */
+ TEST_TYPE(FLOATING_SAVE_AREA, 112, 4);
+ TEST_FIELD(FLOATING_SAVE_AREA, DWORD, ControlWord, 0, 4, 4);
+ TEST_FIELD(FLOATING_SAVE_AREA, DWORD, StatusWord, 4, 4, 4);
+ TEST_FIELD(FLOATING_SAVE_AREA, DWORD, TagWord, 8, 4, 4);
+ TEST_FIELD(FLOATING_SAVE_AREA, DWORD, ErrorOffset, 12, 4, 4);
+ TEST_FIELD(FLOATING_SAVE_AREA, DWORD, ErrorSelector, 16, 4, 4);
+ TEST_FIELD(FLOATING_SAVE_AREA, DWORD, DataOffset, 20, 4, 4);
+ TEST_FIELD(FLOATING_SAVE_AREA, DWORD, DataSelector, 24, 4, 4);
+ TEST_FIELD(FLOATING_SAVE_AREA, BYTE[SIZE_OF_80387_REGISTERS], RegisterArea, 28, 80, 1);
+ TEST_FIELD(FLOATING_SAVE_AREA, DWORD, Cr0NpxState, 108, 4, 4);
+}
+
+static void test_pack_FPO_DATA(void)
+{
+ /* FPO_DATA (pack 4) */
+ TEST_TYPE(FPO_DATA, 16, 4);
+ TEST_FIELD(FPO_DATA, DWORD, ulOffStart, 0, 4, 4);
+ TEST_FIELD(FPO_DATA, DWORD, cbProcSize, 4, 4, 4);
+ TEST_FIELD(FPO_DATA, DWORD, cdwLocals, 8, 4, 4);
+ TEST_FIELD(FPO_DATA, WORD, cdwParams, 12, 2, 2);
+}
+
+static void test_pack_GENERIC_MAPPING(void)
+{
+ /* GENERIC_MAPPING (pack 4) */
+ TEST_TYPE(GENERIC_MAPPING, 16, 4);
+ TEST_FIELD(GENERIC_MAPPING, ACCESS_MASK, GenericRead, 0, 4, 4);
+ TEST_FIELD(GENERIC_MAPPING, ACCESS_MASK, GenericWrite, 4, 4, 4);
+ TEST_FIELD(GENERIC_MAPPING, ACCESS_MASK, GenericExecute, 8, 4, 4);
+ TEST_FIELD(GENERIC_MAPPING, ACCESS_MASK, GenericAll, 12, 4, 4);
+}
+
+static void test_pack_HANDLE(void)
+{
+ /* HANDLE */
+ TEST_TYPE(HANDLE, 4, 4);
+}
+
+static void test_pack_HRESULT(void)
+{
+ /* HRESULT */
+ TEST_TYPE(HRESULT, 4, 4);
+}
+
+static void test_pack_IMAGE_ARCHIVE_MEMBER_HEADER(void)
+{
+ /* IMAGE_ARCHIVE_MEMBER_HEADER (pack 4) */
+ TEST_TYPE(IMAGE_ARCHIVE_MEMBER_HEADER, 60, 1);
+ TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[16], Name, 0, 16, 1);
+ TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[12], Date, 16, 12, 1);
+ TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[6], UserID, 28, 6, 1);
+ TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[6], GroupID, 34, 6, 1);
+ TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[8], Mode, 40, 8, 1);
+ TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[10], Size, 48, 10, 1);
+ TEST_FIELD(IMAGE_ARCHIVE_MEMBER_HEADER, BYTE[2], EndHeader, 58, 2, 1);
+}
+
+static void test_pack_IMAGE_AUX_SYMBOL(void)
+{
+ /* IMAGE_AUX_SYMBOL (pack 2) */
+}
+
+static void test_pack_IMAGE_BASE_RELOCATION(void)
+{
+ /* IMAGE_BASE_RELOCATION (pack 4) */
+ TEST_TYPE(IMAGE_BASE_RELOCATION, 8, 4);
+ TEST_FIELD(IMAGE_BASE_RELOCATION, DWORD, VirtualAddress, 0, 4, 4);
+ TEST_FIELD(IMAGE_BASE_RELOCATION, DWORD, SizeOfBlock, 4, 4, 4);
+}
+
+static void test_pack_IMAGE_BOUND_FORWARDER_REF(void)
+{
+ /* IMAGE_BOUND_FORWARDER_REF (pack 4) */
+ TEST_TYPE(IMAGE_BOUND_FORWARDER_REF, 8, 4);
+ TEST_FIELD(IMAGE_BOUND_FORWARDER_REF, DWORD, TimeDateStamp, 0, 4, 4);
+ TEST_FIELD(IMAGE_BOUND_FORWARDER_REF, WORD, OffsetModuleName, 4, 2, 2);
+ TEST_FIELD(IMAGE_BOUND_FORWARDER_REF, WORD, Reserved, 6, 2, 2);
+}
+
+static void test_pack_IMAGE_BOUND_IMPORT_DESCRIPTOR(void)
+{
+ /* IMAGE_BOUND_IMPORT_DESCRIPTOR (pack 4) */
+ TEST_TYPE(IMAGE_BOUND_IMPORT_DESCRIPTOR, 8, 4);
+ TEST_FIELD(IMAGE_BOUND_IMPORT_DESCRIPTOR, DWORD, TimeDateStamp, 0, 4, 4);
+ TEST_FIELD(IMAGE_BOUND_IMPORT_DESCRIPTOR, WORD, OffsetModuleName, 4, 2, 2);
+ TEST_FIELD(IMAGE_BOUND_IMPORT_DESCRIPTOR, WORD, NumberOfModuleForwarderRefs, 6, 2, 2);
+}
+
+static void test_pack_IMAGE_COFF_SYMBOLS_HEADER(void)
+{
+ /* IMAGE_COFF_SYMBOLS_HEADER (pack 4) */
+ TEST_TYPE(IMAGE_COFF_SYMBOLS_HEADER, 32, 4);
+ TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, NumberOfSymbols, 0, 4, 4);
+ TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, LvaToFirstSymbol, 4, 4, 4);
+ TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, NumberOfLinenumbers, 8, 4, 4);
+ TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, LvaToFirstLinenumber, 12, 4, 4);
+ TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, RvaToFirstByteOfCode, 16, 4, 4);
+ TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, RvaToLastByteOfCode, 20, 4, 4);
+ TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, RvaToFirstByteOfData, 24, 4, 4);
+ TEST_FIELD(IMAGE_COFF_SYMBOLS_HEADER, DWORD, RvaToLastByteOfData, 28, 4, 4);
+}
+
+static void test_pack_IMAGE_DATA_DIRECTORY(void)
+{
+ /* IMAGE_DATA_DIRECTORY (pack 4) */
+ TEST_TYPE(IMAGE_DATA_DIRECTORY, 8, 4);
+ TEST_FIELD(IMAGE_DATA_DIRECTORY, DWORD, VirtualAddress, 0, 4, 4);
+ TEST_FIELD(IMAGE_DATA_DIRECTORY, DWORD, Size, 4, 4, 4);
+}
+
+static void test_pack_IMAGE_DEBUG_DIRECTORY(void)
+{
+ /* IMAGE_DEBUG_DIRECTORY (pack 4) */
+ TEST_TYPE(IMAGE_DEBUG_DIRECTORY, 28, 4);
+ TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, Characteristics, 0, 4, 4);
+ TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, TimeDateStamp, 4, 4, 4);
+ TEST_FIELD(IMAGE_DEBUG_DIRECTORY, WORD, MajorVersion, 8, 2, 2);
+ TEST_FIELD(IMAGE_DEBUG_DIRECTORY, WORD, MinorVersion, 10, 2, 2);
+ TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, Type, 12, 4, 4);
+ TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, SizeOfData, 16, 4, 4);
+ TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, AddressOfRawData, 20, 4, 4);
+ TEST_FIELD(IMAGE_DEBUG_DIRECTORY, DWORD, PointerToRawData, 24, 4, 4);
+}
+
+static void test_pack_IMAGE_DEBUG_MISC(void)
+{
+ /* IMAGE_DEBUG_MISC (pack 4) */
+ TEST_TYPE(IMAGE_DEBUG_MISC, 16, 4);
+ TEST_FIELD(IMAGE_DEBUG_MISC, DWORD, DataType, 0, 4, 4);
+ TEST_FIELD(IMAGE_DEBUG_MISC, DWORD, Length, 4, 4, 4);
+ TEST_FIELD(IMAGE_DEBUG_MISC, BYTE, Unicode, 8, 1, 1);
+ TEST_FIELD(IMAGE_DEBUG_MISC, BYTE[ 3 ], Reserved, 9, 3, 1);
+ TEST_FIELD(IMAGE_DEBUG_MISC, BYTE[ 1 ], Data, 12, 1, 1);
+}
+
+static void test_pack_IMAGE_DOS_HEADER(void)
+{
+ /* IMAGE_DOS_HEADER (pack 2) */
+ TEST_TYPE(IMAGE_DOS_HEADER, 64, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_magic, 0, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_cblp, 2, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_cp, 4, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_crlc, 6, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_cparhdr, 8, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_minalloc, 10, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_maxalloc, 12, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_ss, 14, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_sp, 16, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_csum, 18, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_ip, 20, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_cs, 22, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_lfarlc, 24, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_ovno, 26, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD[4], e_res, 28, 8, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_oemid, 36, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD, e_oeminfo, 38, 2, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, WORD[10], e_res2, 40, 20, 2);
+ TEST_FIELD(IMAGE_DOS_HEADER, DWORD, e_lfanew, 60, 4, 2);
+}
+
+static void test_pack_IMAGE_EXPORT_DIRECTORY(void)
+{
+ /* IMAGE_EXPORT_DIRECTORY (pack 4) */
+ TEST_TYPE(IMAGE_EXPORT_DIRECTORY, 40, 4);
+ TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, Characteristics, 0, 4, 4);
+ TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, TimeDateStamp, 4, 4, 4);
+ TEST_FIELD(IMAGE_EXPORT_DIRECTORY, WORD, MajorVersion, 8, 2, 2);
+ TEST_FIELD(IMAGE_EXPORT_DIRECTORY, WORD, MinorVersion, 10, 2, 2);
+ TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, Name, 12, 4, 4);
+ TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, Base, 16, 4, 4);
+ TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, NumberOfFunctions, 20, 4, 4);
+ TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, NumberOfNames, 24, 4, 4);
+ TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, AddressOfFunctions, 28, 4, 4);
+ TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, AddressOfNames, 32, 4, 4);
+ TEST_FIELD(IMAGE_EXPORT_DIRECTORY, DWORD, AddressOfNameOrdinals, 36, 4, 4);
+}
+
+static void test_pack_IMAGE_FILE_HEADER(void)
+{
+ /* IMAGE_FILE_HEADER (pack 4) */
+ TEST_TYPE(IMAGE_FILE_HEADER, 20, 4);
+ TEST_FIELD(IMAGE_FILE_HEADER, WORD, Machine, 0, 2, 2);
+ TEST_FIELD(IMAGE_FILE_HEADER, WORD, NumberOfSections, 2, 2, 2);
+ TEST_FIELD(IMAGE_FILE_HEADER, DWORD, TimeDateStamp, 4, 4, 4);
+ TEST_FIELD(IMAGE_FILE_HEADER, DWORD, PointerToSymbolTable, 8, 4, 4);
+ TEST_FIELD(IMAGE_FILE_HEADER, DWORD, NumberOfSymbols, 12, 4, 4);
+ TEST_FIELD(IMAGE_FILE_HEADER, WORD, SizeOfOptionalHeader, 16, 2, 2);
+ TEST_FIELD(IMAGE_FILE_HEADER, WORD, Characteristics, 18, 2, 2);
+}
+
+static void test_pack_IMAGE_FUNCTION_ENTRY(void)
+{
+ /* IMAGE_FUNCTION_ENTRY (pack 4) */
+ TEST_TYPE(IMAGE_FUNCTION_ENTRY, 12, 4);
+ TEST_FIELD(IMAGE_FUNCTION_ENTRY, DWORD, StartingAddress, 0, 4, 4);
+ TEST_FIELD(IMAGE_FUNCTION_ENTRY, DWORD, EndingAddress, 4, 4, 4);
+ TEST_FIELD(IMAGE_FUNCTION_ENTRY, DWORD, EndOfPrologue, 8, 4, 4);
+}
+
+static void test_pack_IMAGE_IMPORT_BY_NAME(void)
+{
+ /* IMAGE_IMPORT_BY_NAME (pack 4) */
+ TEST_TYPE(IMAGE_IMPORT_BY_NAME, 4, 2);
+ TEST_FIELD(IMAGE_IMPORT_BY_NAME, WORD, Hint, 0, 2, 2);
+ TEST_FIELD(IMAGE_IMPORT_BY_NAME, BYTE[1], Name, 2, 1, 1);
+}
+
+static void test_pack_IMAGE_IMPORT_DESCRIPTOR(void)
+{
+ /* IMAGE_IMPORT_DESCRIPTOR (pack 4) */
+}
+
+static void test_pack_IMAGE_LINENUMBER(void)
+{
+ /* IMAGE_LINENUMBER (pack 2) */
+}
+
+static void test_pack_IMAGE_LOAD_CONFIG_DIRECTORY(void)
+{
+ /* IMAGE_LOAD_CONFIG_DIRECTORY (pack 4) */
+ TEST_TYPE(IMAGE_LOAD_CONFIG_DIRECTORY, 72, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, Size, 0, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, TimeDateStamp, 4, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, WORD, MajorVersion, 8, 2, 2);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, WORD, MinorVersion, 10, 2, 2);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, GlobalFlagsClear, 12, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, GlobalFlagsSet, 16, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, CriticalSectionDefaultTimeout, 20, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, DeCommitFreeBlockThreshold, 24, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, DeCommitTotalFreeThreshold, 28, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, PVOID, LockPrefixTable, 32, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, MaximumAllocationSize, 36, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, VirtualMemoryThreshold, 40, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, ProcessHeapFlags, 44, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, ProcessAffinityMask, 48, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, WORD, CSDVersion, 52, 2, 2);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, WORD, Reserved1, 54, 2, 2);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, PVOID, EditList, 56, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, SecurityCookie, 60, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, SEHandlerTable, 64, 4, 4);
+ TEST_FIELD(IMAGE_LOAD_CONFIG_DIRECTORY, DWORD, SEHandlerCount, 68, 4, 4);
+}
+
+static void test_pack_IMAGE_NT_HEADERS(void)
+{
+ /* IMAGE_NT_HEADERS (pack 4) */
+ TEST_TYPE(IMAGE_NT_HEADERS, 248, 4);
+ TEST_FIELD(IMAGE_NT_HEADERS, DWORD, Signature, 0, 4, 4);
+ TEST_FIELD(IMAGE_NT_HEADERS, IMAGE_FILE_HEADER, FileHeader, 4, 20, 4);
+ TEST_FIELD(IMAGE_NT_HEADERS, IMAGE_OPTIONAL_HEADER, OptionalHeader, 24, 224, 4);
+}
+
+static void test_pack_IMAGE_OPTIONAL_HEADER(void)
+{
+ /* IMAGE_OPTIONAL_HEADER (pack 4) */
+ TEST_TYPE(IMAGE_OPTIONAL_HEADER, 224, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, Magic, 0, 2, 2);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, BYTE, MajorLinkerVersion, 2, 1, 1);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, BYTE, MinorLinkerVersion, 3, 1, 1);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfCode, 4, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfInitializedData, 8, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfUninitializedData, 12, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, AddressOfEntryPoint, 16, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, BaseOfCode, 20, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, BaseOfData, 24, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, ImageBase, 28, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SectionAlignment, 32, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, FileAlignment, 36, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MajorOperatingSystemVersion, 40, 2, 2);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MinorOperatingSystemVersion, 42, 2, 2);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MajorImageVersion, 44, 2, 2);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MinorImageVersion, 46, 2, 2);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MajorSubsystemVersion, 48, 2, 2);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, MinorSubsystemVersion, 50, 2, 2);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, Win32VersionValue, 52, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfImage, 56, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfHeaders, 60, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, CheckSum, 64, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, Subsystem, 68, 2, 2);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, WORD, DllCharacteristics, 70, 2, 2);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfStackReserve, 72, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfStackCommit, 76, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfHeapReserve, 80, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, SizeOfHeapCommit, 84, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, LoaderFlags, 88, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, DWORD, NumberOfRvaAndSizes, 92, 4, 4);
+ TEST_FIELD(IMAGE_OPTIONAL_HEADER, IMAGE_DATA_DIRECTORY[IMAGE_NUMBEROF_DIRECTORY_ENTRIES], DataDirectory, 96, 128, 4);
+}
+
+static void test_pack_IMAGE_OS2_HEADER(void)
+{
+ /* IMAGE_OS2_HEADER (pack 2) */
+ TEST_TYPE(IMAGE_OS2_HEADER, 64, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_magic, 0, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, BYTE, ne_ver, 2, 1, 1);
+ TEST_FIELD(IMAGE_OS2_HEADER, BYTE, ne_rev, 3, 1, 1);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_enttab, 4, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cbenttab, 6, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, LONG, ne_crc, 8, 4, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_flags, 12, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_autodata, 14, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_heap, 16, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_stack, 18, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, DWORD, ne_csip, 20, 4, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, DWORD, ne_sssp, 24, 4, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cseg, 28, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cmod, 30, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cbnrestab, 32, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_segtab, 34, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_rsrctab, 36, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_restab, 38, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_modtab, 40, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_imptab, 42, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, DWORD, ne_nrestab, 44, 4, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cmovent, 48, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_align, 50, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_cres, 52, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, BYTE, ne_exetyp, 54, 1, 1);
+ TEST_FIELD(IMAGE_OS2_HEADER, BYTE, ne_flagsothers, 55, 1, 1);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_pretthunks, 56, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_psegrefbytes, 58, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_swaparea, 60, 2, 2);
+ TEST_FIELD(IMAGE_OS2_HEADER, WORD, ne_expver, 62, 2, 2);
+}
+
+static void test_pack_IMAGE_RELOCATION(void)
+{
+ /* IMAGE_RELOCATION (pack 2) */
+}
+
+static void test_pack_IMAGE_RESOURCE_DATA_ENTRY(void)
+{
+ /* IMAGE_RESOURCE_DATA_ENTRY (pack 4) */
+ TEST_TYPE(IMAGE_RESOURCE_DATA_ENTRY, 16, 4);
+ TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, DWORD, OffsetToData, 0, 4, 4);
+ TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, DWORD, Size, 4, 4, 4);
+ TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, DWORD, CodePage, 8, 4, 4);
+ TEST_FIELD(IMAGE_RESOURCE_DATA_ENTRY, DWORD, Reserved, 12, 4, 4);
+}
+
+static void test_pack_IMAGE_RESOURCE_DIRECTORY(void)
+{
+ /* IMAGE_RESOURCE_DIRECTORY (pack 4) */
+ TEST_TYPE(IMAGE_RESOURCE_DIRECTORY, 16, 4);
+ TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, DWORD, Characteristics, 0, 4, 4);
+ TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, DWORD, TimeDateStamp, 4, 4, 4);
+ TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, WORD, MajorVersion, 8, 2, 2);
+ TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, WORD, MinorVersion, 10, 2, 2);
+ TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, WORD, NumberOfNamedEntries, 12, 2, 2);
+ TEST_FIELD(IMAGE_RESOURCE_DIRECTORY, WORD, NumberOfIdEntries, 14, 2, 2);
+}
+
+static void test_pack_IMAGE_RESOURCE_DIRECTORY_ENTRY(void)
+{
+ /* IMAGE_RESOURCE_DIRECTORY_ENTRY (pack 4) */
+}
+
+static void test_pack_IMAGE_RESOURCE_DIRECTORY_STRING(void)
+{
+ /* IMAGE_RESOURCE_DIRECTORY_STRING (pack 4) */
+ TEST_TYPE(IMAGE_RESOURCE_DIRECTORY_STRING, 4, 2);
+ TEST_FIELD(IMAGE_RESOURCE_DIRECTORY_STRING, WORD, Length, 0, 2, 2);
+ TEST_FIELD(IMAGE_RESOURCE_DIRECTORY_STRING, CHAR[ 1 ], NameString, 2, 1, 1);
+}
+
+static void test_pack_IMAGE_RESOURCE_DIR_STRING_U(void)
+{
+ /* IMAGE_RESOURCE_DIR_STRING_U (pack 4) */
+ TEST_TYPE(IMAGE_RESOURCE_DIR_STRING_U, 4, 2);
+ TEST_FIELD(IMAGE_RESOURCE_DIR_STRING_U, WORD, Length, 0, 2, 2);
+ TEST_FIELD(IMAGE_RESOURCE_DIR_STRING_U, WCHAR[ 1 ], NameString, 2, 2, 2);
+}
+
+static void test_pack_IMAGE_SECTION_HEADER(void)
+{
+ /* IMAGE_SECTION_HEADER (pack 4) */
+ TEST_FIELD(IMAGE_SECTION_HEADER, BYTE[IMAGE_SIZEOF_SHORT_NAME], Name, 0, 8, 1);
+}
+
+static void test_pack_IMAGE_SEPARATE_DEBUG_HEADER(void)
+{
+ /* IMAGE_SEPARATE_DEBUG_HEADER (pack 4) */
+ TEST_TYPE(IMAGE_SEPARATE_DEBUG_HEADER, 48, 4);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, WORD, Signature, 0, 2, 2);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, WORD, Flags, 2, 2, 2);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, WORD, Machine, 4, 2, 2);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, WORD, Characteristics, 6, 2, 2);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, TimeDateStamp, 8, 4, 4);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, CheckSum, 12, 4, 4);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, ImageBase, 16, 4, 4);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, SizeOfImage, 20, 4, 4);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, NumberOfSections, 24, 4, 4);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, ExportedNamesSize, 28, 4, 4);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, DebugDirectorySize, 32, 4, 4);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD, SectionAlignment, 36, 4, 4);
+ TEST_FIELD(IMAGE_SEPARATE_DEBUG_HEADER, DWORD[ 2 ], Reserved, 40, 8, 4);
+}
+
+static void test_pack_IMAGE_SYMBOL(void)
+{
+ /* IMAGE_SYMBOL (pack 2) */
+}
+
+static void test_pack_IMAGE_THUNK_DATA(void)
+{
+ /* IMAGE_THUNK_DATA (pack 4) */
+}
+
+static void test_pack_IMAGE_TLS_DIRECTORY(void)
+{
+ /* IMAGE_TLS_DIRECTORY (pack 4) */
+ TEST_TYPE(IMAGE_TLS_DIRECTORY, 24, 4);
+ TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, StartAddressOfRawData, 0, 4, 4);
+ TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, EndAddressOfRawData, 4, 4, 4);
+ TEST_FIELD(IMAGE_TLS_DIRECTORY, LPDWORD, AddressOfIndex, 8, 4, 4);
+ TEST_FIELD(IMAGE_TLS_DIRECTORY, PIMAGE_TLS_CALLBACK *, AddressOfCallBacks, 12, 4, 4);
+ TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, SizeOfZeroFill, 16, 4, 4);
+ TEST_FIELD(IMAGE_TLS_DIRECTORY, DWORD, Characteristics, 20, 4, 4);
+}
+
+static void test_pack_IMAGE_VXD_HEADER(void)
+{
+ /* IMAGE_VXD_HEADER (pack 2) */
+ TEST_TYPE(IMAGE_VXD_HEADER, 196, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_magic, 0, 2, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, BYTE, e32_border, 2, 1, 1);
+ TEST_FIELD(IMAGE_VXD_HEADER, BYTE, e32_worder, 3, 1, 1);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_level, 4, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_cpu, 8, 2, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_os, 10, 2, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_ver, 12, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_mflags, 16, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_mpages, 20, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_startobj, 24, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_eip, 28, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_stackobj, 32, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_esp, 36, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_pagesize, 40, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_lastpagesize, 44, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_fixupsize, 48, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_fixupsum, 52, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_ldrsize, 56, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_ldrsum, 60, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_objtab, 64, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_objcnt, 68, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_objmap, 72, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_itermap, 76, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_rsrctab, 80, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_rsrccnt, 84, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_restab, 88, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_enttab, 92, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_dirtab, 96, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_dircnt, 100, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_fpagetab, 104, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_frectab, 108, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_impmod, 112, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_impmodcnt, 116, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_impproc, 120, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_pagesum, 124, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_datapage, 128, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_preload, 132, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_nrestab, 136, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_cbnrestab, 140, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_nressum, 144, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_autodata, 148, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_debuginfo, 152, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_debuglen, 156, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_instpreload, 160, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_instdemand, 164, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_heapsize, 168, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, BYTE[12], e32_res3, 172, 12, 1);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_winresoff, 184, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, DWORD, e32_winreslen, 188, 4, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_devid, 192, 2, 2);
+ TEST_FIELD(IMAGE_VXD_HEADER, WORD, e32_ddkver, 194, 2, 2);
+}
+
+static void test_pack_IO_COUNTERS(void)
+{
+ /* IO_COUNTERS (pack 8) */
+ TEST_TYPE(IO_COUNTERS, 48, 8);
+ TEST_FIELD(IO_COUNTERS, ULONGLONG, ReadOperationCount, 0, 8, 8);
+ TEST_FIELD(IO_COUNTERS, ULONGLONG, WriteOperationCount, 8, 8, 8);
+ TEST_FIELD(IO_COUNTERS, ULONGLONG, OtherOperationCount, 16, 8, 8);
+ TEST_FIELD(IO_COUNTERS, ULONGLONG, ReadTransferCount, 24, 8, 8);
+ TEST_FIELD(IO_COUNTERS, ULONGLONG, WriteTransferCount, 32, 8, 8);
+ TEST_FIELD(IO_COUNTERS, ULONGLONG, OtherTransferCount, 40, 8, 8);
+}
+
+static void test_pack_LANGID(void)
+{
+ /* LANGID */
+ TEST_TYPE(LANGID, 2, 2);
+ TEST_TYPE_UNSIGNED(LANGID);
+}
+
+static void test_pack_LARGE_INTEGER(void)
+{
+ /* LARGE_INTEGER (pack 4) */
+}
+
+static void test_pack_LCID(void)
+{
+ /* LCID */
+ TEST_TYPE(LCID, 4, 4);
+ TEST_TYPE_UNSIGNED(LCID);
+}
+
+static void test_pack_LIST_ENTRY(void)
+{
+ /* LIST_ENTRY (pack 4) */
+ TEST_TYPE(LIST_ENTRY, 8, 4);
+ TEST_FIELD(LIST_ENTRY, struct _LIST_ENTRY *, Flink, 0, 4, 4);
+ TEST_FIELD(LIST_ENTRY, struct _LIST_ENTRY *, Blink, 4, 4, 4);
+}
+
+static void test_pack_LONG(void)
+{
+ /* LONG */
+ TEST_TYPE(LONG, 4, 4);
+ TEST_TYPE_SIGNED(LONG);
+}
+
+static void test_pack_LONGLONG(void)
+{
+ /* LONGLONG */
+ TEST_TYPE(LONGLONG, 8, 8);
+ TEST_TYPE_SIGNED(LONGLONG);
+}
+
+static void test_pack_LPTOP_LEVEL_EXCEPTION_FILTER(void)
+{
+ /* LPTOP_LEVEL_EXCEPTION_FILTER */
+ TEST_TYPE(LPTOP_LEVEL_EXCEPTION_FILTER, 4, 4);
+}
+
+static void test_pack_LUID(void)
+{
+ /* LUID (pack 4) */
+ TEST_TYPE(LUID, 8, 4);
+ TEST_FIELD(LUID, DWORD, LowPart, 0, 4, 4);
+ TEST_FIELD(LUID, LONG, HighPart, 4, 4, 4);
+}
+
+static void test_pack_LUID_AND_ATTRIBUTES(void)
+{
+ /* LUID_AND_ATTRIBUTES (pack 4) */
+ TEST_TYPE(LUID_AND_ATTRIBUTES, 12, 4);
+ TEST_FIELD(LUID_AND_ATTRIBUTES, LUID, Luid, 0, 8, 4);
+ TEST_FIELD(LUID_AND_ATTRIBUTES, DWORD, Attributes, 8, 4, 4);
+}
+
+static void test_pack_MEMORY_BASIC_INFORMATION(void)
+{
+ /* MEMORY_BASIC_INFORMATION (pack 4) */
+ TEST_TYPE(MEMORY_BASIC_INFORMATION, 28, 4);
+ TEST_FIELD(MEMORY_BASIC_INFORMATION, LPVOID, BaseAddress, 0, 4, 4);
+ TEST_FIELD(MEMORY_BASIC_INFORMATION, LPVOID, AllocationBase, 4, 4, 4);
+ TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, AllocationProtect, 8, 4, 4);
+ TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, RegionSize, 12, 4, 4);
+ TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, State, 16, 4, 4);
+ TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, Protect, 20, 4, 4);
+ TEST_FIELD(MEMORY_BASIC_INFORMATION, DWORD, Type, 24, 4, 4);
+}
+
+static void test_pack_MESSAGE_RESOURCE_BLOCK(void)
+{
+ /* MESSAGE_RESOURCE_BLOCK (pack 4) */
+ TEST_TYPE(MESSAGE_RESOURCE_BLOCK, 12, 4);
+ TEST_FIELD(MESSAGE_RESOURCE_BLOCK, DWORD, LowId, 0, 4, 4);
+ TEST_FIELD(MESSAGE_RESOURCE_BLOCK, DWORD, HighId, 4, 4, 4);
+ TEST_FIELD(MESSAGE_RESOURCE_BLOCK, DWORD, OffsetToEntries, 8, 4, 4);
+}
+
+static void test_pack_MESSAGE_RESOURCE_DATA(void)
+{
+ /* MESSAGE_RESOURCE_DATA (pack 4) */
+ TEST_TYPE(MESSAGE_RESOURCE_DATA, 16, 4);
+ TEST_FIELD(MESSAGE_RESOURCE_DATA, DWORD, NumberOfBlocks, 0, 4, 4);
+ TEST_FIELD(MESSAGE_RESOURCE_DATA, MESSAGE_RESOURCE_BLOCK[ 1 ], Blocks, 4, 12, 4);
+}
+
+static void test_pack_MESSAGE_RESOURCE_ENTRY(void)
+{
+ /* MESSAGE_RESOURCE_ENTRY (pack 4) */
+ TEST_TYPE(MESSAGE_RESOURCE_ENTRY, 6, 2);
+ TEST_FIELD(MESSAGE_RESOURCE_ENTRY, WORD, Length, 0, 2, 2);
+ TEST_FIELD(MESSAGE_RESOURCE_ENTRY, WORD, Flags, 2, 2, 2);
+ TEST_FIELD(MESSAGE_RESOURCE_ENTRY, BYTE[1], Text, 4, 1, 1);
+}
+
+static void test_pack_NT_TIB(void)
+{
+ /* NT_TIB (pack 4) */
+ TEST_FIELD(NT_TIB, struct _EXCEPTION_REGISTRATION_RECORD *, ExceptionList, 0, 4, 4);
+ TEST_FIELD(NT_TIB, PVOID, StackBase, 4, 4, 4);
+ TEST_FIELD(NT_TIB, PVOID, StackLimit, 8, 4, 4);
+ TEST_FIELD(NT_TIB, PVOID, SubSystemTib, 12, 4, 4);
+}
+
+static void test_pack_OBJECT_TYPE_LIST(void)
+{
+ /* OBJECT_TYPE_LIST (pack 4) */
+ TEST_TYPE(OBJECT_TYPE_LIST, 8, 4);
+ TEST_FIELD(OBJECT_TYPE_LIST, WORD, Level, 0, 2, 2);
+ TEST_FIELD(OBJECT_TYPE_LIST, WORD, Sbz, 2, 2, 2);
+ TEST_FIELD(OBJECT_TYPE_LIST, GUID *, ObjectType, 4, 4, 4);
+}
+
+static void test_pack_PACCESS_ALLOWED_ACE(void)
+{
+ /* PACCESS_ALLOWED_ACE */
+ TEST_TYPE(PACCESS_ALLOWED_ACE, 4, 4);
+ TEST_TYPE_POINTER(PACCESS_ALLOWED_ACE, 12, 4);
+}
+
+static void test_pack_PACCESS_DENIED_ACE(void)
+{
+ /* PACCESS_DENIED_ACE */
+ TEST_TYPE(PACCESS_DENIED_ACE, 4, 4);
+ TEST_TYPE_POINTER(PACCESS_DENIED_ACE, 12, 4);
+}
+
+static void test_pack_PACCESS_TOKEN(void)
+{
+ /* PACCESS_TOKEN */
+ TEST_TYPE(PACCESS_TOKEN, 4, 4);
+}
+
+static void test_pack_PACE_HEADER(void)
+{
+ /* PACE_HEADER */
+ TEST_TYPE(PACE_HEADER, 4, 4);
+ TEST_TYPE_POINTER(PACE_HEADER, 4, 2);
+}
+
+static void test_pack_PACL(void)
+{
+ /* PACL */
+ TEST_TYPE(PACL, 4, 4);
+ TEST_TYPE_POINTER(PACL, 8, 2);
+}
+
+static void test_pack_PACL_REVISION_INFORMATION(void)
+{
+ /* PACL_REVISION_INFORMATION */
+ TEST_TYPE(PACL_REVISION_INFORMATION, 4, 4);
+ TEST_TYPE_POINTER(PACL_REVISION_INFORMATION, 4, 4);
+}
+
+static void test_pack_PACL_SIZE_INFORMATION(void)
+{
+ /* PACL_SIZE_INFORMATION */
+ TEST_TYPE(PACL_SIZE_INFORMATION, 4, 4);
+ TEST_TYPE_POINTER(PACL_SIZE_INFORMATION, 12, 4);
+}
+
+static void test_pack_PCCH(void)
+{
+ /* PCCH */
+ TEST_TYPE(PCCH, 4, 4);
+ TEST_TYPE_POINTER(PCCH, 1, 1);
+}
+
+static void test_pack_PCH(void)
+{
+ /* PCH */
+ TEST_TYPE(PCH, 4, 4);
+ TEST_TYPE_POINTER(PCH, 1, 1);
+}
+
+static void test_pack_PCSTR(void)
+{
+ /* PCSTR */
+ TEST_TYPE(PCSTR, 4, 4);
+ TEST_TYPE_POINTER(PCSTR, 1, 1);
+}
+
+static void test_pack_PCTSTR(void)
+{
+ /* PCTSTR */
+ TEST_TYPE(PCTSTR, 4, 4);
+}
+
+static void test_pack_PCWCH(void)
+{
+ /* PCWCH */
+ TEST_TYPE(PCWCH, 4, 4);
+ TEST_TYPE_POINTER(PCWCH, 2, 2);
+}
+
+static void test_pack_PCWSTR(void)
+{
+ /* PCWSTR */
+ TEST_TYPE(PCWSTR, 4, 4);
+ TEST_TYPE_POINTER(PCWSTR, 2, 2);
+}
+
+static void test_pack_PEXCEPTION_POINTERS(void)
+{
+ /* PEXCEPTION_POINTERS */
+ TEST_TYPE(PEXCEPTION_POINTERS, 4, 4);
+ TEST_TYPE_POINTER(PEXCEPTION_POINTERS, 8, 4);
+}
+
+static void test_pack_PEXCEPTION_RECORD(void)
+{
+ /* PEXCEPTION_RECORD */
+ TEST_TYPE(PEXCEPTION_RECORD, 4, 4);
+ TEST_TYPE_POINTER(PEXCEPTION_RECORD, 80, 4);
+}
+
+static void test_pack_PFLOATING_SAVE_AREA(void)
+{
+ /* PFLOATING_SAVE_AREA */
+ TEST_TYPE(PFLOATING_SAVE_AREA, 4, 4);
+ TEST_TYPE_POINTER(PFLOATING_SAVE_AREA, 112, 4);
+}
+
+static void test_pack_PFPO_DATA(void)
+{
+ /* PFPO_DATA */
+ TEST_TYPE(PFPO_DATA, 4, 4);
+ TEST_TYPE_POINTER(PFPO_DATA, 16, 4);
+}
+
+static void test_pack_PGENERIC_MAPPING(void)
+{
+ /* PGENERIC_MAPPING */
+ TEST_TYPE(PGENERIC_MAPPING, 4, 4);
+ TEST_TYPE_POINTER(PGENERIC_MAPPING, 16, 4);
+}
+
+static void test_pack_PHANDLE(void)
+{
+ /* PHANDLE */
+ TEST_TYPE(PHANDLE, 4, 4);
+ TEST_TYPE_POINTER(PHANDLE, 4, 4);
+}
+
+static void test_pack_PIMAGE_ARCHIVE_MEMBER_HEADER(void)
+{
+ /* PIMAGE_ARCHIVE_MEMBER_HEADER */
+ TEST_TYPE(PIMAGE_ARCHIVE_MEMBER_HEADER, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_ARCHIVE_MEMBER_HEADER, 60, 1);
+}
+
+static void test_pack_PIMAGE_AUX_SYMBOL(void)
+{
+ /* PIMAGE_AUX_SYMBOL */
+ TEST_TYPE(PIMAGE_AUX_SYMBOL, 4, 4);
+}
+
+static void test_pack_PIMAGE_BASE_RELOCATION(void)
+{
+ /* PIMAGE_BASE_RELOCATION */
+ TEST_TYPE(PIMAGE_BASE_RELOCATION, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_BASE_RELOCATION, 8, 4);
+}
+
+static void test_pack_PIMAGE_BOUND_FORWARDER_REF(void)
+{
+ /* PIMAGE_BOUND_FORWARDER_REF */
+ TEST_TYPE(PIMAGE_BOUND_FORWARDER_REF, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_BOUND_FORWARDER_REF, 8, 4);
+}
+
+static void test_pack_PIMAGE_BOUND_IMPORT_DESCRIPTOR(void)
+{
+ /* PIMAGE_BOUND_IMPORT_DESCRIPTOR */
+ TEST_TYPE(PIMAGE_BOUND_IMPORT_DESCRIPTOR, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_BOUND_IMPORT_DESCRIPTOR, 8, 4);
+}
+
+static void test_pack_PIMAGE_COFF_SYMBOLS_HEADER(void)
+{
+ /* PIMAGE_COFF_SYMBOLS_HEADER */
+ TEST_TYPE(PIMAGE_COFF_SYMBOLS_HEADER, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_COFF_SYMBOLS_HEADER, 32, 4);
+}
+
+static void test_pack_PIMAGE_DATA_DIRECTORY(void)
+{
+ /* PIMAGE_DATA_DIRECTORY */
+ TEST_TYPE(PIMAGE_DATA_DIRECTORY, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_DATA_DIRECTORY, 8, 4);
+}
+
+static void test_pack_PIMAGE_DEBUG_DIRECTORY(void)
+{
+ /* PIMAGE_DEBUG_DIRECTORY */
+ TEST_TYPE(PIMAGE_DEBUG_DIRECTORY, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_DEBUG_DIRECTORY, 28, 4);
+}
+
+static void test_pack_PIMAGE_DEBUG_MISC(void)
+{
+ /* PIMAGE_DEBUG_MISC */
+ TEST_TYPE(PIMAGE_DEBUG_MISC, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_DEBUG_MISC, 16, 4);
+}
+
+static void test_pack_PIMAGE_DOS_HEADER(void)
+{
+ /* PIMAGE_DOS_HEADER */
+ TEST_TYPE(PIMAGE_DOS_HEADER, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_DOS_HEADER, 64, 2);
+}
+
+static void test_pack_PIMAGE_EXPORT_DIRECTORY(void)
+{
+ /* PIMAGE_EXPORT_DIRECTORY */
+ TEST_TYPE(PIMAGE_EXPORT_DIRECTORY, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_EXPORT_DIRECTORY, 40, 4);
+}
+
+static void test_pack_PIMAGE_FILE_HEADER(void)
+{
+ /* PIMAGE_FILE_HEADER */
+ TEST_TYPE(PIMAGE_FILE_HEADER, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_FILE_HEADER, 20, 4);
+}
+
+static void test_pack_PIMAGE_FUNCTION_ENTRY(void)
+{
+ /* PIMAGE_FUNCTION_ENTRY */
+ TEST_TYPE(PIMAGE_FUNCTION_ENTRY, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_FUNCTION_ENTRY, 12, 4);
+}
+
+static void test_pack_PIMAGE_IMPORT_BY_NAME(void)
+{
+ /* PIMAGE_IMPORT_BY_NAME */
+ TEST_TYPE(PIMAGE_IMPORT_BY_NAME, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_IMPORT_BY_NAME, 4, 2);
+}
+
+static void test_pack_PIMAGE_IMPORT_DESCRIPTOR(void)
+{
+ /* PIMAGE_IMPORT_DESCRIPTOR */
+ TEST_TYPE(PIMAGE_IMPORT_DESCRIPTOR, 4, 4);
+}
+
+static void test_pack_PIMAGE_LINENUMBER(void)
+{
+ /* PIMAGE_LINENUMBER */
+ TEST_TYPE(PIMAGE_LINENUMBER, 4, 4);
+}
+
+static void test_pack_PIMAGE_LOAD_CONFIG_DIRECTORY(void)
+{
+ /* PIMAGE_LOAD_CONFIG_DIRECTORY */
+ TEST_TYPE(PIMAGE_LOAD_CONFIG_DIRECTORY, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_LOAD_CONFIG_DIRECTORY, 72, 4);
+}
+
+static void test_pack_PIMAGE_NT_HEADERS(void)
+{
+ /* PIMAGE_NT_HEADERS */
+ TEST_TYPE(PIMAGE_NT_HEADERS, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_NT_HEADERS, 248, 4);
+}
+
+static void test_pack_PIMAGE_OPTIONAL_HEADER(void)
+{
+ /* PIMAGE_OPTIONAL_HEADER */
+ TEST_TYPE(PIMAGE_OPTIONAL_HEADER, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_OPTIONAL_HEADER, 224, 4);
+}
+
+static void test_pack_PIMAGE_OS2_HEADER(void)
+{
+ /* PIMAGE_OS2_HEADER */
+ TEST_TYPE(PIMAGE_OS2_HEADER, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_OS2_HEADER, 64, 2);
+}
+
+static void test_pack_PIMAGE_RELOCATION(void)
+{
+ /* PIMAGE_RELOCATION */
+ TEST_TYPE(PIMAGE_RELOCATION, 4, 4);
+}
+
+static void test_pack_PIMAGE_RESOURCE_DATA_ENTRY(void)
+{
+ /* PIMAGE_RESOURCE_DATA_ENTRY */
+ TEST_TYPE(PIMAGE_RESOURCE_DATA_ENTRY, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_RESOURCE_DATA_ENTRY, 16, 4);
+}
+
+static void test_pack_PIMAGE_RESOURCE_DIRECTORY(void)
+{
+ /* PIMAGE_RESOURCE_DIRECTORY */
+ TEST_TYPE(PIMAGE_RESOURCE_DIRECTORY, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_RESOURCE_DIRECTORY, 16, 4);
+}
+
+static void test_pack_PIMAGE_RESOURCE_DIRECTORY_ENTRY(void)
+{
+ /* PIMAGE_RESOURCE_DIRECTORY_ENTRY */
+ TEST_TYPE(PIMAGE_RESOURCE_DIRECTORY_ENTRY, 4, 4);
+}
+
+static void test_pack_PIMAGE_RESOURCE_DIRECTORY_STRING(void)
+{
+ /* PIMAGE_RESOURCE_DIRECTORY_STRING */
+ TEST_TYPE(PIMAGE_RESOURCE_DIRECTORY_STRING, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_RESOURCE_DIRECTORY_STRING, 4, 2);
+}
+
+static void test_pack_PIMAGE_RESOURCE_DIR_STRING_U(void)
+{
+ /* PIMAGE_RESOURCE_DIR_STRING_U */
+ TEST_TYPE(PIMAGE_RESOURCE_DIR_STRING_U, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_RESOURCE_DIR_STRING_U, 4, 2);
+}
+
+static void test_pack_PIMAGE_SECTION_HEADER(void)
+{
+ /* PIMAGE_SECTION_HEADER */
+ TEST_TYPE(PIMAGE_SECTION_HEADER, 4, 4);
+}
+
+static void test_pack_PIMAGE_SEPARATE_DEBUG_HEADER(void)
+{
+ /* PIMAGE_SEPARATE_DEBUG_HEADER */
+ TEST_TYPE(PIMAGE_SEPARATE_DEBUG_HEADER, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_SEPARATE_DEBUG_HEADER, 48, 4);
+}
+
+static void test_pack_PIMAGE_SYMBOL(void)
+{
+ /* PIMAGE_SYMBOL */
+ TEST_TYPE(PIMAGE_SYMBOL, 4, 4);
+}
+
+static void test_pack_PIMAGE_THUNK_DATA(void)
+{
+ /* PIMAGE_THUNK_DATA */
+ TEST_TYPE(PIMAGE_THUNK_DATA, 4, 4);
+}
+
+static void test_pack_PIMAGE_TLS_CALLBACK(void)
+{
+ /* PIMAGE_TLS_CALLBACK */
+ TEST_TYPE(PIMAGE_TLS_CALLBACK, 4, 4);
+}
+
+static void test_pack_PIMAGE_TLS_DIRECTORY(void)
+{
+ /* PIMAGE_TLS_DIRECTORY */
+ TEST_TYPE(PIMAGE_TLS_DIRECTORY, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_TLS_DIRECTORY, 24, 4);
+}
+
+static void test_pack_PIMAGE_VXD_HEADER(void)
+{
+ /* PIMAGE_VXD_HEADER */
+ TEST_TYPE(PIMAGE_VXD_HEADER, 4, 4);
+ TEST_TYPE_POINTER(PIMAGE_VXD_HEADER, 196, 2);
+}
+
+static void test_pack_PIO_COUNTERS(void)
+{
+ /* PIO_COUNTERS */
+ TEST_TYPE(PIO_COUNTERS, 4, 4);
+ TEST_TYPE_POINTER(PIO_COUNTERS, 48, 8);
+}
+
+static void test_pack_PISECURITY_DESCRIPTOR(void)
+{
+ /* PISECURITY_DESCRIPTOR */
+ TEST_TYPE(PISECURITY_DESCRIPTOR, 4, 4);
+ TEST_TYPE_POINTER(PISECURITY_DESCRIPTOR, 20, 4);
+}
+
+static void test_pack_PISECURITY_DESCRIPTOR_RELATIVE(void)
+{
+ /* PISECURITY_DESCRIPTOR_RELATIVE */
+ TEST_TYPE(PISECURITY_DESCRIPTOR_RELATIVE, 4, 4);
+ TEST_TYPE_POINTER(PISECURITY_DESCRIPTOR_RELATIVE, 20, 4);
+}
+
+static void test_pack_PISID(void)
+{
+ /* PISID */
+ TEST_TYPE(PISID, 4, 4);
+ TEST_TYPE_POINTER(PISID, 12, 4);
+}
+
+static void test_pack_PLARGE_INTEGER(void)
+{
+ /* PLARGE_INTEGER */
+ TEST_TYPE(PLARGE_INTEGER, 4, 4);
+}
+
+static void test_pack_PLIST_ENTRY(void)
+{
+ /* PLIST_ENTRY */
+ TEST_TYPE(PLIST_ENTRY, 4, 4);
+ TEST_TYPE_POINTER(PLIST_ENTRY, 8, 4);
+}
+
+static void test_pack_PLUID(void)
+{
+ /* PLUID */
+ TEST_TYPE(PLUID, 4, 4);
+ TEST_TYPE_POINTER(PLUID, 8, 4);
+}
+
+static void test_pack_PLUID_AND_ATTRIBUTES(void)
+{
+ /* PLUID_AND_ATTRIBUTES */
+ TEST_TYPE(PLUID_AND_ATTRIBUTES, 4, 4);
+ TEST_TYPE_POINTER(PLUID_AND_ATTRIBUTES, 12, 4);
+}
+
+static void test_pack_PMEMORY_BASIC_INFORMATION(void)
+{
+ /* PMEMORY_BASIC_INFORMATION */
+ TEST_TYPE(PMEMORY_BASIC_INFORMATION, 4, 4);
+ TEST_TYPE_POINTER(PMEMORY_BASIC_INFORMATION, 28, 4);
+}
+
+static void test_pack_PMESSAGE_RESOURCE_BLOCK(void)
+{
+ /* PMESSAGE_RESOURCE_BLOCK */
+ TEST_TYPE(PMESSAGE_RESOURCE_BLOCK, 4, 4);
+ TEST_TYPE_POINTER(PMESSAGE_RESOURCE_BLOCK, 12, 4);
+}
+
+static void test_pack_PMESSAGE_RESOURCE_DATA(void)
+{
+ /* PMESSAGE_RESOURCE_DATA */
+ TEST_TYPE(PMESSAGE_RESOURCE_DATA, 4, 4);
+ TEST_TYPE_POINTER(PMESSAGE_RESOURCE_DATA, 16, 4);
+}
+
+static void test_pack_PMESSAGE_RESOURCE_ENTRY(void)
+{
+ /* PMESSAGE_RESOURCE_ENTRY */
+ TEST_TYPE(PMESSAGE_RESOURCE_ENTRY, 4, 4);
+ TEST_TYPE_POINTER(PMESSAGE_RESOURCE_ENTRY, 6, 2);
+}
+
+static void test_pack_PNT_TIB(void)
+{
+ /* PNT_TIB */
+ TEST_TYPE(PNT_TIB, 4, 4);
+}
+
+static void test_pack_POBJECT_TYPE_LIST(void)
+{
+ /* POBJECT_TYPE_LIST */
+ TEST_TYPE(POBJECT_TYPE_LIST, 4, 4);
+ TEST_TYPE_POINTER(POBJECT_TYPE_LIST, 8, 4);
+}
+
+static void test_pack_PPRIVILEGE_SET(void)
+{
+ /* PPRIVILEGE_SET */
+ TEST_TYPE(PPRIVILEGE_SET, 4, 4);
+ TEST_TYPE_POINTER(PPRIVILEGE_SET, 20, 4);
+}
+
+static void test_pack_PRIVILEGE_SET(void)
+{
+ /* PRIVILEGE_SET (pack 4) */
+ TEST_TYPE(PRIVILEGE_SET, 20, 4);
+ TEST_FIELD(PRIVILEGE_SET, DWORD, PrivilegeCount, 0, 4, 4);
+ TEST_FIELD(PRIVILEGE_SET, DWORD, Control, 4, 4, 4);
+ TEST_FIELD(PRIVILEGE_SET, LUID_AND_ATTRIBUTES[ANYSIZE_ARRAY], Privilege, 8, 12, 4);
+}
+
+static void test_pack_PRLIST_ENTRY(void)
+{
+ /* PRLIST_ENTRY */
+ TEST_TYPE(PRLIST_ENTRY, 4, 4);
+ TEST_TYPE_POINTER(PRLIST_ENTRY, 8, 4);
+}
+
+static void test_pack_PRTL_CRITICAL_SECTION(void)
+{
+ /* PRTL_CRITICAL_SECTION */
+ TEST_TYPE(PRTL_CRITICAL_SECTION, 4, 4);
+ TEST_TYPE_POINTER(PRTL_CRITICAL_SECTION, 24, 4);
+}
+
+static void test_pack_PRTL_CRITICAL_SECTION_DEBUG(void)
+{
+ /* PRTL_CRITICAL_SECTION_DEBUG */
+ TEST_TYPE(PRTL_CRITICAL_SECTION_DEBUG, 4, 4);
+ TEST_TYPE_POINTER(PRTL_CRITICAL_SECTION_DEBUG, 32, 4);
+}
+
+static void test_pack_PRTL_OSVERSIONINFOEXW(void)
+{
+ /* PRTL_OSVERSIONINFOEXW */
+ TEST_TYPE(PRTL_OSVERSIONINFOEXW, 4, 4);
+ TEST_TYPE_POINTER(PRTL_OSVERSIONINFOEXW, 284, 4);
+}
+
+static void test_pack_PRTL_OSVERSIONINFOW(void)
+{
+ /* PRTL_OSVERSIONINFOW */
+ TEST_TYPE(PRTL_OSVERSIONINFOW, 4, 4);
+ TEST_TYPE_POINTER(PRTL_OSVERSIONINFOW, 276, 4);
+}
+
+static void test_pack_PRTL_RESOURCE_DEBUG(void)
+{
+ /* PRTL_RESOURCE_DEBUG */
+ TEST_TYPE(PRTL_RESOURCE_DEBUG, 4, 4);
+ TEST_TYPE_POINTER(PRTL_RESOURCE_DEBUG, 32, 4);
+}
+
+static void test_pack_PSECURITY_DESCRIPTOR(void)
+{
+ /* PSECURITY_DESCRIPTOR */
+ TEST_TYPE(PSECURITY_DESCRIPTOR, 4, 4);
+}
+
+static void test_pack_PSECURITY_QUALITY_OF_SERVICE(void)
+{
+ /* PSECURITY_QUALITY_OF_SERVICE */
+ TEST_TYPE(PSECURITY_QUALITY_OF_SERVICE, 4, 4);
+}
+
+static void test_pack_PSID(void)
+{
+ /* PSID */
+ TEST_TYPE(PSID, 4, 4);
+}
+
+static void test_pack_PSID_IDENTIFIER_AUTHORITY(void)
+{
+ /* PSID_IDENTIFIER_AUTHORITY */
+ TEST_TYPE(PSID_IDENTIFIER_AUTHORITY, 4, 4);
+ TEST_TYPE_POINTER(PSID_IDENTIFIER_AUTHORITY, 6, 1);
+}
+
+static void test_pack_PSINGLE_LIST_ENTRY(void)
+{
+ /* PSINGLE_LIST_ENTRY */
+ TEST_TYPE(PSINGLE_LIST_ENTRY, 4, 4);
+ TEST_TYPE_POINTER(PSINGLE_LIST_ENTRY, 4, 4);
+}
+
+static void test_pack_PSTR(void)
+{
+ /* PSTR */
+ TEST_TYPE(PSTR, 4, 4);
+ TEST_TYPE_POINTER(PSTR, 1, 1);
+}
+
+static void test_pack_PSYSTEM_ALARM_ACE(void)
+{
+ /* PSYSTEM_ALARM_ACE */
+ TEST_TYPE(PSYSTEM_ALARM_ACE, 4, 4);
+ TEST_TYPE_POINTER(PSYSTEM_ALARM_ACE, 12, 4);
+}
+
+static void test_pack_PSYSTEM_AUDIT_ACE(void)
+{
+ /* PSYSTEM_AUDIT_ACE */
+ TEST_TYPE(PSYSTEM_AUDIT_ACE, 4, 4);
+ TEST_TYPE_POINTER(PSYSTEM_AUDIT_ACE, 12, 4);
+}
+
+static void test_pack_PTOKEN_GROUPS(void)
+{
+ /* PTOKEN_GROUPS */
+ TEST_TYPE(PTOKEN_GROUPS, 4, 4);
+ TEST_TYPE_POINTER(PTOKEN_GROUPS, 12, 4);
+}
+
+static void test_pack_PTOKEN_PRIVILEGES(void)
+{
+ /* PTOKEN_PRIVILEGES */
+ TEST_TYPE(PTOKEN_PRIVILEGES, 4, 4);
+ TEST_TYPE_POINTER(PTOKEN_PRIVILEGES, 16, 4);
+}
+
+static void test_pack_PTOKEN_USER(void)
+{
+ /* PTOKEN_USER */
+ TEST_TYPE(PTOKEN_USER, 4, 4);
+ TEST_TYPE_POINTER(PTOKEN_USER, 8, 4);
+}
+
+static void test_pack_PTOP_LEVEL_EXCEPTION_FILTER(void)
+{
+ /* PTOP_LEVEL_EXCEPTION_FILTER */
+ TEST_TYPE(PTOP_LEVEL_EXCEPTION_FILTER, 4, 4);
+}
+
+static void test_pack_PTSTR(void)
+{
+ /* PTSTR */
+ TEST_TYPE(PTSTR, 4, 4);
+}
+
+static void test_pack_PULARGE_INTEGER(void)
+{
+ /* PULARGE_INTEGER */
+ TEST_TYPE(PULARGE_INTEGER, 4, 4);
+}
+
+static void test_pack_PVECTORED_EXCEPTION_HANDLER(void)
+{
+ /* PVECTORED_EXCEPTION_HANDLER */
+ TEST_TYPE(PVECTORED_EXCEPTION_HANDLER, 4, 4);
+}
+
+static void test_pack_PVOID(void)
+{
+ /* PVOID */
+ TEST_TYPE(PVOID, 4, 4);
+}
+
+static void test_pack_PWCH(void)
+{
+ /* PWCH */
+ TEST_TYPE(PWCH, 4, 4);
+ TEST_TYPE_POINTER(PWCH, 2, 2);
+}
+
+static void test_pack_PWSTR(void)
+{
+ /* PWSTR */
+ TEST_TYPE(PWSTR, 4, 4);
+ TEST_TYPE_POINTER(PWSTR, 2, 2);
+}
+
+static void test_pack_RTL_CRITICAL_SECTION(void)
+{
+ /* RTL_CRITICAL_SECTION (pack 4) */
+ TEST_TYPE(RTL_CRITICAL_SECTION, 24, 4);
+ TEST_FIELD(RTL_CRITICAL_SECTION, PRTL_CRITICAL_SECTION_DEBUG, DebugInfo, 0, 4, 4);
+ TEST_FIELD(RTL_CRITICAL_SECTION, LONG, LockCount, 4, 4, 4);
+ TEST_FIELD(RTL_CRITICAL_SECTION, LONG, RecursionCount, 8, 4, 4);
+ TEST_FIELD(RTL_CRITICAL_SECTION, HANDLE, OwningThread, 12, 4, 4);
+ TEST_FIELD(RTL_CRITICAL_SECTION, HANDLE, LockSemaphore, 16, 4, 4);
+ TEST_FIELD(RTL_CRITICAL_SECTION, ULONG_PTR, SpinCount, 20, 4, 4);
+}
+
+static void test_pack_RTL_CRITICAL_SECTION_DEBUG(void)
+{
+ /* RTL_CRITICAL_SECTION_DEBUG (pack 4) */
+ TEST_TYPE(RTL_CRITICAL_SECTION_DEBUG, 32, 4);
+ TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, WORD, Type, 0, 2, 2);
+ TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, WORD, CreatorBackTraceIndex, 2, 2, 2);
+ TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, struct _RTL_CRITICAL_SECTION *, CriticalSection, 4, 4, 4);
+ TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, LIST_ENTRY, ProcessLocksList, 8, 8, 4);
+ TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, DWORD, EntryCount, 16, 4, 4);
+ TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, DWORD, ContentionCount, 20, 4, 4);
+ TEST_FIELD(RTL_CRITICAL_SECTION_DEBUG, DWORD[ 2 ], Spare, 24, 8, 4);
+}
+
+static void test_pack_RTL_OSVERSIONINFOEXW(void)
+{
+ /* RTL_OSVERSIONINFOEXW (pack 4) */
+ TEST_TYPE(RTL_OSVERSIONINFOEXW, 284, 4);
+ TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
+ TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwMajorVersion, 4, 4, 4);
+ TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwMinorVersion, 8, 4, 4);
+ TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwBuildNumber, 12, 4, 4);
+ TEST_FIELD(RTL_OSVERSIONINFOEXW, DWORD, dwPlatformId, 16, 4, 4);
+ TEST_FIELD(RTL_OSVERSIONINFOEXW, WCHAR[128], szCSDVersion, 20, 256, 2);
+ TEST_FIELD(RTL_OSVERSIONINFOEXW, WORD, wServicePackMajor, 276, 2, 2);
+ TEST_FIELD(RTL_OSVERSIONINFOEXW, WORD, wServicePackMinor, 278, 2, 2);
+ TEST_FIELD(RTL_OSVERSIONINFOEXW, WORD, wSuiteMask, 280, 2, 2);
+ TEST_FIELD(RTL_OSVERSIONINFOEXW, BYTE, wProductType, 282, 1, 1);
+ TEST_FIELD(RTL_OSVERSIONINFOEXW, BYTE, wReserved, 283, 1, 1);
+}
+
+static void test_pack_RTL_OSVERSIONINFOW(void)
+{
+ /* RTL_OSVERSIONINFOW (pack 4) */
+ TEST_TYPE(RTL_OSVERSIONINFOW, 276, 4);
+ TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
+ TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwMajorVersion, 4, 4, 4);
+ TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwMinorVersion, 8, 4, 4);
+ TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwBuildNumber, 12, 4, 4);
+ TEST_FIELD(RTL_OSVERSIONINFOW, DWORD, dwPlatformId, 16, 4, 4);
+ TEST_FIELD(RTL_OSVERSIONINFOW, WCHAR[128], szCSDVersion, 20, 256, 2);
+}
+
+static void test_pack_RTL_RESOURCE_DEBUG(void)
+{
+ /* RTL_RESOURCE_DEBUG (pack 4) */
+ TEST_TYPE(RTL_RESOURCE_DEBUG, 32, 4);
+ TEST_FIELD(RTL_RESOURCE_DEBUG, WORD, Type, 0, 2, 2);
+ TEST_FIELD(RTL_RESOURCE_DEBUG, WORD, CreatorBackTraceIndex, 2, 2, 2);
+ TEST_FIELD(RTL_RESOURCE_DEBUG, struct _RTL_CRITICAL_SECTION *, CriticalSection, 4, 4, 4);
+ TEST_FIELD(RTL_RESOURCE_DEBUG, LIST_ENTRY, ProcessLocksList, 8, 8, 4);
+ TEST_FIELD(RTL_RESOURCE_DEBUG, DWORD, EntryCount, 16, 4, 4);
+ TEST_FIELD(RTL_RESOURCE_DEBUG, DWORD, ContentionCount, 20, 4, 4);
+ TEST_FIELD(RTL_RESOURCE_DEBUG, DWORD[ 2 ], Spare, 24, 8, 4);
+}
+
+static void test_pack_SECURITY_CONTEXT_TRACKING_MODE(void)
+{
+ /* SECURITY_CONTEXT_TRACKING_MODE */
+ TEST_TYPE(SECURITY_CONTEXT_TRACKING_MODE, 1, 1);
+}
+
+static void test_pack_SECURITY_DESCRIPTOR(void)
+{
+ /* SECURITY_DESCRIPTOR (pack 4) */
+ TEST_TYPE(SECURITY_DESCRIPTOR, 20, 4);
+ TEST_FIELD(SECURITY_DESCRIPTOR, BYTE, Revision, 0, 1, 1);
+ TEST_FIELD(SECURITY_DESCRIPTOR, BYTE, Sbz1, 1, 1, 1);
+ TEST_FIELD(SECURITY_DESCRIPTOR, SECURITY_DESCRIPTOR_CONTROL, Control, 2, 2, 2);
+ TEST_FIELD(SECURITY_DESCRIPTOR, PSID, Owner, 4, 4, 4);
+ TEST_FIELD(SECURITY_DESCRIPTOR, PSID, Group, 8, 4, 4);
+ TEST_FIELD(SECURITY_DESCRIPTOR, PACL, Sacl, 12, 4, 4);
+ TEST_FIELD(SECURITY_DESCRIPTOR, PACL, Dacl, 16, 4, 4);
+}
+
+static void test_pack_SECURITY_DESCRIPTOR_CONTROL(void)
+{
+ /* SECURITY_DESCRIPTOR_CONTROL */
+ TEST_TYPE(SECURITY_DESCRIPTOR_CONTROL, 2, 2);
+ TEST_TYPE_UNSIGNED(SECURITY_DESCRIPTOR_CONTROL);
+}
+
+static void test_pack_SECURITY_DESCRIPTOR_RELATIVE(void)
+{
+ /* SECURITY_DESCRIPTOR_RELATIVE (pack 4) */
+ TEST_TYPE(SECURITY_DESCRIPTOR_RELATIVE, 20, 4);
+ TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, BYTE, Revision, 0, 1, 1);
+ TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, BYTE, Sbz1, 1, 1, 1);
+ TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, SECURITY_DESCRIPTOR_CONTROL, Control, 2, 2, 2);
+ TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, DWORD, Owner, 4, 4, 4);
+ TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, DWORD, Group, 8, 4, 4);
+ TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, DWORD, Sacl, 12, 4, 4);
+ TEST_FIELD(SECURITY_DESCRIPTOR_RELATIVE, DWORD, Dacl, 16, 4, 4);
+}
+
+static void test_pack_SECURITY_INFORMATION(void)
+{
+ /* SECURITY_INFORMATION */
+ TEST_TYPE(SECURITY_INFORMATION, 4, 4);
+ TEST_TYPE_UNSIGNED(SECURITY_INFORMATION);
+}
+
+static void test_pack_SECURITY_QUALITY_OF_SERVICE(void)
+{
+ /* SECURITY_QUALITY_OF_SERVICE (pack 4) */
+ TEST_FIELD(SECURITY_QUALITY_OF_SERVICE, DWORD, Length, 0, 4, 4);
+}
+
+static void test_pack_SHORT(void)
+{
+ /* SHORT */
+ TEST_TYPE(SHORT, 2, 2);
+ TEST_TYPE_SIGNED(SHORT);
+}
+
+static void test_pack_SID(void)
+{
+ /* SID (pack 4) */
+ TEST_TYPE(SID, 12, 4);
+ TEST_FIELD(SID, BYTE, Revision, 0, 1, 1);
+ TEST_FIELD(SID, BYTE, SubAuthorityCount, 1, 1, 1);
+ TEST_FIELD(SID, SID_IDENTIFIER_AUTHORITY, IdentifierAuthority, 2, 6, 1);
+ TEST_FIELD(SID, DWORD[1], SubAuthority, 8, 4, 4);
+}
+
+static void test_pack_SID_AND_ATTRIBUTES(void)
+{
+ /* SID_AND_ATTRIBUTES (pack 4) */
+ TEST_TYPE(SID_AND_ATTRIBUTES, 8, 4);
+ TEST_FIELD(SID_AND_ATTRIBUTES, PSID, Sid, 0, 4, 4);
+ TEST_FIELD(SID_AND_ATTRIBUTES, DWORD, Attributes, 4, 4, 4);
+}
+
+static void test_pack_SID_IDENTIFIER_AUTHORITY(void)
+{
+ /* SID_IDENTIFIER_AUTHORITY (pack 4) */
+ TEST_TYPE(SID_IDENTIFIER_AUTHORITY, 6, 1);
+ TEST_FIELD(SID_IDENTIFIER_AUTHORITY, BYTE[6], Value, 0, 6, 1);
+}
+
+static void test_pack_SINGLE_LIST_ENTRY(void)
+{
+ /* SINGLE_LIST_ENTRY (pack 4) */
+ TEST_TYPE(SINGLE_LIST_ENTRY, 4, 4);
+ TEST_FIELD(SINGLE_LIST_ENTRY, struct _SINGLE_LIST_ENTRY *, Next, 0, 4, 4);
+}
+
+static void test_pack_SYSTEM_ALARM_ACE(void)
+{
+ /* SYSTEM_ALARM_ACE (pack 4) */
+ TEST_TYPE(SYSTEM_ALARM_ACE, 12, 4);
+ TEST_FIELD(SYSTEM_ALARM_ACE, ACE_HEADER, Header, 0, 4, 2);
+ TEST_FIELD(SYSTEM_ALARM_ACE, DWORD, Mask, 4, 4, 4);
+ TEST_FIELD(SYSTEM_ALARM_ACE, DWORD, SidStart, 8, 4, 4);
+}
+
+static void test_pack_SYSTEM_AUDIT_ACE(void)
+{
+ /* SYSTEM_AUDIT_ACE (pack 4) */
+ TEST_TYPE(SYSTEM_AUDIT_ACE, 12, 4);
+ TEST_FIELD(SYSTEM_AUDIT_ACE, ACE_HEADER, Header, 0, 4, 2);
+ TEST_FIELD(SYSTEM_AUDIT_ACE, DWORD, Mask, 4, 4, 4);
+ TEST_FIELD(SYSTEM_AUDIT_ACE, DWORD, SidStart, 8, 4, 4);
+}
+
+static void test_pack_TCHAR(void)
+{
+ /* TCHAR */
+ TEST_TYPE(TCHAR, 1, 1);
+}
+
+static void test_pack_TOKEN_DEFAULT_DACL(void)
+{
+ /* TOKEN_DEFAULT_DACL (pack 4) */
+ TEST_TYPE(TOKEN_DEFAULT_DACL, 4, 4);
+ TEST_FIELD(TOKEN_DEFAULT_DACL, PACL, DefaultDacl, 0, 4, 4);
+}
+
+static void test_pack_TOKEN_GROUPS(void)
+{
+ /* TOKEN_GROUPS (pack 4) */
+ TEST_TYPE(TOKEN_GROUPS, 12, 4);
+ TEST_FIELD(TOKEN_GROUPS, DWORD, GroupCount, 0, 4, 4);
+ TEST_FIELD(TOKEN_GROUPS, SID_AND_ATTRIBUTES[ANYSIZE_ARRAY], Groups, 4, 8, 4);
+}
+
+static void test_pack_TOKEN_OWNER(void)
+{
+ /* TOKEN_OWNER (pack 4) */
+ TEST_TYPE(TOKEN_OWNER, 4, 4);
+ TEST_FIELD(TOKEN_OWNER, PSID, Owner, 0, 4, 4);
+}
+
+static void test_pack_TOKEN_PRIMARY_GROUP(void)
+{
+ /* TOKEN_PRIMARY_GROUP (pack 4) */
+ TEST_TYPE(TOKEN_PRIMARY_GROUP, 4, 4);
+ TEST_FIELD(TOKEN_PRIMARY_GROUP, PSID, PrimaryGroup, 0, 4, 4);
+}
+
+static void test_pack_TOKEN_PRIVILEGES(void)
+{
+ /* TOKEN_PRIVILEGES (pack 4) */
+ TEST_TYPE(TOKEN_PRIVILEGES, 16, 4);
+ TEST_FIELD(TOKEN_PRIVILEGES, DWORD, PrivilegeCount, 0, 4, 4);
+ TEST_FIELD(TOKEN_PRIVILEGES, LUID_AND_ATTRIBUTES[ANYSIZE_ARRAY], Privileges, 4, 12, 4);
+}
+
+static void test_pack_TOKEN_SOURCE(void)
+{
+ /* TOKEN_SOURCE (pack 4) */
+ TEST_TYPE(TOKEN_SOURCE, 16, 4);
+ TEST_FIELD(TOKEN_SOURCE, char[TOKEN_SOURCE_LENGTH], SourceName, 0, 8, 1);
+ TEST_FIELD(TOKEN_SOURCE, LUID, SourceIdentifier, 8, 8, 4);
+}
+
+static void test_pack_TOKEN_STATISTICS(void)
+{
+ /* TOKEN_STATISTICS (pack 4) */
+ TEST_FIELD(TOKEN_STATISTICS, LUID, TokenId, 0, 8, 4);
+ TEST_FIELD(TOKEN_STATISTICS, LUID, AuthenticationId, 8, 8, 4);
+ TEST_FIELD(TOKEN_STATISTICS, LARGE_INTEGER, ExpirationTime, 16, 8, 4);
+}
+
+static void test_pack_TOKEN_USER(void)
+{
+ /* TOKEN_USER (pack 4) */
+ TEST_TYPE(TOKEN_USER, 8, 4);
+ TEST_FIELD(TOKEN_USER, SID_AND_ATTRIBUTES, User, 0, 8, 4);
+}
+
+static void test_pack_ULARGE_INTEGER(void)
+{
+ /* ULARGE_INTEGER (pack 4) */
+}
+
+static void test_pack_ULONGLONG(void)
+{
+ /* ULONGLONG */
+ TEST_TYPE(ULONGLONG, 8, 8);
+ TEST_TYPE_UNSIGNED(ULONGLONG);
+}
+
+static void test_pack_WAITORTIMERCALLBACKFUNC(void)
+{
+ /* WAITORTIMERCALLBACKFUNC */
+ TEST_TYPE(WAITORTIMERCALLBACKFUNC, 4, 4);
+}
+
+static void test_pack_WCHAR(void)
+{
+ /* WCHAR */
+ TEST_TYPE(WCHAR, 2, 2);
+ TEST_TYPE_UNSIGNED(WCHAR);
+}
+
+static void test_pack_ATOM(void)
+{
+ /* ATOM */
+ TEST_TYPE(ATOM, 2, 2);
+ TEST_TYPE_UNSIGNED(ATOM);
+}
+
+static void test_pack_BOOL(void)
+{
+ /* BOOL */
+ TEST_TYPE(BOOL, 4, 4);
+ TEST_TYPE_SIGNED(BOOL);
+}
+
+static void test_pack_BYTE(void)
+{
+ /* BYTE */
+ TEST_TYPE(BYTE, 1, 1);
+ TEST_TYPE_UNSIGNED(BYTE);
+}
+
+static void test_pack_COLORREF(void)
+{
+ /* COLORREF */
+ TEST_TYPE(COLORREF, 4, 4);
+ TEST_TYPE_UNSIGNED(COLORREF);
+}
+
+static void test_pack_DWORD(void)
+{
+ /* DWORD */
+ TEST_TYPE(DWORD, 4, 4);
+ TEST_TYPE_UNSIGNED(DWORD);
+}
+
+static void test_pack_FARPROC(void)
+{
+ /* FARPROC */
+ TEST_TYPE(FARPROC, 4, 4);
+}
+
+static void test_pack_FLOAT(void)
+{
+ /* FLOAT */
+ TEST_TYPE(FLOAT, 4, 4);
+}
+
+static void test_pack_GLOBALHANDLE(void)
+{
+ /* GLOBALHANDLE */
+ TEST_TYPE(GLOBALHANDLE, 4, 4);
+}
+
+static void test_pack_HCURSOR(void)
+{
+ /* HCURSOR */
+ TEST_TYPE(HCURSOR, 4, 4);
+ TEST_TYPE_UNSIGNED(HCURSOR);
+}
+
+static void test_pack_HFILE(void)
+{
+ /* HFILE */
+ TEST_TYPE(HFILE, 4, 4);
+ TEST_TYPE_SIGNED(HFILE);
+}
+
+static void test_pack_HGDIOBJ(void)
+{
+ /* HGDIOBJ */
+ TEST_TYPE(HGDIOBJ, 4, 4);
+}
+
+static void test_pack_HGLOBAL(void)
+{
+ /* HGLOBAL */
+ TEST_TYPE(HGLOBAL, 4, 4);
+}
+
+static void test_pack_HLOCAL(void)
+{
+ /* HLOCAL */
+ TEST_TYPE(HLOCAL, 4, 4);
+}
+
+static void test_pack_HMODULE(void)
+{
+ /* HMODULE */
+ TEST_TYPE(HMODULE, 4, 4);
+ TEST_TYPE_UNSIGNED(HMODULE);
+}
+
+static void test_pack_INT(void)
+{
+ /* INT */
+ TEST_TYPE(INT, 4, 4);
+ TEST_TYPE_SIGNED(INT);
+}
+
+static void test_pack_LOCALHANDLE(void)
+{
+ /* LOCALHANDLE */
+ TEST_TYPE(LOCALHANDLE, 4, 4);
+}
+
+static void test_pack_LPARAM(void)
+{
+ /* LPARAM */
+ TEST_TYPE(LPARAM, 4, 4);
+}
+
+static void test_pack_LPCRECT(void)
+{
+ /* LPCRECT */
+ TEST_TYPE(LPCRECT, 4, 4);
+ TEST_TYPE_POINTER(LPCRECT, 16, 4);
+}
+
+static void test_pack_LPCRECTL(void)
+{
+ /* LPCRECTL */
+ TEST_TYPE(LPCRECTL, 4, 4);
+ TEST_TYPE_POINTER(LPCRECTL, 16, 4);
+}
+
+static void test_pack_LPCVOID(void)
+{
+ /* LPCVOID */
+ TEST_TYPE(LPCVOID, 4, 4);
+}
+
+static void test_pack_LPPOINT(void)
+{
+ /* LPPOINT */
+ TEST_TYPE(LPPOINT, 4, 4);
+ TEST_TYPE_POINTER(LPPOINT, 8, 4);
+}
+
+static void test_pack_LPPOINTS(void)
+{
+ /* LPPOINTS */
+ TEST_TYPE(LPPOINTS, 4, 4);
+ TEST_TYPE_POINTER(LPPOINTS, 4, 2);
+}
+
+static void test_pack_LPRECT(void)
+{
+ /* LPRECT */
+ TEST_TYPE(LPRECT, 4, 4);
+ TEST_TYPE_POINTER(LPRECT, 16, 4);
+}
+
+static void test_pack_LPRECTL(void)
+{
+ /* LPRECTL */
+ TEST_TYPE(LPRECTL, 4, 4);
+ TEST_TYPE_POINTER(LPRECTL, 16, 4);
+}
+
+static void test_pack_LPSIZE(void)
+{
+ /* LPSIZE */
+ TEST_TYPE(LPSIZE, 4, 4);
+ TEST_TYPE_POINTER(LPSIZE, 8, 4);
+}
+
+static void test_pack_LRESULT(void)
+{
+ /* LRESULT */
+ TEST_TYPE(LRESULT, 4, 4);
+}
+
+static void test_pack_POINT(void)
+{
+ /* POINT (pack 4) */
+ TEST_TYPE(POINT, 8, 4);
+ TEST_FIELD(POINT, LONG, x, 0, 4, 4);
+ TEST_FIELD(POINT, LONG, y, 4, 4, 4);
+}
+
+static void test_pack_POINTL(void)
+{
+ /* POINTL (pack 4) */
+ TEST_TYPE(POINTL, 8, 4);
+ TEST_FIELD(POINTL, LONG, x, 0, 4, 4);
+ TEST_FIELD(POINTL, LONG, y, 4, 4, 4);
+}
+
+static void test_pack_POINTS(void)
+{
+ /* POINTS (pack 4) */
+ TEST_TYPE(POINTS, 4, 2);
+ TEST_FIELD(POINTS, SHORT, x, 0, 2, 2);
+ TEST_FIELD(POINTS, SHORT, y, 2, 2, 2);
+}
+
+static void test_pack_PPOINT(void)
+{
+ /* PPOINT */
+ TEST_TYPE(PPOINT, 4, 4);
+ TEST_TYPE_POINTER(PPOINT, 8, 4);
+}
+
+static void test_pack_PPOINTL(void)
+{
+ /* PPOINTL */
+ TEST_TYPE(PPOINTL, 4, 4);
+ TEST_TYPE_POINTER(PPOINTL, 8, 4);
+}
+
+static void test_pack_PPOINTS(void)
+{
+ /* PPOINTS */
+ TEST_TYPE(PPOINTS, 4, 4);
+ TEST_TYPE_POINTER(PPOINTS, 4, 2);
+}
+
+static void test_pack_PRECT(void)
+{
+ /* PRECT */
+ TEST_TYPE(PRECT, 4, 4);
+ TEST_TYPE_POINTER(PRECT, 16, 4);
+}
+
+static void test_pack_PRECTL(void)
+{
+ /* PRECTL */
+ TEST_TYPE(PRECTL, 4, 4);
+ TEST_TYPE_POINTER(PRECTL, 16, 4);
+}
+
+static void test_pack_PROC(void)
+{
+ /* PROC */
+ TEST_TYPE(PROC, 4, 4);
+}
+
+static void test_pack_PSIZE(void)
+{
+ /* PSIZE */
+ TEST_TYPE(PSIZE, 4, 4);
+ TEST_TYPE_POINTER(PSIZE, 8, 4);
+}
+
+static void test_pack_PSZ(void)
+{
+ /* PSZ */
+ TEST_TYPE(PSZ, 4, 4);
+}
+
+static void test_pack_RECT(void)
+{
+ /* RECT (pack 4) */
+ TEST_TYPE(RECT, 16, 4);
+ TEST_FIELD(RECT, LONG, left, 0, 4, 4);
+ TEST_FIELD(RECT, LONG, top, 4, 4, 4);
+ TEST_FIELD(RECT, LONG, right, 8, 4, 4);
+ TEST_FIELD(RECT, LONG, bottom, 12, 4, 4);
+}
+
+static void test_pack_RECTL(void)
+{
+ /* RECTL (pack 4) */
+ TEST_TYPE(RECTL, 16, 4);
+ TEST_FIELD(RECTL, LONG, left, 0, 4, 4);
+ TEST_FIELD(RECTL, LONG, top, 4, 4, 4);
+ TEST_FIELD(RECTL, LONG, right, 8, 4, 4);
+ TEST_FIELD(RECTL, LONG, bottom, 12, 4, 4);
+}
+
+static void test_pack_SIZE(void)
+{
+ /* SIZE (pack 4) */
+ TEST_TYPE(SIZE, 8, 4);
+ TEST_FIELD(SIZE, LONG, cx, 0, 4, 4);
+ TEST_FIELD(SIZE, LONG, cy, 4, 4, 4);
+}
+
+static void test_pack_SIZEL(void)
+{
+ /* SIZEL */
+ TEST_TYPE(SIZEL, 8, 4);
+}
+
+static void test_pack_UCHAR(void)
+{
+ /* UCHAR */
+ TEST_TYPE(UCHAR, 1, 1);
+ TEST_TYPE_UNSIGNED(UCHAR);
+}
+
+static void test_pack_UINT(void)
+{
+ /* UINT */
+ TEST_TYPE(UINT, 4, 4);
+ TEST_TYPE_UNSIGNED(UINT);
+}
+
+static void test_pack_ULONG(void)
+{
+ /* ULONG */
+ TEST_TYPE(ULONG, 4, 4);
+ TEST_TYPE_UNSIGNED(ULONG);
+}
+
+static void test_pack_USHORT(void)
+{
+ /* USHORT */
+ TEST_TYPE(USHORT, 2, 2);
+ TEST_TYPE_UNSIGNED(USHORT);
+}
+
+static void test_pack_WORD(void)
+{
+ /* WORD */
+ TEST_TYPE(WORD, 2, 2);
+ TEST_TYPE_UNSIGNED(WORD);
+}
+
+static void test_pack_WPARAM(void)
+{
+ /* WPARAM */
+ TEST_TYPE(WPARAM, 4, 4);
+}
+
+static void test_pack(void)
+{
+ test_pack_ACCESS_ALLOWED_ACE();
+ test_pack_ACCESS_DENIED_ACE();
+ test_pack_ACCESS_MASK();
+ test_pack_ACE_HEADER();
+ test_pack_ACL();
+ test_pack_ACL_REVISION_INFORMATION();
+ test_pack_ACL_SIZE_INFORMATION();
+ test_pack_ATOM();
+ test_pack_BOOL();
+ test_pack_BOOLEAN();
+ test_pack_BYTE();
+ test_pack_CCHAR();
+ test_pack_CHAR();
+ test_pack_COLORREF();
+ test_pack_DWORD();
+ test_pack_DWORD32();
+ test_pack_DWORD64();
+ test_pack_DWORDLONG();
+ test_pack_DWORD_PTR();
+ test_pack_EXCEPTION_POINTERS();
+ test_pack_EXCEPTION_RECORD();
+ test_pack_EXECUTION_STATE();
+ test_pack_FARPROC();
+ test_pack_FLOAT();
+ test_pack_FLOATING_SAVE_AREA();
+ test_pack_FPO_DATA();
+ test_pack_GENERIC_MAPPING();
+ test_pack_GLOBALHANDLE();
+ test_pack_HALF_PTR();
+ test_pack_HANDLE();
+ test_pack_HCURSOR();
+ test_pack_HFILE();
+ test_pack_HGDIOBJ();
+ test_pack_HGLOBAL();
+ test_pack_HLOCAL();
+ test_pack_HMODULE();
+ test_pack_HRESULT();
+ test_pack_IMAGE_ARCHIVE_MEMBER_HEADER();
+ test_pack_IMAGE_AUX_SYMBOL();
+ test_pack_IMAGE_BASE_RELOCATION();
+ test_pack_IMAGE_BOUND_FORWARDER_REF();
+ test_pack_IMAGE_BOUND_IMPORT_DESCRIPTOR();
+ test_pack_IMAGE_COFF_SYMBOLS_HEADER();
+ test_pack_IMAGE_DATA_DIRECTORY();
+ test_pack_IMAGE_DEBUG_DIRECTORY();
+ test_pack_IMAGE_DEBUG_MISC();
+ test_pack_IMAGE_DOS_HEADER();
+ test_pack_IMAGE_EXPORT_DIRECTORY();
+ test_pack_IMAGE_FILE_HEADER();
+ test_pack_IMAGE_FUNCTION_ENTRY();
+ test_pack_IMAGE_IMPORT_BY_NAME();
+ test_pack_IMAGE_IMPORT_DESCRIPTOR();
+ test_pack_IMAGE_LINENUMBER();
+ test_pack_IMAGE_LOAD_CONFIG_DIRECTORY();
+ test_pack_IMAGE_NT_HEADERS();
+ test_pack_IMAGE_OPTIONAL_HEADER();
+ test_pack_IMAGE_OS2_HEADER();
+ test_pack_IMAGE_RELOCATION();
+ test_pack_IMAGE_RESOURCE_DATA_ENTRY();
+ test_pack_IMAGE_RESOURCE_DIRECTORY();
+ test_pack_IMAGE_RESOURCE_DIRECTORY_ENTRY();
+ test_pack_IMAGE_RESOURCE_DIRECTORY_STRING();
+ test_pack_IMAGE_RESOURCE_DIR_STRING_U();
+ test_pack_IMAGE_SECTION_HEADER();
+ test_pack_IMAGE_SEPARATE_DEBUG_HEADER();
+ test_pack_IMAGE_SYMBOL();
+ test_pack_IMAGE_THUNK_DATA();
+ test_pack_IMAGE_TLS_DIRECTORY();
+ test_pack_IMAGE_VXD_HEADER();
+ test_pack_INT();
+ test_pack_INT16();
+ test_pack_INT32();
+ test_pack_INT64();
+ test_pack_INT8();
+ test_pack_INT_PTR();
+ test_pack_IO_COUNTERS();
+ test_pack_LANGID();
+ test_pack_LARGE_INTEGER();
+ test_pack_LCID();
+ test_pack_LIST_ENTRY();
+ test_pack_LOCALHANDLE();
+ test_pack_LONG();
+ test_pack_LONG32();
+ test_pack_LONG64();
+ test_pack_LONGLONG();
+ test_pack_LONG_PTR();
+ test_pack_LPARAM();
+ test_pack_LPCRECT();
+ test_pack_LPCRECTL();
+ test_pack_LPCVOID();
+ test_pack_LPPOINT();
+ test_pack_LPPOINTS();
+ test_pack_LPRECT();
+ test_pack_LPRECTL();
+ test_pack_LPSIZE();
+ test_pack_LPTOP_LEVEL_EXCEPTION_FILTER();
+ test_pack_LRESULT();
+ test_pack_LUID();
+ test_pack_LUID_AND_ATTRIBUTES();
+ test_pack_MEMORY_BASIC_INFORMATION();
+ test_pack_MESSAGE_RESOURCE_BLOCK();
+ test_pack_MESSAGE_RESOURCE_DATA();
+ test_pack_MESSAGE_RESOURCE_ENTRY();
+ test_pack_NT_TIB();
+ test_pack_OBJECT_TYPE_LIST();
+ test_pack_PACCESS_ALLOWED_ACE();
+ test_pack_PACCESS_DENIED_ACE();
+ test_pack_PACCESS_TOKEN();
+ test_pack_PACE_HEADER();
+ test_pack_PACL();
+ test_pack_PACL_REVISION_INFORMATION();
+ test_pack_PACL_SIZE_INFORMATION();
+ test_pack_PCCH();
+ test_pack_PCH();
+ test_pack_PCSTR();
+ test_pack_PCTSTR();
+ test_pack_PCWCH();
+ test_pack_PCWSTR();
+ test_pack_PEXCEPTION_POINTERS();
+ test_pack_PEXCEPTION_RECORD();
+ test_pack_PFLOATING_SAVE_AREA();
+ test_pack_PFPO_DATA();
+ test_pack_PGENERIC_MAPPING();
+ test_pack_PHANDLE();
+ test_pack_PIMAGE_ARCHIVE_MEMBER_HEADER();
+ test_pack_PIMAGE_AUX_SYMBOL();
+ test_pack_PIMAGE_BASE_RELOCATION();
+ test_pack_PIMAGE_BOUND_FORWARDER_REF();
+ test_pack_PIMAGE_BOUND_IMPORT_DESCRIPTOR();
+ test_pack_PIMAGE_COFF_SYMBOLS_HEADER();
+ test_pack_PIMAGE_DATA_DIRECTORY();
+ test_pack_PIMAGE_DEBUG_DIRECTORY();
+ test_pack_PIMAGE_DEBUG_MISC();
+ test_pack_PIMAGE_DOS_HEADER();
+ test_pack_PIMAGE_EXPORT_DIRECTORY();
+ test_pack_PIMAGE_FILE_HEADER();
+ test_pack_PIMAGE_FUNCTION_ENTRY();
+ test_pack_PIMAGE_IMPORT_BY_NAME();
+ test_pack_PIMAGE_IMPORT_DESCRIPTOR();
+ test_pack_PIMAGE_LINENUMBER();
+ test_pack_PIMAGE_LOAD_CONFIG_DIRECTORY();
+ test_pack_PIMAGE_NT_HEADERS();
+ test_pack_PIMAGE_OPTIONAL_HEADER();
+ test_pack_PIMAGE_OS2_HEADER();
+ test_pack_PIMAGE_RELOCATION();
+ test_pack_PIMAGE_RESOURCE_DATA_ENTRY();
+ test_pack_PIMAGE_RESOURCE_DIRECTORY();
+ test_pack_PIMAGE_RESOURCE_DIRECTORY_ENTRY();
+ test_pack_PIMAGE_RESOURCE_DIRECTORY_STRING();
+ test_pack_PIMAGE_RESOURCE_DIR_STRING_U();
+ test_pack_PIMAGE_SECTION_HEADER();
+ test_pack_PIMAGE_SEPARATE_DEBUG_HEADER();
+ test_pack_PIMAGE_SYMBOL();
+ test_pack_PIMAGE_THUNK_DATA();
+ test_pack_PIMAGE_TLS_CALLBACK();
+ test_pack_PIMAGE_TLS_DIRECTORY();
+ test_pack_PIMAGE_VXD_HEADER();
+ test_pack_PIO_COUNTERS();
+ test_pack_PISECURITY_DESCRIPTOR();
+ test_pack_PISECURITY_DESCRIPTOR_RELATIVE();
+ test_pack_PISID();
+ test_pack_PLARGE_INTEGER();
+ test_pack_PLIST_ENTRY();
+ test_pack_PLUID();
+ test_pack_PLUID_AND_ATTRIBUTES();
+ test_pack_PMEMORY_BASIC_INFORMATION();
+ test_pack_PMESSAGE_RESOURCE_BLOCK();
+ test_pack_PMESSAGE_RESOURCE_DATA();
+ test_pack_PMESSAGE_RESOURCE_ENTRY();
+ test_pack_PNT_TIB();
+ test_pack_POBJECT_TYPE_LIST();
+ test_pack_POINT();
+ test_pack_POINTL();
+ test_pack_POINTS();
+ test_pack_PPOINT();
+ test_pack_PPOINTL();
+ test_pack_PPOINTS();
+ test_pack_PPRIVILEGE_SET();
+ test_pack_PRECT();
+ test_pack_PRECTL();
+ test_pack_PRIVILEGE_SET();
+ test_pack_PRLIST_ENTRY();
+ test_pack_PROC();
+ test_pack_PRTL_CRITICAL_SECTION();
+ test_pack_PRTL_CRITICAL_SECTION_DEBUG();
+ test_pack_PRTL_OSVERSIONINFOEXW();
+ test_pack_PRTL_OSVERSIONINFOW();
+ test_pack_PRTL_RESOURCE_DEBUG();
+ test_pack_PSECURITY_DESCRIPTOR();
+ test_pack_PSECURITY_QUALITY_OF_SERVICE();
+ test_pack_PSID();
+ test_pack_PSID_IDENTIFIER_AUTHORITY();
+ test_pack_PSINGLE_LIST_ENTRY();
+ test_pack_PSIZE();
+ test_pack_PSTR();
+ test_pack_PSYSTEM_ALARM_ACE();
+ test_pack_PSYSTEM_AUDIT_ACE();
+ test_pack_PSZ();
+ test_pack_PTOKEN_GROUPS();
+ test_pack_PTOKEN_PRIVILEGES();
+ test_pack_PTOKEN_USER();
+ test_pack_PTOP_LEVEL_EXCEPTION_FILTER();
+ test_pack_PTSTR();
+ test_pack_PULARGE_INTEGER();
+ test_pack_PVECTORED_EXCEPTION_HANDLER();
+ test_pack_PVOID();
+ test_pack_PWCH();
+ test_pack_PWSTR();
+ test_pack_RECT();
+ test_pack_RECTL();
+ test_pack_RTL_CRITICAL_SECTION();
+ test_pack_RTL_CRITICAL_SECTION_DEBUG();
+ test_pack_RTL_OSVERSIONINFOEXW();
+ test_pack_RTL_OSVERSIONINFOW();
+ test_pack_RTL_RESOURCE_DEBUG();
+ test_pack_SECURITY_CONTEXT_TRACKING_MODE();
+ test_pack_SECURITY_DESCRIPTOR();
+ test_pack_SECURITY_DESCRIPTOR_CONTROL();
+ test_pack_SECURITY_DESCRIPTOR_RELATIVE();
+ test_pack_SECURITY_INFORMATION();
+ test_pack_SECURITY_QUALITY_OF_SERVICE();
+ test_pack_SHORT();
+ test_pack_SID();
+ test_pack_SID_AND_ATTRIBUTES();
+ test_pack_SID_IDENTIFIER_AUTHORITY();
+ test_pack_SINGLE_LIST_ENTRY();
+ test_pack_SIZE();
+ test_pack_SIZEL();
+ test_pack_SIZE_T();
+ test_pack_SSIZE_T();
+ test_pack_SYSTEM_ALARM_ACE();
+ test_pack_SYSTEM_AUDIT_ACE();
+ test_pack_TCHAR();
+ test_pack_TOKEN_DEFAULT_DACL();
+ test_pack_TOKEN_GROUPS();
+ test_pack_TOKEN_OWNER();
+ test_pack_TOKEN_PRIMARY_GROUP();
+ test_pack_TOKEN_PRIVILEGES();
+ test_pack_TOKEN_SOURCE();
+ test_pack_TOKEN_STATISTICS();
+ test_pack_TOKEN_USER();
+ test_pack_UCHAR();
+ test_pack_UHALF_PTR();
+ test_pack_UINT();
+ test_pack_UINT16();
+ test_pack_UINT32();
+ test_pack_UINT64();
+ test_pack_UINT8();
+ test_pack_UINT_PTR();
+ test_pack_ULARGE_INTEGER();
+ test_pack_ULONG();
+ test_pack_ULONG32();
+ test_pack_ULONG64();
+ test_pack_ULONGLONG();
+ test_pack_ULONG_PTR();
+ test_pack_USHORT();
+ test_pack_WAITORTIMERCALLBACKFUNC();
+ test_pack_WCHAR();
+ test_pack_WORD();
+ test_pack_WPARAM();
+}
+
+START_TEST(generated)
+{
+ test_pack();
+}
--- /dev/null
+/* Unit test suite for *Information* Registry API functions
+ *
+ * Copyright 2005 Paul Vriens
+ *
+ * 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
+ *
+ */
+
+#include "ntdll_test.h"
+
+static NTSTATUS (WINAPI * pNtQuerySystemInformation)(SYSTEM_INFORMATION_CLASS, PVOID, ULONG, PULONG);
+static NTSTATUS (WINAPI * pNtQueryInformationProcess)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG);
+
+static HMODULE hntdll = 0;
+
+/* one_before_last_pid is used to be able to compare values of a still running process
+ with the output of the test_query_process_times and test_query_process_handlecount tests.
+*/
+static DWORD one_before_last_pid = 0;
+
+#define NTDLL_GET_PROC(func) \
+ p ## func = (void*)GetProcAddress(hntdll, #func); \
+ if(!p ## func) { \
+ trace("GetProcAddress(%s) failed\n", #func); \
+ FreeLibrary(hntdll); \
+ return FALSE; \
+ }
+
+static BOOL InitFunctionPtrs(void)
+{
+ hntdll = LoadLibraryA("ntdll.dll");
+ if(!hntdll) {
+ trace("Could not load ntdll.dll\n");
+ return FALSE;
+ }
+ if (hntdll)
+ {
+ NTDLL_GET_PROC(NtQuerySystemInformation)
+ NTDLL_GET_PROC(NtQueryInformationProcess)
+ }
+ return TRUE;
+}
+
+static void test_query_basic(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ SYSTEM_BASIC_INFORMATION sbi;
+
+ /* This test also covers some basic parameter testing that should be the same for
+ * every information class
+ */
+
+ /* Use a nonexistent info class */
+ trace("Check nonexistent info class\n");
+ status = pNtQuerySystemInformation(-1, NULL, 0, NULL);
+ ok( status == STATUS_INVALID_INFO_CLASS, "Expected STATUS_INVALID_INFO_CLASS, got %08lx\n", status);
+
+ /* Use an existing class but with a zero-length buffer */
+ trace("Check zero-length buffer\n");
+ status = pNtQuerySystemInformation(SystemBasicInformation, NULL, 0, NULL);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ /* Use an existing class, correct length but no SystemInformation buffer */
+ trace("Check no SystemInformation buffer\n");
+ status = pNtQuerySystemInformation(SystemBasicInformation, NULL, sizeof(sbi), NULL);
+ ok( status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got %08lx\n", status);
+
+ /* Use a existing class, correct length, a pointer to a buffer but no ReturnLength pointer */
+ trace("Check no ReturnLength pointer\n");
+ status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), NULL);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+
+ /* Check a too large buffer size */
+ trace("Check a too large buffer size\n");
+ status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi) * 2, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ /* Finally some correct calls */
+ trace("Check with correct parameters\n");
+ status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(sbi) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(sbi), ReturnLength);
+
+ /* Check if we have some return values */
+ trace("Number of Processors : %d\n", sbi.NumberOfProcessors);
+ ok( sbi.NumberOfProcessors > 0, "Expected more than 0 processors, got %d\n", sbi.NumberOfProcessors);
+}
+
+static void test_query_cpu(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ SYSTEM_CPU_INFORMATION sci;
+
+ status = pNtQuerySystemInformation(SystemCpuInformation, &sci, sizeof(sci), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(sci) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(sci), ReturnLength);
+
+ /* Check if we have some return values */
+ trace("Processor FeatureSet : %08lx\n", sci.FeatureSet);
+ ok( sci.FeatureSet != 0, "Expected some features for this processor, got %08lx\n", sci.FeatureSet);
+}
+
+static void test_query_performance(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ SYSTEM_PERFORMANCE_INFORMATION spi;
+
+ status = pNtQuerySystemInformation(SystemPerformanceInformation, &spi, 0, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ status = pNtQuerySystemInformation(SystemPerformanceInformation, &spi, sizeof(spi), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(spi) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(spi), ReturnLength);
+
+ status = pNtQuerySystemInformation(SystemPerformanceInformation, &spi, sizeof(spi) + 2, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(spi) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(spi), ReturnLength);
+
+ /* Not return values yet, as struct members are unknown */
+}
+
+static void test_query_timeofday(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+
+ /* Copy of our winternl.h structure turned into a private one */
+ typedef struct _SYSTEM_TIMEOFDAY_INFORMATION_PRIVATE {
+ LARGE_INTEGER liKeBootTime;
+ LARGE_INTEGER liKeSystemTime;
+ LARGE_INTEGER liExpTimeZoneBias;
+ ULONG uCurrentTimeZoneId;
+ DWORD dwUnknown1[5];
+ } SYSTEM_TIMEOFDAY_INFORMATION_PRIVATE, *PSYSTEM_TIMEOFDAY_INFORMATION_PRIVATE;
+
+ SYSTEM_TIMEOFDAY_INFORMATION_PRIVATE sti;
+
+ /* The struct size for NT (32 bytes) and Win2K/XP (48 bytes) differ.
+ *
+ * Windows 2000 and XP return STATUS_INFO_LENGTH_MISMATCH if the given buffer size is greater
+ * then 48 and 0 otherwise
+ * Windows NT returns STATUS_INFO_LENGTH_MISMATCH when the given buffer size is not correct
+ * and 0 otherwise
+ *
+ * Windows 2000 and XP copy the given buffer size into the provided buffer, if the return code is STATUS_SUCCESS
+ * NT only fills the buffer if the return code is STATUS_SUCCESS
+ *
+ */
+
+ status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, sizeof(sti), &ReturnLength);
+
+ if (status == STATUS_INFO_LENGTH_MISMATCH)
+ {
+ trace("Windows version is NT, we have to cater for differences with W2K/WinXP\n");
+
+ status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 0, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+ ok( 0 == ReturnLength, "ReturnLength should be 0, it is (%ld)\n", ReturnLength);
+
+ sti.uCurrentTimeZoneId = 0xdeadbeef;
+ status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 28, &ReturnLength);
+ ok( 0xdeadbeef == sti.uCurrentTimeZoneId, "This part of the buffer should not have been filled\n");
+
+ status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 32, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( 32 == ReturnLength, "ReturnLength should be 0, it is (%ld)\n", ReturnLength);
+ }
+ else
+ {
+ status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 0, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( 0 == ReturnLength, "ReturnLength should be 0, it is (%ld)\n", ReturnLength);
+
+ sti.uCurrentTimeZoneId = 0xdeadbeef;
+ status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 24, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( 24 == ReturnLength, "ReturnLength should be 24, it is (%ld)\n", ReturnLength);
+ ok( 0xdeadbeef == sti.uCurrentTimeZoneId, "This part of the buffer should not have been filled\n");
+
+ sti.uCurrentTimeZoneId = 0xdeadbeef;
+ status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 32, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( 32 == ReturnLength, "ReturnLength should be 32, it is (%ld)\n", ReturnLength);
+ ok( 0xdeadbeef != sti.uCurrentTimeZoneId, "Buffer should have been partially filled\n");
+
+ status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 49, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+ ok( 0 == ReturnLength, "ReturnLength should be 0, it is (%ld)\n", ReturnLength);
+
+ status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, sizeof(sti), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(sti) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(sti), ReturnLength);
+ }
+
+ /* Check if we have some return values */
+ trace("uCurrentTimeZoneId : (%ld)\n", sti.uCurrentTimeZoneId);
+}
+
+static void test_query_process(void)
+{
+ DWORD status;
+ DWORD last_pid;
+ ULONG ReturnLength;
+ int i = 0, j = 0, k = 0;
+ int is_nt = 0;
+ SYSTEM_BASIC_INFORMATION sbi;
+
+ /* Copy of our winternl.h structure turned into a private one */
+ typedef struct _SYSTEM_PROCESS_INFORMATION_PRIVATE {
+ DWORD dwOffset;
+ DWORD dwThreadCount;
+ DWORD dwUnknown1[6];
+ FILETIME ftCreationTime;
+ FILETIME ftUserTime;
+ FILETIME ftKernelTime;
+ UNICODE_STRING ProcessName;
+ DWORD dwBasePriority;
+ DWORD dwProcessID;
+ DWORD dwParentProcessID;
+ DWORD dwHandleCount;
+ DWORD dwUnknown3;
+ DWORD dwUnknown4;
+ VM_COUNTERS vmCounters;
+ IO_COUNTERS ioCounters;
+ SYSTEM_THREAD_INFORMATION ti[1];
+ } SYSTEM_PROCESS_INFORMATION_PRIVATE, *PSYSTEM_PROCESS_INFORMATION_PRIVATE;
+
+ ULONG SystemInformationLength = sizeof(SYSTEM_PROCESS_INFORMATION_PRIVATE);
+ SYSTEM_PROCESS_INFORMATION_PRIVATE* spi = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength);
+
+ /* Only W2K3 returns the needed length, the rest returns 0, so we have to loop */
+
+ for (;;)
+ {
+ status = pNtQuerySystemInformation(SystemProcessInformation, spi, SystemInformationLength, &ReturnLength);
+
+ if (status != STATUS_INFO_LENGTH_MISMATCH) break;
+
+ spi = HeapReAlloc(GetProcessHeap(), 0, spi , SystemInformationLength *= 2);
+ }
+
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+
+ /* Get the first dwOffset, from this we can deduce the OS version we're running
+ *
+ * W2K/WinXP/W2K3:
+ * dwOffset for a process is 184 + (no. of threads) * sizeof(SYSTEM_THREAD_INFORMATION)
+ * NT:
+ * dwOffset for a process is 136 + (no. of threads) * sizeof(SYSTEM_THREAD_INFORMATION)
+ * Wine (with every windows version):
+ * dwOffset for a process is 0 if just this test is running
+ * dwOffset for a process is 184 + (no. of threads) * sizeof(SYSTEM_THREAD_INFORMATION) +
+ * ProcessName.MaximumLength
+ * if more wine processes are running
+ *
+ * Note : On windows the first process is in fact the Idle 'process' with a thread for every processor
+ */
+
+ pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), &ReturnLength);
+
+ is_nt = ( spi->dwOffset - (sbi.NumberOfProcessors * sizeof(SYSTEM_THREAD_INFORMATION)) == 136);
+
+ if (is_nt) trace("Windows version is NT, we will skip thread tests\n");
+
+ /* Check if we have some return values
+ *
+ * On windows there will be several processes running (Including the always present Idle and System)
+ * On wine we only have one (if this test is the only wine process running)
+ */
+
+ /* Loop through the processes */
+
+ for (;;)
+ {
+ i++;
+
+ last_pid = spi->dwProcessID;
+
+ ok( spi->dwThreadCount > 0, "Expected some threads for this process, got 0\n");
+
+ /* Loop through the threads, skip NT4 for now */
+
+ if (!is_nt)
+ {
+ for ( j = 0; j < spi->dwThreadCount; j++)
+ {
+ k++;
+ ok ( spi->ti[j].dwOwningPID == spi->dwProcessID,
+ "The owning pid of the thread (%ld) doesn't equal the pid (%ld) of the process\n",
+ spi->ti[j].dwOwningPID, spi->dwProcessID);
+ }
+ }
+
+ if (!spi->dwOffset) break;
+
+ one_before_last_pid = last_pid;
+
+ spi = (SYSTEM_PROCESS_INFORMATION_PRIVATE*)((char*)spi + spi->dwOffset);
+ }
+ trace("Total number of running processes : %d\n", i);
+ if (!is_nt) trace("Total number of running threads : %d\n", k);
+
+ if (one_before_last_pid == 0) one_before_last_pid = last_pid;
+
+ HeapFree( GetProcessHeap(), 0, spi);
+}
+
+static void test_query_procperf(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ ULONG NeededLength;
+ SYSTEM_BASIC_INFORMATION sbi;
+ SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION* sppi;
+
+ /* Find out the number of processors */
+ status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), &ReturnLength);
+ NeededLength = sbi.NumberOfProcessors * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
+
+ sppi = HeapAlloc(GetProcessHeap(), 0, NeededLength);
+
+ status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi, 0, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ /* Try it for 1 processor */
+ status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi,
+ sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) == ReturnLength,
+ "Inconsistent length (%d) <-> (%ld)\n", sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION), ReturnLength);
+
+ /* Try it for all processors */
+ status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi, NeededLength, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( NeededLength == ReturnLength, "Inconsistent length (%ld) <-> (%ld)\n", NeededLength, ReturnLength);
+
+ /* A too large given buffer size */
+ sppi = HeapReAlloc(GetProcessHeap(), 0, sppi , NeededLength + 2);
+ status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi, NeededLength + 2, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( NeededLength == ReturnLength, "Inconsistent length (%ld) <-> (%ld)\n", NeededLength, ReturnLength);
+
+ HeapFree( GetProcessHeap(), 0, sppi);
+}
+
+static void test_query_module(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ DWORD ModuleCount;
+ int i;
+
+ ULONG SystemInformationLength = sizeof(SYSTEM_MODULE_INFORMATION);
+ SYSTEM_MODULE_INFORMATION* smi = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength);
+ SYSTEM_MODULE* sm;
+
+ /* Request the needed length */
+ status = pNtQuerySystemInformation(SystemModuleInformation, smi, 0, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+ ok( ReturnLength > 0, "Expected a ReturnLength to show the needed length\n");
+
+ SystemInformationLength = ReturnLength;
+ smi = HeapReAlloc(GetProcessHeap(), 0, smi , SystemInformationLength);
+ status = pNtQuerySystemInformation(SystemModuleInformation, smi, SystemInformationLength, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+
+ ModuleCount = smi->ModulesCount;
+ sm = &smi->Modules[0];
+ todo_wine{
+ /* our implementation is a stub for now */
+ ok( ModuleCount > 0, "Expected some modules to be loaded\n");
+ }
+
+ /* Loop through all the modules/drivers, Wine doesn't get here (yet) */
+ for (i = 0; i < ModuleCount ; i++)
+ {
+ ok( i == sm->Id, "Id (%d) should have matched %d\n", sm->Id, i);
+ sm++;
+ }
+
+ HeapFree( GetProcessHeap(), 0, smi);
+}
+
+static void test_query_handle(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ ULONG SystemInformationLength = sizeof(SYSTEM_HANDLE_INFORMATION);
+ SYSTEM_HANDLE_INFORMATION* shi = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength);
+
+ /* Request the needed length : a SystemInformationLength greater than one struct sets ReturnLength */
+ status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength);
+
+ /* The following check assumes more than one handle on any given system */
+ todo_wine
+ {
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+ }
+ ok( ReturnLength > 0, "Expected ReturnLength to be > 0, it was %ld\n", ReturnLength);
+
+ SystemInformationLength = ReturnLength;
+ shi = HeapReAlloc(GetProcessHeap(), 0, shi , SystemInformationLength);
+ status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+
+ /* Check if we have some return values */
+ trace("Number of Handles : %ld\n", shi->Count);
+ todo_wine
+ {
+ /* our implementation is a stub for now */
+ ok( shi->Count > 1, "Expected more than 1 handles, got (%ld)\n", shi->Count);
+ }
+
+ HeapFree( GetProcessHeap(), 0, shi);
+}
+
+static void test_query_cache(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ SYSTEM_CACHE_INFORMATION sci;
+
+ status = pNtQuerySystemInformation(SystemCacheInformation, &sci, 0, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ status = pNtQuerySystemInformation(SystemCacheInformation, &sci, sizeof(sci), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(sci) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(sci), ReturnLength);
+
+ status = pNtQuerySystemInformation(SystemCacheInformation, &sci, sizeof(sci) + 2, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(sci) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(sci), ReturnLength);
+}
+
+static void test_query_interrupt(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ ULONG NeededLength;
+ SYSTEM_BASIC_INFORMATION sbi;
+ SYSTEM_INTERRUPT_INFORMATION* sii;
+
+ /* Find out the number of processors */
+ status = pNtQuerySystemInformation(SystemBasicInformation, &sbi, sizeof(sbi), &ReturnLength);
+ NeededLength = sbi.NumberOfProcessors * sizeof(SYSTEM_INTERRUPT_INFORMATION);
+
+ sii = HeapAlloc(GetProcessHeap(), 0, NeededLength);
+
+ status = pNtQuerySystemInformation(SystemInterruptInformation, sii, 0, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ /* Try it for all processors */
+ status = pNtQuerySystemInformation(SystemInterruptInformation, sii, NeededLength, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+
+ /* Windows XP and W2K3 (and others?) always return 0 for the ReturnLength
+ * No test added for this as it's highly unlikely that an app depends on this
+ */
+
+ HeapFree( GetProcessHeap(), 0, sii);
+}
+
+static void test_query_kerndebug(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ SYSTEM_KERNEL_DEBUGGER_INFORMATION skdi;
+
+ status = pNtQuerySystemInformation(SystemKernelDebuggerInformation, &skdi, 0, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ status = pNtQuerySystemInformation(SystemKernelDebuggerInformation, &skdi, sizeof(skdi), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(skdi) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(skdi), ReturnLength);
+
+ status = pNtQuerySystemInformation(SystemKernelDebuggerInformation, &skdi, sizeof(skdi) + 2, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(skdi) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(skdi), ReturnLength);
+}
+
+static void test_query_regquota(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ SYSTEM_REGISTRY_QUOTA_INFORMATION srqi;
+
+ status = pNtQuerySystemInformation(SystemRegistryQuotaInformation, &srqi, 0, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ status = pNtQuerySystemInformation(SystemRegistryQuotaInformation, &srqi, sizeof(srqi), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(srqi) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(srqi), ReturnLength);
+
+ status = pNtQuerySystemInformation(SystemRegistryQuotaInformation, &srqi, sizeof(srqi) + 2, &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(srqi) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(srqi), ReturnLength);
+}
+
+static void test_query_process_basic(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+
+ typedef struct _PROCESS_BASIC_INFORMATION_PRIVATE {
+ DWORD ExitStatus;
+ DWORD PebBaseAddress;
+ DWORD AffinityMask;
+ DWORD BasePriority;
+ ULONG UniqueProcessId;
+ ULONG InheritedFromUniqueProcessId;
+ } PROCESS_BASIC_INFORMATION_PRIVATE, *PPROCESS_BASIC_INFORMATION_PRIVATE;
+
+ PROCESS_BASIC_INFORMATION_PRIVATE pbi;
+
+ /* This test also covers some basic parameter testing that should be the same for
+ * every information class
+ */
+
+ /* Use a nonexistent info class */
+ trace("Check nonexistent info class\n");
+ status = pNtQueryInformationProcess(NULL, -1, NULL, 0, NULL);
+ ok( status == STATUS_INVALID_INFO_CLASS, "Expected STATUS_INVALID_INFO_CLASS, got %08lx\n", status);
+
+ /* Do not give a handle and buffer */
+ trace("Check NULL handle and buffer and zero-length buffersize\n");
+ status = pNtQueryInformationProcess(NULL, ProcessBasicInformation, NULL, 0, NULL);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ /* Use a correct info class and buffer size, but still no handle and buffer */
+ trace("Check NULL handle and buffer\n");
+ status = pNtQueryInformationProcess(NULL, ProcessBasicInformation, NULL, sizeof(pbi), NULL);
+ ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
+ "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08lx\n", status);
+
+ /* Use a correct info class and buffer size, but still no handle */
+ trace("Check NULL handle\n");
+ status = pNtQueryInformationProcess(NULL, ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
+ ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08lx\n", status);
+
+ /* Use a greater buffer size */
+ trace("Check NULL handle and too large buffersize\n");
+ status = pNtQueryInformationProcess(NULL, ProcessBasicInformation, &pbi, sizeof(pbi) * 2, NULL);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ /* Use no ReturnLength */
+ trace("Check NULL ReturnLength\n");
+ status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+
+ /* Finally some correct calls */
+ trace("Check with correct parameters\n");
+ status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(pbi) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(pbi), ReturnLength);
+
+ /* Everything is correct except a too large buffersize */
+ trace("Too large buffersize\n");
+ status = pNtQueryInformationProcess(GetCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi) * 2, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+ ok( sizeof(pbi) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(pbi), ReturnLength);
+
+ /* Check if we have some return values */
+ trace("ProcessID : %ld\n", pbi.UniqueProcessId);
+ ok( pbi.UniqueProcessId > 0, "Expected a ProcessID > 0, got 0\n");
+}
+
+static void test_query_process_vm(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ VM_COUNTERS pvi;
+
+ status = pNtQueryInformationProcess(NULL, ProcessVmCounters, NULL, sizeof(pvi), NULL);
+ ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
+ "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08lx\n", status);
+
+ status = pNtQueryInformationProcess(NULL, ProcessVmCounters, &pvi, sizeof(pvi), NULL);
+ ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08lx\n", status);
+
+ /* Windows XP and W2K3 will report success for a size of 44 AND 48 !
+ Windows W2K will only report success for 44.
+ For now we only care for 44, which is sizeof(VM_COUNTERS)
+ If an app depends on it, we have to implement this in ntdll/process.c
+ */
+
+ status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters, &pvi, 24, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters, &pvi, sizeof(pvi), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(pvi) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(pvi), ReturnLength);
+
+ status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters, &pvi, 46, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+ ok( sizeof(pvi) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(pvi), ReturnLength);
+
+ /* Check if we have some return values */
+ trace("WorkingSetSize : %ld\n", pvi.WorkingSetSize);
+ todo_wine
+ {
+ ok( pvi.WorkingSetSize > 0, "Expected a WorkingSetSize > 0\n");
+ }
+}
+
+static void test_query_process_io(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ IO_COUNTERS pii;
+
+ /* NT4 doesn't support this information class, so check for it */
+ status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessIoCounters, &pii, sizeof(pii), &ReturnLength);
+ if (status == STATUS_NOT_SUPPORTED)
+ {
+ trace("ProcessIoCounters information class not supported, skipping tests\n");
+ return;
+ }
+
+ status = pNtQueryInformationProcess(NULL, ProcessIoCounters, NULL, sizeof(pii), NULL);
+ ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
+ "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08lx\n", status);
+
+ status = pNtQueryInformationProcess(NULL, ProcessIoCounters, &pii, sizeof(pii), NULL);
+ ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08lx\n", status);
+
+ status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessIoCounters, &pii, 24, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessIoCounters, &pii, sizeof(pii), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(pii) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(pii), ReturnLength);
+
+ status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessIoCounters, &pii, sizeof(pii) * 2, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+ ok( sizeof(pii) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(pii), ReturnLength);
+
+ /* Check if we have some return values */
+ trace("OtherOperationCount : %lld\n", pii.OtherOperationCount);
+ todo_wine
+ {
+ ok( pii.OtherOperationCount > 0, "Expected an OtherOperationCount > 0\n");
+ }
+}
+
+static void test_query_process_times(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ HANDLE process;
+ SYSTEMTIME UTC, Local;
+ KERNEL_USER_TIMES spti;
+
+ status = pNtQueryInformationProcess(NULL, ProcessTimes, NULL, sizeof(spti), NULL);
+ ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
+ "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08lx\n", status);
+
+ status = pNtQueryInformationProcess(NULL, ProcessTimes, &spti, sizeof(spti), NULL);
+ ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08lx\n", status);
+
+ status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessTimes, &spti, 24, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ process = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, one_before_last_pid);
+ if (!process)
+ {
+ trace("Could not open process with ID : %ld, error : %08lx. Going to use current one.\n", one_before_last_pid, GetLastError());
+ process = GetCurrentProcess();
+ trace("ProcessTimes for current process\n");
+ }
+ else
+ trace("ProcessTimes for process with ID : %ld\n", one_before_last_pid);
+
+ status = pNtQueryInformationProcess( process, ProcessTimes, &spti, sizeof(spti), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(spti) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(spti), ReturnLength);
+ CloseHandle(process);
+
+ FileTimeToSystemTime((const FILETIME *)&spti.CreateTime, &UTC);
+ SystemTimeToTzSpecificLocalTime(NULL, &UTC, &Local);
+ trace("CreateTime : %02d/%02d/%04d %02d:%02d:%02d\n", Local.wMonth, Local.wDay, Local.wYear,
+ Local.wHour, Local.wMinute, Local.wSecond);
+
+ FileTimeToSystemTime((const FILETIME *)&spti.ExitTime, &UTC);
+ SystemTimeToTzSpecificLocalTime(NULL, &UTC, &Local);
+ trace("ExitTime : %02d/%02d/%04d %02d:%02d:%02d\n", Local.wMonth, Local.wDay, Local.wYear,
+ Local.wHour, Local.wMinute, Local.wSecond);
+
+ FileTimeToSystemTime((const FILETIME *)&spti.KernelTime, &Local);
+ trace("KernelTime : %02d:%02d:%02d.%03d\n", Local.wHour, Local.wMinute, Local.wSecond, Local.wMilliseconds);
+
+ FileTimeToSystemTime((const FILETIME *)&spti.UserTime, &Local);
+ trace("UserTime : %02d:%02d:%02d.%03d\n", Local.wHour, Local.wMinute, Local.wSecond, Local.wMilliseconds);
+
+ status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessTimes, &spti, sizeof(spti) * 2, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+ ok( sizeof(spti) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(spti), ReturnLength);
+}
+
+static void test_query_process_handlecount(void)
+{
+ DWORD status;
+ ULONG ReturnLength;
+ DWORD handlecount;
+ HANDLE process;
+
+ status = pNtQueryInformationProcess(NULL, ProcessHandleCount, NULL, sizeof(handlecount), NULL);
+ ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
+ "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_HANDLE(W2K3), got %08lx\n", status);
+
+ status = pNtQueryInformationProcess(NULL, ProcessHandleCount, &handlecount, sizeof(handlecount), NULL);
+ ok( status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %08lx\n", status);
+
+ status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessHandleCount, &handlecount, 2, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+
+ process = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, one_before_last_pid);
+ trace("Handlecount for process with ID : %ld\n", one_before_last_pid);
+ status = pNtQueryInformationProcess( process, ProcessHandleCount, &handlecount, sizeof(handlecount), &ReturnLength);
+ ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08lx\n", status);
+ ok( sizeof(handlecount) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(handlecount), ReturnLength);
+ CloseHandle(process);
+
+ status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessHandleCount, &handlecount, sizeof(handlecount) * 2, &ReturnLength);
+ ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status);
+ ok( sizeof(handlecount) == ReturnLength, "Inconsistent length (%d) <-> (%ld)\n", sizeof(handlecount), ReturnLength);
+
+ /* Check if we have some return values */
+ trace("HandleCount : %ld\n", handlecount);
+ todo_wine
+ {
+ ok( handlecount > 0, "Expected some handles, got 0\n");
+ }
+}
+
+START_TEST(info)
+{
+ if(!InitFunctionPtrs())
+ return;
+
+ /* NtQuerySystemInformation */
+
+ /* 0x0 SystemBasicInformation */
+ trace("Starting test_query_basic()\n");
+ test_query_basic();
+
+ /* 0x1 SystemCpuInformation */
+ trace("Starting test_query_cpu()\n");
+ test_query_cpu();
+
+ /* 0x2 SystemPerformanceInformation */
+ trace("Starting test_query_performance()\n");
+ test_query_performance();
+
+ /* 0x3 SystemTimeOfDayInformation */
+ trace("Starting test_query_timeofday()\n");
+ test_query_timeofday();
+
+ /* 0x5 SystemProcessInformation */
+ trace("Starting test_query_process()\n");
+ test_query_process();
+
+ /* 0x8 SystemProcessorPerformanceInformation */
+ trace("Starting test_query_procperf()\n");
+ test_query_procperf();
+
+ /* 0xb SystemModuleInformation */
+ trace("Starting test_query_module()\n");
+ test_query_module();
+
+ /* 0x10 SystemHandleInformation */
+ trace("Starting test_query_handle()\n");
+ test_query_handle();
+
+ /* 0x15 SystemCacheInformation */
+ trace("Starting test_query_cache()\n");
+ test_query_cache();
+
+ /* 0x17 SystemInterruptInformation */
+ trace("Starting test_query_interrupt()\n");
+ test_query_interrupt();
+
+ /* 0x23 SystemKernelDebuggerInformation */
+ trace("Starting test_query_kerndebug()\n");
+ test_query_kerndebug();
+
+ /* 0x25 SystemRegistryQuotaInformation */
+ trace("Starting test_query_regquota()\n");
+ test_query_regquota();
+
+ /* NtQueryInformationProcess */
+
+ /* 0x0 ProcessBasicInformation */
+ trace("Starting test_query_process_basic()\n");
+ test_query_process_basic();
+
+ /* 0x2 ProcessIoCounters */
+ trace("Starting test_query_process_io()\n");
+ test_query_process_io();
+
+ /* 0x3 ProcessVmCounters */
+ trace("Starting test_query_process_vm()\n");
+ test_query_process_vm();
+
+ /* 0x4 ProcessTimes */
+ trace("Starting test_query_process_times()\n");
+ test_query_process_times();
+
+ /* 0x14 ProcessHandleCount */
+ trace("Starting test_query_process_handlecount()\n");
+ test_query_process_handlecount();
+
+ FreeLibrary(hntdll);
+}
--- /dev/null
+/* Unit test suite for Rtl large integer 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 "ntdll_test.h"
+
+
+/* Function ptrs for ntdll calls */
+static HMODULE hntdll = 0;
+static LONGLONG (WINAPI *pRtlExtendedMagicDivide)(LONGLONG, LONGLONG, INT);
+static VOID (WINAPI *pRtlFreeAnsiString)(PSTRING);
+static NTSTATUS (WINAPI *pRtlInt64ToUnicodeString)(ULONGLONG, ULONG, UNICODE_STRING *);
+static NTSTATUS (WINAPI *pRtlLargeIntegerToChar)(ULONGLONG *, ULONG, ULONG, PCHAR);
+static NTSTATUS (WINAPI *pRtlUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN);
+
+
+static void InitFunctionPtrs(void)
+{
+ hntdll = LoadLibraryA("ntdll.dll");
+ ok(hntdll != 0, "LoadLibrary failed\n");
+ if (hntdll) {
+ pRtlExtendedMagicDivide = (void *)GetProcAddress(hntdll, "RtlExtendedMagicDivide");
+ pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString");
+ pRtlInt64ToUnicodeString = (void *)GetProcAddress(hntdll, "RtlInt64ToUnicodeString");
+ pRtlLargeIntegerToChar = (void *)GetProcAddress(hntdll, "RtlLargeIntegerToChar");
+ pRtlUnicodeStringToAnsiString = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToAnsiString");
+ } /* if */
+}
+
+#define ULL(a,b) (((ULONGLONG)(a) << 32) | (b))
+
+typedef struct {
+ LONGLONG a;
+ LONGLONG b;
+ INT shift;
+ LONGLONG result;
+} magic_divide_t;
+
+static const magic_divide_t magic_divide[] = {
+ { 3, ULL(0x55555555,0x55555555), 0, 0}, /* 1 */
+ { 333333333, ULL(0x55555555,0x55555555), 0, 111111110}, /* 111111111 */
+ { ULL(0x7fffffff,0xffffffff), ULL(0x55555555,0x55555555), 0, ULL(0x2aaaaaaa,0xaaaaaaaa)},
+ { 3, ULL(0xaaaaaaaa,0xaaaaaaaa), 1, 0}, /* 1 */
+ { 333333333, ULL(0xaaaaaaaa,0xaaaaaaaa), 1, 111111110}, /* 111111111 */
+ { ULL(0x7fffffff,0xffffffff), ULL(0xaaaaaaaa,0xaaaaaaaa), 1, ULL(0x2aaaaaaa,0xaaaaaaaa)},
+ { -3, ULL(0x55555555,0x55555555), 0, 0}, /* -1 */
+ { -333333333, ULL(0x55555555,0x55555555), 0, -111111110}, /* -111111111 */
+ {-ULL(0x7fffffff,0xffffffff), ULL(0x55555555,0x55555555), 0, -ULL(0x2aaaaaaa,0xaaaaaaaa)},
+ { -3, ULL(0xaaaaaaaa,0xaaaaaaaa), 1, 0}, /* -1 */
+ { -333333333, ULL(0xaaaaaaaa,0xaaaaaaaa), 1, -111111110}, /* -111111111 */
+ {-ULL(0x7fffffff,0xffffffff), ULL(0xaaaaaaaa,0xaaaaaaaa), 1, -ULL(0x2aaaaaaa,0xaaaaaaaa)},
+ { -3, -ULL(0x55555555,0x55555555), 0, -2}, /* -1 */
+ { -333333333, -ULL(0x55555555,0x55555555), 0, -222222222}, /* -111111111 */
+ {-ULL(0x7fffffff,0xffffffff), -ULL(0x55555555,0x55555555), 0, -ULL(0x55555555,0x55555554)},
+ { -3, -ULL(0xaaaaaaaa,0xaaaaaaaa), 1, 0}, /* -1 */
+ { -333333333, -ULL(0xaaaaaaaa,0xaaaaaaaa), 1, -55555555}, /* -111111111 */
+ {-ULL(0x7fffffff,0xffffffff), -ULL(0xaaaaaaaa,0xaaaaaaaa), 1, -ULL(0x15555555,0x55555555)},
+ { 3, -ULL(0x55555555,0x55555555), 0, 2}, /* -1 */
+ { 333333333, -ULL(0x55555555,0x55555555), 0, 222222222}, /* -111111111 */
+ { ULL(0x7fffffff,0xffffffff), -ULL(0x55555555,0x55555555), 0, ULL(0x55555555,0x55555554)},
+ { 3, -ULL(0xaaaaaaaa,0xaaaaaaaa), 1, 0}, /* -1 */
+ { 333333333, -ULL(0xaaaaaaaa,0xaaaaaaaa), 1, 55555555}, /* -111111111 */
+ { ULL(0x7fffffff,0xffffffff), -ULL(0xaaaaaaaa,0xaaaaaaaa), 1, ULL(0x15555555,0x55555555)},
+ { 3, ULL(0xaaaaaaaa,0xaaaaa800), 1, 0}, /* 1 */
+ { 333333333, ULL(0xaaaaaaaa,0xaaaaa800), 1, 111111110}, /* 111111111 */
+ { ULL(0x7fffffff,0xffffffff), ULL(0xaaaaaaaa,0xaaaaa800), 1, ULL(0x2aaaaaaa,0xaaaaa9ff)}, /* 0x2aaaaaaaaaaaaaaa */
+ { 5, ULL(0x33333333,0x333333ff), 0, 1},
+ { 555555555, ULL(0x33333333,0x333333ff), 0, 111111111},
+ { ULL(0x7fffffff,0xffffffff), ULL(0x33333333,0x333333ff), 0, ULL(0x19999999,0x999999ff)}, /* 0x199999999999999a */
+ { 5, ULL(0x66666666,0x666667fe), 1, 1},
+ { 555555555, ULL(0x66666666,0x666667fe), 1, 111111111},
+ { ULL(0x7fffffff,0xffffffff), ULL(0x66666666,0x666667fe), 1, ULL(0x19999999,0x999999ff)}, /* 0x199999999999999a */
+ { 5, ULL(0xcccccccc,0xcccccffd), 2, 1},
+ { 555555555, ULL(0xcccccccc,0xcccccffd), 2, 111111111},
+ { ULL(0x7fffffff,0xffffffff), ULL(0xcccccccc,0xcccccffd), 2, ULL(0x19999999,0x999999ff)}, /* 0x199999999999999a */
+ { ULL(0x00000add,0xcafeface), ULL(0x002f1e28,0xfd1b5cca), 33, 1},
+ { ULL(0x081ac1b9,0xc2310a80), ULL(0x002f1e28,0xfd1b5cca), 33, 0xbeef},
+ { ULL(0x74ae3b5f,0x1558c800), ULL(0x002f1e28,0xfd1b5cca), 33, 0xabcde},
+ { ULL(0x00000add,0xcafeface), ULL(0x2f1e28fd,0x1b5cca00), 41, 1},
+ { ULL(0x081ac1b9,0xc2310a80), ULL(0x2f1e28fd,0x1b5cca00), 41, 0xbeef},
+ { ULL(0x74ae3b5f,0x1558c800), ULL(0x2f1e28fd,0x1b5cca00), 41, 0xabcde},
+
+};
+#define NB_MAGIC_DIVIDE (sizeof(magic_divide)/sizeof(*magic_divide))
+
+
+static void test_RtlExtendedMagicDivide(void)
+{
+ int i;
+ LONGLONG result;
+
+ for (i = 0; i < NB_MAGIC_DIVIDE; i++) {
+ result = pRtlExtendedMagicDivide(magic_divide[i].a, magic_divide[i].b, magic_divide[i].shift);
+ ok(result == magic_divide[i].result,
+ "call failed: RtlExtendedMagicDivide(%lld, %llu, %d) has result %llx, expected %llx\n",
+ magic_divide[i].a, magic_divide[i].b, magic_divide[i].shift, result, magic_divide[i].result);
+ }
+}
+
+
+#define LARGE_STRI_BUFFER_LENGTH 67
+
+typedef struct {
+ int base;
+ ULONGLONG value;
+ USHORT Length;
+ USHORT MaximumLength;
+ const char *Buffer;
+ NTSTATUS result;
+} largeint2str_t;
+
+/*
+ * The native DLL does produce garbage or STATUS_BUFFER_OVERFLOW for
+ * base 2, 8 and 16 when the value is larger than 0xFFFFFFFF.
+ * Therefore these testcases are commented out.
+ */
+
+static const largeint2str_t largeint2str[] = {
+ {10, 123, 3, 11, "123\0---------------------------------------------------------------", STATUS_SUCCESS},
+
+ { 0, 0x80000000U, 10, 11, "2147483648\0--------------------------------------------------------", STATUS_SUCCESS},
+ { 0, -2147483647, 20, 21, "18446744071562067969\0----------------------------------------------", STATUS_SUCCESS},
+ { 0, -2, 20, 21, "18446744073709551614\0----------------------------------------------", STATUS_SUCCESS},
+ { 0, -1, 20, 21, "18446744073709551615\0----------------------------------------------", STATUS_SUCCESS},
+ { 0, 0, 1, 11, "0\0-----------------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 1, 1, 11, "1\0-----------------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 12, 2, 11, "12\0----------------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 123, 3, 11, "123\0---------------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 1234, 4, 11, "1234\0--------------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 12345, 5, 11, "12345\0-------------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 123456, 6, 11, "123456\0------------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 1234567, 7, 11, "1234567\0-----------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 12345678, 8, 11, "12345678\0----------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 123456789, 9, 11, "123456789\0---------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 2147483646, 10, 11, "2147483646\0--------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 2147483647, 10, 11, "2147483647\0--------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 2147483648U, 10, 11, "2147483648\0--------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 2147483649U, 10, 11, "2147483649\0--------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 4294967294U, 10, 11, "4294967294\0--------------------------------------------------------", STATUS_SUCCESS},
+ { 0, 4294967295U, 10, 11, "4294967295\0--------------------------------------------------------", STATUS_SUCCESS},
+ { 0, ULL(0x2,0xdfdc1c35), 11, 12, "12345678901\0-------------------------------------------------------", STATUS_SUCCESS},
+ { 0, ULL(0xe5,0xf4c8f374), 12, 13, "987654321012\0------------------------------------------------------", STATUS_SUCCESS},
+ { 0, ULL(0x1c0,0xfc161e3e), 13, 14, "1928374656574\0-----------------------------------------------------", STATUS_SUCCESS},
+ { 0, ULL(0xbad,0xcafeface), 14, 15, "12841062955726\0----------------------------------------------------", STATUS_SUCCESS},
+ { 0, ULL(0x5bad,0xcafeface), 15, 16, "100801993177806\0---------------------------------------------------", STATUS_SUCCESS},
+ { 0, ULL(0xaface,0xbeefcafe), 16, 20, "3090515640699646\0--------------------------------------------------", STATUS_SUCCESS},
+ { 0, ULL(0xa5beef,0xabcdcafe), 17, 20, "46653307746110206\0-------------------------------------------------", STATUS_SUCCESS},
+ { 0, ULL(0x1f8cf9b,0xf2df3af1), 18, 20, "142091656963767025\0------------------------------------------------", STATUS_SUCCESS},
+ { 0, ULL(0x0fffffff,0xffffffff), 19, 20, "1152921504606846975\0-----------------------------------------------", STATUS_SUCCESS},
+ { 0, ULL(0xffffffff,0xfffffffe), 20, 21, "18446744073709551614\0----------------------------------------------", STATUS_SUCCESS},
+ { 0, ULL(0xffffffff,0xffffffff), 20, 21, "18446744073709551615\0----------------------------------------------", STATUS_SUCCESS},
+
+ { 2, 0x80000000U, 32, 33, "10000000000000000000000000000000\0----------------------------------", STATUS_SUCCESS},
+/*
+ * { 2, -2147483647, 64, 65, "1111111111111111111111111111111110000000000000000000000000000001\0--", STATUS_SUCCESS},
+ * { 2, -2, 64, 65, "1111111111111111111111111111111111111111111111111111111111111110\0--", STATUS_SUCCESS},
+ * { 2, -1, 64, 65, "1111111111111111111111111111111111111111111111111111111111111111\0--", STATUS_SUCCESS},
+ */
+ { 2, 0, 1, 33, "0\0-----------------------------------------------------------------", STATUS_SUCCESS},
+ { 2, 1, 1, 33, "1\0-----------------------------------------------------------------", STATUS_SUCCESS},
+ { 2, 10, 4, 33, "1010\0--------------------------------------------------------------", STATUS_SUCCESS},
+ { 2, 100, 7, 33, "1100100\0-----------------------------------------------------------", STATUS_SUCCESS},
+ { 2, 1000, 10, 33, "1111101000\0--------------------------------------------------------", STATUS_SUCCESS},
+ { 2, 10000, 14, 33, "10011100010000\0----------------------------------------------------", STATUS_SUCCESS},
+ { 2, 32767, 15, 33, "111111111111111\0---------------------------------------------------", STATUS_SUCCESS},
+ { 2, 32768, 16, 33, "1000000000000000\0--------------------------------------------------", STATUS_SUCCESS},
+ { 2, 65535, 16, 33, "1111111111111111\0--------------------------------------------------", STATUS_SUCCESS},
+ { 2, 100000, 17, 33, "11000011010100000\0-------------------------------------------------", STATUS_SUCCESS},
+ { 2, 1000000, 20, 33, "11110100001001000000\0----------------------------------------------", STATUS_SUCCESS},
+ { 2, 10000000, 24, 33, "100110001001011010000000\0------------------------------------------", STATUS_SUCCESS},
+ { 2, 100000000, 27, 33, "101111101011110000100000000\0---------------------------------------", STATUS_SUCCESS},
+ { 2, 1000000000, 30, 33, "111011100110101100101000000000\0------------------------------------", STATUS_SUCCESS},
+ { 2, 1073741823, 30, 33, "111111111111111111111111111111\0------------------------------------", STATUS_SUCCESS},
+ { 2, 2147483646, 31, 33, "1111111111111111111111111111110\0-----------------------------------", STATUS_SUCCESS},
+ { 2, 2147483647, 31, 33, "1111111111111111111111111111111\0-----------------------------------", STATUS_SUCCESS},
+ { 2, 2147483648U, 32, 33, "10000000000000000000000000000000\0----------------------------------", STATUS_SUCCESS},
+ { 2, 2147483649U, 32, 33, "10000000000000000000000000000001\0----------------------------------", STATUS_SUCCESS},
+ { 2, 4294967294U, 32, 33, "11111111111111111111111111111110\0----------------------------------", STATUS_SUCCESS},
+ { 2, 0xFFFFFFFF, 32, 33, "11111111111111111111111111111111\0----------------------------------", STATUS_SUCCESS},
+/*
+ * { 2, 0x1FFFFFFFF, 33, 34, "111111111111111111111111111111111\0---------------------------------", STATUS_SUCCESS},
+ * { 2, 0x3FFFFFFFF, 34, 35, "1111111111111111111111111111111111\0--------------------------------", STATUS_SUCCESS},
+ * { 2, 0x7FFFFFFFF, 35, 36, "11111111111111111111111111111111111\0-------------------------------", STATUS_SUCCESS},
+ * { 2, 0xFFFFFFFFF, 36, 37, "111111111111111111111111111111111111\0------------------------------", STATUS_SUCCESS},
+ * { 2, 0x1FFFFFFFFF, 37, 38, "1111111111111111111111111111111111111\0-----------------------------", STATUS_SUCCESS},
+ * { 2, 0x3FFFFFFFFF, 38, 39, "11111111111111111111111111111111111111\0----------------------------", STATUS_SUCCESS},
+ * { 2, 0x7FFFFFFFFF, 39, 40, "111111111111111111111111111111111111111\0---------------------------", STATUS_SUCCESS},
+ * { 2, 0xFFFFFFFFFF, 40, 41, "1111111111111111111111111111111111111111\0--------------------------", STATUS_SUCCESS},
+ */
+
+ { 8, 0x80000000U, 11, 12, "20000000000\0-------------------------------------------------------", STATUS_SUCCESS},
+/*
+ * { 8, -2147483647, 22, 23, "1777777777760000000001\0--------------------------------------------", STATUS_SUCCESS},
+ * { 8, -2, 22, 23, "1777777777777777777776\0--------------------------------------------", STATUS_SUCCESS},
+ * { 8, -1, 22, 23, "1777777777777777777777\0--------------------------------------------", STATUS_SUCCESS},
+ */
+ { 8, 0, 1, 12, "0\0-----------------------------------------------------------------", STATUS_SUCCESS},
+ { 8, 1, 1, 12, "1\0-----------------------------------------------------------------", STATUS_SUCCESS},
+ { 8, 2147483646, 11, 12, "17777777776\0-------------------------------------------------------", STATUS_SUCCESS},
+ { 8, 2147483647, 11, 12, "17777777777\0-------------------------------------------------------", STATUS_SUCCESS},
+ { 8, 2147483648U, 11, 12, "20000000000\0-------------------------------------------------------", STATUS_SUCCESS},
+ { 8, 2147483649U, 11, 12, "20000000001\0-------------------------------------------------------", STATUS_SUCCESS},
+ { 8, 4294967294U, 11, 12, "37777777776\0-------------------------------------------------------", STATUS_SUCCESS},
+ { 8, 4294967295U, 11, 12, "37777777777\0-------------------------------------------------------", STATUS_SUCCESS},
+
+ {10, 0x80000000U, 10, 11, "2147483648\0--------------------------------------------------------", STATUS_SUCCESS},
+ {10, -2147483647, 20, 21, "18446744071562067969\0----------------------------------------------", STATUS_SUCCESS},
+ {10, -2, 20, 21, "18446744073709551614\0----------------------------------------------", STATUS_SUCCESS},
+ {10, -1, 20, 21, "18446744073709551615\0----------------------------------------------", STATUS_SUCCESS},
+ {10, 0, 1, 11, "0\0-----------------------------------------------------------------", STATUS_SUCCESS},
+ {10, 1, 1, 11, "1\0-----------------------------------------------------------------", STATUS_SUCCESS},
+ {10, 2147483646, 10, 11, "2147483646\0--------------------------------------------------------", STATUS_SUCCESS},
+ {10, 2147483647, 10, 11, "2147483647\0--------------------------------------------------------", STATUS_SUCCESS},
+ {10, 2147483648U, 10, 11, "2147483648\0--------------------------------------------------------", STATUS_SUCCESS},
+ {10, 2147483649U, 10, 11, "2147483649\0--------------------------------------------------------", STATUS_SUCCESS},
+ {10, 4294967294U, 10, 11, "4294967294\0--------------------------------------------------------", STATUS_SUCCESS},
+ {10, 4294967295U, 10, 11, "4294967295\0--------------------------------------------------------", STATUS_SUCCESS},
+
+ {16, 0, 1, 9, "0\0-----------------------------------------------------------------", STATUS_SUCCESS},
+ {16, 1, 1, 9, "1\0-----------------------------------------------------------------", STATUS_SUCCESS},
+ {16, 2147483646, 8, 9, "7FFFFFFE\0----------------------------------------------------------", STATUS_SUCCESS},
+ {16, 2147483647, 8, 9, "7FFFFFFF\0----------------------------------------------------------", STATUS_SUCCESS},
+ {16, 0x80000000, 8, 9, "80000000\0----------------------------------------------------------", STATUS_SUCCESS},
+ {16, 0x80000001, 8, 9, "80000001\0----------------------------------------------------------", STATUS_SUCCESS},
+ {16, 0xFFFFFFFE, 8, 9, "FFFFFFFE\0----------------------------------------------------------", STATUS_SUCCESS},
+ {16, 0xFFFFFFFF, 8, 9, "FFFFFFFF\0----------------------------------------------------------", STATUS_SUCCESS},
+/*
+ * {16, 0x100000000, 9, 10, "100000000\0---------------------------------------------------------", STATUS_SUCCESS},
+ * {16, 0xBADDEADBEEF, 11, 12, "BADDEADBEEF\0-------------------------------------------------------", STATUS_SUCCESS},
+ * {16, 0x8000000000000000, 16, 17, "8000000000000000\0--------------------------------------------------", STATUS_SUCCESS},
+ * {16, 0xFEDCBA9876543210, 16, 17, "FEDCBA9876543210\0--------------------------------------------------", STATUS_SUCCESS},
+ * {16, 0xFFFFFFFF80000001, 16, 17, "FFFFFFFF80000001\0--------------------------------------------------", STATUS_SUCCESS},
+ * {16, 0xFFFFFFFFFFFFFFFE, 16, 17, "FFFFFFFFFFFFFFFE\0--------------------------------------------------", STATUS_SUCCESS},
+ * {16, 0xFFFFFFFFFFFFFFFF, 16, 17, "FFFFFFFFFFFFFFFF\0--------------------------------------------------", STATUS_SUCCESS},
+ */
+
+ { 2, 32768, 16, 17, "1000000000000000\0--------------------------------------------------", STATUS_SUCCESS},
+ { 2, 32768, 16, 16, "1000000000000000---------------------------------------------------", STATUS_SUCCESS},
+ { 2, 65536, 17, 18, "10000000000000000\0-------------------------------------------------", STATUS_SUCCESS},
+ { 2, 65536, 17, 17, "10000000000000000--------------------------------------------------", STATUS_SUCCESS},
+ { 2, 131072, 18, 19, "100000000000000000\0------------------------------------------------", STATUS_SUCCESS},
+ { 2, 131072, 18, 18, "100000000000000000-------------------------------------------------", STATUS_SUCCESS},
+ {16, 0xffffffff, 8, 9, "FFFFFFFF\0----------------------------------------------------------", STATUS_SUCCESS},
+ {16, 0xffffffff, 8, 8, "FFFFFFFF-----------------------------------------------------------", STATUS_SUCCESS},
+ {16, 0xffffffff, 8, 7, "-------------------------------------------------------------------", STATUS_BUFFER_OVERFLOW},
+ {16, 0xa, 1, 2, "A\0-----------------------------------------------------------------", STATUS_SUCCESS},
+ {16, 0xa, 1, 1, "A------------------------------------------------------------------", STATUS_SUCCESS},
+ {16, 0, 1, 0, "-------------------------------------------------------------------", STATUS_BUFFER_OVERFLOW},
+ {20, 0xdeadbeef, 0, 9, "-------------------------------------------------------------------", STATUS_INVALID_PARAMETER},
+ {-8, 07654321, 0, 12, "-------------------------------------------------------------------", STATUS_INVALID_PARAMETER},
+};
+#define NB_LARGEINT2STR (sizeof(largeint2str)/sizeof(*largeint2str))
+
+
+static void one_RtlInt64ToUnicodeString_test(int test_num, const largeint2str_t *largeint2str)
+{
+ int pos;
+ WCHAR expected_str_Buffer[LARGE_STRI_BUFFER_LENGTH + 1];
+ UNICODE_STRING expected_unicode_string;
+ STRING expected_ansi_str;
+ WCHAR str_Buffer[LARGE_STRI_BUFFER_LENGTH + 1];
+ UNICODE_STRING unicode_string;
+ STRING ansi_str;
+ NTSTATUS result;
+
+ for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
+ expected_str_Buffer[pos] = largeint2str->Buffer[pos];
+ } /* for */
+ expected_unicode_string.Length = largeint2str->Length * sizeof(WCHAR);
+ expected_unicode_string.MaximumLength = largeint2str->MaximumLength * sizeof(WCHAR);
+ expected_unicode_string.Buffer = expected_str_Buffer;
+ pRtlUnicodeStringToAnsiString(&expected_ansi_str, &expected_unicode_string, 1);
+
+ for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
+ str_Buffer[pos] = '-';
+ } /* for */
+ unicode_string.Length = 0;
+ unicode_string.MaximumLength = largeint2str->MaximumLength * sizeof(WCHAR);
+ unicode_string.Buffer = str_Buffer;
+
+ if (largeint2str->base == 0) {
+ result = pRtlInt64ToUnicodeString(largeint2str->value, 10, &unicode_string);
+ } else {
+ result = pRtlInt64ToUnicodeString(largeint2str->value, largeint2str->base, &unicode_string);
+ } /* if */
+ pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
+ if (result == STATUS_BUFFER_OVERFLOW) {
+ /* On BUFFER_OVERFLOW the string Buffer should be unchanged */
+ for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
+ expected_str_Buffer[pos] = '-';
+ } /* for */
+ /* w2k: The native function has two reasons for BUFFER_OVERFLOW: */
+ /* If the value is too large to convert: The Length is unchanged */
+ /* If str is too small to hold the string: Set str->Length to the length */
+ /* the string would have (which can be larger than the MaximumLength). */
+ /* To allow all this in the tests we do the following: */
+ if (expected_unicode_string.Length >= 64) {
+ /* The value is too large to convert only triggerd when testing native */
+ /* Length is not filled with the expected string length (garbage?) */
+ expected_unicode_string.Length = unicode_string.Length;
+ } /* if */
+ } else {
+ ok(result == largeint2str->result,
+ "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) has result %lx, expected: %lx\n",
+ test_num, largeint2str->value, largeint2str->base, result, largeint2str->result);
+ if (result == STATUS_SUCCESS) {
+ ok(unicode_string.Buffer[unicode_string.Length/sizeof(WCHAR)] == '\0',
+ "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) string \"%s\" is not NULL terminated\n",
+ test_num, largeint2str->value, largeint2str->base, ansi_str.Buffer);
+ } /* if */
+ } /* if */
+ ok(memcmp(unicode_string.Buffer, expected_unicode_string.Buffer, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
+ "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
+ test_num, largeint2str->value, largeint2str->base, ansi_str.Buffer, expected_ansi_str.Buffer);
+ ok(unicode_string.Length == expected_unicode_string.Length,
+ "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) string has Length %d, expected: %d\n",
+ test_num, largeint2str->value, largeint2str->base, unicode_string.Length, expected_unicode_string.Length);
+ ok(unicode_string.MaximumLength == expected_unicode_string.MaximumLength,
+ "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) string has MaximumLength %d, expected: %d\n",
+ test_num, largeint2str->value, largeint2str->base, unicode_string.MaximumLength, expected_unicode_string.MaximumLength);
+ pRtlFreeAnsiString(&expected_ansi_str);
+ pRtlFreeAnsiString(&ansi_str);
+}
+
+
+static void test_RtlInt64ToUnicodeString(void)
+{
+ int test_num;
+
+ for (test_num = 0; test_num < NB_LARGEINT2STR; test_num++) {
+ one_RtlInt64ToUnicodeString_test(test_num, &largeint2str[test_num]);
+ } /* for */
+}
+
+
+static void one_RtlLargeIntegerToChar_test(int test_num, const largeint2str_t *largeint2str)
+{
+ NTSTATUS result;
+ char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
+ ULONGLONG value;
+
+ memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
+ dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
+ value = largeint2str->value;
+ if (largeint2str->base == 0) {
+ result = pRtlLargeIntegerToChar(&value, 10, largeint2str->MaximumLength, dest_str);
+ } else {
+ result = pRtlLargeIntegerToChar(&value, largeint2str->base, largeint2str->MaximumLength, dest_str);
+ } /* if */
+ ok(result == largeint2str->result,
+ "(test %d): RtlLargeIntegerToChar(%llu, %d, %d, [out]) has result %lx, expected: %lx\n",
+ test_num, largeint2str->value, largeint2str->base, largeint2str->MaximumLength, result, largeint2str->result);
+ ok(memcmp(dest_str, largeint2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
+ "(test %d): RtlLargeIntegerToChar(%llu, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
+ test_num, largeint2str->value, largeint2str->base, largeint2str->MaximumLength, dest_str, largeint2str->Buffer);
+}
+
+
+static void test_RtlLargeIntegerToChar(void)
+{
+ NTSTATUS result;
+ int test_num;
+ ULONGLONG value;
+
+ for (test_num = 0; test_num < NB_LARGEINT2STR; test_num++) {
+ one_RtlLargeIntegerToChar_test(test_num, &largeint2str[test_num]);
+ } /* for */
+
+ value = largeint2str[0].value;
+ result = pRtlLargeIntegerToChar(&value, 20, largeint2str[0].MaximumLength, NULL);
+ ok(result == STATUS_INVALID_PARAMETER,
+ "(test a): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x\n",
+ largeint2str[0].value, 20, largeint2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER);
+
+ result = pRtlLargeIntegerToChar(&value, 20, 0, NULL);
+ ok(result == STATUS_INVALID_PARAMETER,
+ "(test b): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x\n",
+ largeint2str[0].value, 20, largeint2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER);
+
+ result = pRtlLargeIntegerToChar(&value, largeint2str[0].base, 0, NULL);
+ ok(result == STATUS_BUFFER_OVERFLOW,
+ "(test c): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x\n",
+ largeint2str[0].value, largeint2str[0].base, 0, result, STATUS_BUFFER_OVERFLOW);
+
+ result = pRtlLargeIntegerToChar(&value, largeint2str[0].base, largeint2str[0].MaximumLength, NULL);
+ ok(result == STATUS_ACCESS_VIOLATION,
+ "(test d): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x\n",
+ largeint2str[0].value, largeint2str[0].base, largeint2str[0].MaximumLength, result, STATUS_ACCESS_VIOLATION);
+}
+
+
+START_TEST(large_int)
+{
+ InitFunctionPtrs();
+
+ if (pRtlExtendedMagicDivide)
+ test_RtlExtendedMagicDivide();
+ if (pRtlInt64ToUnicodeString)
+ test_RtlInt64ToUnicodeString();
+ if (pRtlLargeIntegerToChar)
+ test_RtlLargeIntegerToChar();
+}
--- /dev/null
+/*
+ * Unit test suite for ntdll path functions
+ *
+ * Copyright 2003 Eric Pouech
+ *
+ * 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
+ */
+
+#include <stdarg.h>
+
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x500 /* For NTSTATUS */
+#endif
+
+#include "ntstatus.h"
+#define WIN32_NO_STATUS
+#include "windef.h"
+#include "winbase.h"
+#include "winnt.h"
+#include "winreg.h"
+#include "winternl.h"
+
+#include "wine/test.h"
--- /dev/null
+<module name="ntdll_test" type="win32cui" installbase="bin" installname="ntdll_test.exe" warnings="true">
+ <include base="ntdll_test">.</include>
+ <define name="__USE_W32API" />
+ <library>ntdll</library>
+ <file>atom.c</file>
+ <file>env.c</file>
+ <file>error.c</file>
+ <file>info.c</file>
+ <file>large_int.c</file>
+ <file>path.c</file>
+ <file>reg.c</file>
+ <file>rtlbitmap.c</file>
+ <file>rtl.c</file>
+ <file>rtlstr.c</file>
+ <file>string.c</file>
+ <file>time.c</file>
+ <file>testlist.c</file>
+</module>
--- /dev/null
+/*
+ * Unit test suite for ntdll path functions
+ *
+ * Copyright 2002 Alexandre Julliard
+ *
+ * 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
+ */
+
+#include "ntdll_test.h"
+
+static NTSTATUS (WINAPI *pRtlMultiByteToUnicodeN)( LPWSTR dst, DWORD dstlen, LPDWORD reslen,
+ LPCSTR src, DWORD srclen );
+static NTSTATUS (WINAPI *pRtlUnicodeToMultiByteN)(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
+static UINT (WINAPI *pRtlDetermineDosPathNameType_U)( PCWSTR path );
+static ULONG (WINAPI *pRtlIsDosDeviceName_U)( PCWSTR dos_name );
+static NTSTATUS (WINAPI *pRtlOemStringToUnicodeString)(UNICODE_STRING *, const STRING *, BOOLEAN );
+static BOOLEAN (WINAPI *pRtlIsNameLegalDOS8Dot3)(const UNICODE_STRING*,POEM_STRING,PBOOLEAN);
+static DWORD (WINAPI *pRtlGetFullPathName_U)(const WCHAR*,ULONG,WCHAR*,WCHAR**);
+
+
+static void test_RtlDetermineDosPathNameType(void)
+{
+ struct test
+ {
+ const char *path;
+ UINT ret;
+ };
+
+ static const struct test tests[] =
+ {
+ { "\\\\foo", 1 },
+ { "//foo", 1 },
+ { "\\/foo", 1 },
+ { "/\\foo", 1 },
+ { "\\\\", 1 },
+ { "//", 1 },
+ { "c:\\foo", 2 },
+ { "c:/foo", 2 },
+ { "c://foo", 2 },
+ { "c:\\", 2 },
+ { "c:/", 2 },
+ { "c:foo", 3 },
+ { "c:f\\oo", 3 },
+ { "c:foo/bar", 3 },
+ { "\\foo", 4 },
+ { "/foo", 4 },
+ { "\\", 4 },
+ { "/", 4 },
+ { "foo", 5 },
+ { "", 5 },
+ { "\0:foo", 5 },
+ { "\\\\.\\foo", 6 },
+ { "//./foo", 6 },
+ { "/\\./foo", 6 },
+ { "\\\\.foo", 1 },
+ { "//.foo", 1 },
+ { "\\\\.", 7 },
+ { "//.", 7 },
+ { NULL, 0 }
+ };
+
+ const struct test *test;
+ WCHAR buffer[MAX_PATH];
+ UINT ret;
+
+ for (test = tests; test->path; test++)
+ {
+ pRtlMultiByteToUnicodeN( buffer, sizeof(buffer), NULL, test->path, strlen(test->path)+1 );
+ ret = pRtlDetermineDosPathNameType_U( buffer );
+ ok( ret == test->ret, "Wrong result %d/%d for %s\n", ret, test->ret, test->path );
+ }
+}
+
+
+static void test_RtlIsDosDeviceName(void)
+{
+ struct test
+ {
+ const char *path;
+ WORD pos;
+ WORD len;
+ };
+
+ static const struct test tests[] =
+ {
+ { "\\\\.\\CON", 8, 6 },
+ { "\\\\.\\con", 8, 6 },
+ { "\\\\.\\CON2", 0, 0 },
+ { "", 0, 0 },
+ { "\\\\foo\\nul", 0, 0 },
+ { "c:\\nul:", 6, 6 },
+ { "c:\\nul::", 0, 0 },
+ { "c:prn ", 4, 6 },
+ { "c:prn.......", 4, 6 },
+ { "c:prn... ...", 4, 6 },
+ { "c:NUL .... ", 0, 0 },
+ { "c: . . .", 0, 0 },
+ { "c:", 0, 0 },
+ { " . . . :", 0, 0 },
+ { ":", 0, 0 },
+ { "c:nul. . . :", 4, 6 },
+ { "c:nul . . :", 0, 0 },
+ { "c:nul0", 0, 0 },
+ { "c:prn:aaa", 0, 0 },
+ { "c:PRN:.txt", 4, 6 },
+ { "c:aux:.txt...", 4, 6 },
+ { "c:prn:.txt:", 4, 6 },
+ { "c:nul:aaa", 0, 0 },
+ { "con:", 0, 6 },
+ { "lpt1:", 0, 8 },
+ { "c:com5:", 4, 8 },
+ { "CoM4:", 0, 8 },
+ { "lpt9:", 0, 8 },
+ { "c:\\lpt0.txt", 0, 0 },
+ { "c:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\nul.txt", 1000, 6 },
+ { NULL, 0 }
+ };
+
+ const struct test *test;
+ WCHAR buffer[2000];
+ ULONG ret;
+
+ for (test = tests; test->path; test++)
+ {
+ pRtlMultiByteToUnicodeN( buffer, sizeof(buffer), NULL, test->path, strlen(test->path)+1 );
+ ret = pRtlIsDosDeviceName_U( buffer );
+ ok( ret == MAKELONG( test->len, test->pos ),
+ "Wrong result (%d,%d)/(%d,%d) for %s\n",
+ HIWORD(ret), LOWORD(ret), test->pos, test->len, test->path );
+ }
+}
+
+static void test_RtlIsNameLegalDOS8Dot3(void)
+{
+ struct test
+ {
+ const char *path;
+ BOOLEAN result;
+ BOOLEAN spaces;
+ };
+
+ static const struct test tests[] =
+ {
+ { "12345678", TRUE, FALSE },
+ { "123 5678", TRUE, TRUE },
+ { "12345678.", FALSE, 2 /*not set*/ },
+ { "1234 678.", FALSE, 2 /*not set*/ },
+ { "12345678.a", TRUE, FALSE },
+ { "12345678.a ", FALSE, 2 /*not set*/ },
+ { "12345678.a c", TRUE, TRUE },
+ { " 2345678.a ", FALSE, 2 /*not set*/ },
+ { "1 345678.abc", TRUE, TRUE },
+ { "1 8.a c", TRUE, TRUE },
+ { "1 3 5 7 .abc", FALSE, 2 /*not set*/ },
+ { "12345678. c", TRUE, TRUE },
+ { "123456789.a", FALSE, 2 /*not set*/ },
+ { "12345.abcd", FALSE, 2 /*not set*/ },
+ { "12345.ab d", FALSE, 2 /*not set*/ },
+ { ".abc", FALSE, 2 /*not set*/ },
+ { "12.abc.d", FALSE, 2 /*not set*/ },
+ { ".", TRUE, FALSE },
+ { "..", TRUE, FALSE },
+ { "...", FALSE, 2 /*not set*/ },
+ { "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", FALSE, 2 /*not set*/ },
+ { NULL, 0 }
+ };
+
+ const struct test *test;
+ UNICODE_STRING ustr;
+ OEM_STRING oem, oem_ret;
+ WCHAR buffer[200];
+ char buff2[12];
+ BOOLEAN ret, spaces;
+
+ ustr.MaximumLength = sizeof(buffer);
+ ustr.Buffer = buffer;
+ for (test = tests; test->path; test++)
+ {
+ char path[100];
+ strcpy(path, test->path);
+ oem.Buffer = path;
+ oem.Length = strlen(test->path);
+ oem.MaximumLength = oem.Length + 1;
+ pRtlOemStringToUnicodeString( &ustr, &oem, FALSE );
+ spaces = 2;
+ oem_ret.Length = oem_ret.MaximumLength = sizeof(buff2);
+ oem_ret.Buffer = buff2;
+ ret = pRtlIsNameLegalDOS8Dot3( &ustr, &oem_ret, &spaces );
+ ok( ret == test->result, "Wrong result %d/%d for '%s'\n", ret, test->result, test->path );
+ ok( spaces == test->spaces, "Wrong spaces value %d/%d for '%s'\n", spaces, test->spaces, test->path );
+ if (strlen(test->path) <= 12)
+ {
+ char str[13];
+ int i;
+ strcpy( str, test->path );
+ for (i = 0; str[i]; i++) str[i] = toupper(str[i]);
+ ok( oem_ret.Length == strlen(test->path), "Wrong length %d/%d for '%s'\n",
+ oem_ret.Length, strlen(test->path), test->path );
+ ok( !memcmp( oem_ret.Buffer, str, oem_ret.Length ),
+ "Wrong string '%.*s'/'%s'\n", oem_ret.Length, oem_ret.Buffer, str );
+ }
+ }
+}
+static void test_RtlGetFullPathName_U(void)
+{
+ struct test
+ {
+ const char *path;
+ const char *rname;
+ const char *rfile;
+ };
+
+ static const struct test tests[] =
+ {
+ { "c:/test", "c:\\test", "test"},
+ { "c:/test ", "c:\\test", "test"},
+ { "c:/test.", "c:\\test", "test"},
+ { "c:/test .... .. ", "c:\\test", "test"},
+ { "c:/test/ .... .. ", "c:\\test\\", NULL},
+ { "c:/test/..", "c:\\", NULL},
+ { "c:/test/.. ", "c:\\test\\", NULL},
+ { "c:/TEST", "c:\\test", "test"},
+ { "c:/test/file", "c:\\test\\file", "file"},
+ { "c:/test./file", "c:\\test\\file", "file"},
+ { "c:/test../file", "c:\\test.\\file", "file"},
+ { "c:/test.. /file", "c:\\test.. \\file","file"},
+ { "c:/test/././file", "c:\\test\\file", "file"},
+ { "c:/test\\.\\.\\file", "c:\\test\\file", "file"},
+ { "c:/test/\\.\\.\\file", "c:\\test\\file", "file"},
+ { "c:/test\\\\.\\.\\file", "c:\\test\\file", "file"},
+ { "c:/test\\test1\\..\\.\\file", "c:\\test\\file", "file"},
+ { "c:///test\\.\\.\\file//", "c:\\test\\file\\", NULL},
+ { "c:///test\\..\\file\\..\\//", "c:\\", NULL},
+ { NULL, NULL, NULL}
+ };
+
+ const struct test *test;
+ WCHAR pathbufW[2*MAX_PATH], rbufferW[MAX_PATH];
+ CHAR rbufferA[MAX_PATH], rfileA[MAX_PATH];
+ ULONG ret;
+ WCHAR *file_part;
+ DWORD reslen;
+ UINT len;
+
+ for (test = tests; test->path; test++)
+ {
+ len= strlen(test->rname) * sizeof(WCHAR);
+ pRtlMultiByteToUnicodeN(pathbufW , sizeof(pathbufW), NULL, test->path, strlen(test->path)+1 );
+ ret = pRtlGetFullPathName_U( pathbufW,MAX_PATH, rbufferW, &file_part);
+ ok( ret == len, "Wrong result %ld/%d for \"%s\"\n", ret, len, test->path );
+ ok(pRtlUnicodeToMultiByteN(rbufferA,MAX_PATH,&reslen,rbufferW,MAX_PATH) == STATUS_SUCCESS,
+ "RtlUnicodeToMultiByteN failed\n");
+ ok(lstrcmpiA(rbufferA,test->rname) == 0, "Got \"%s\" expected \"%s\"\n",rbufferA,test->rname);
+ if (file_part)
+ {
+ ok(pRtlUnicodeToMultiByteN(rfileA,MAX_PATH,&reslen,file_part,MAX_PATH) == STATUS_SUCCESS,
+ "RtlUnicodeToMultiByteN failed\n");
+ ok(test->rfile && !lstrcmpiA(rfileA,test->rfile), "Got \"%s\" expected \"%s\"\n",rfileA,test->rfile);
+ }
+ else
+ {
+ ok( !test->rfile, "Got NULL expected \"%s\"\n", test->rfile );
+ }
+ }
+
+}
+
+START_TEST(path)
+{
+ HMODULE mod = GetModuleHandleA("ntdll.dll");
+ pRtlMultiByteToUnicodeN = (void *)GetProcAddress(mod,"RtlMultiByteToUnicodeN");
+ pRtlUnicodeToMultiByteN = (void *)GetProcAddress(mod,"RtlUnicodeToMultiByteN");
+ pRtlDetermineDosPathNameType_U = (void *)GetProcAddress(mod,"RtlDetermineDosPathNameType_U");
+ pRtlIsDosDeviceName_U = (void *)GetProcAddress(mod,"RtlIsDosDeviceName_U");
+ pRtlOemStringToUnicodeString = (void *)GetProcAddress(mod,"RtlOemStringToUnicodeString");
+ pRtlIsNameLegalDOS8Dot3 = (void *)GetProcAddress(mod,"RtlIsNameLegalDOS8Dot3");
+ pRtlGetFullPathName_U = (void *)GetProcAddress(mod,"RtlGetFullPathName_U");
+ if (pRtlDetermineDosPathNameType_U)
+ test_RtlDetermineDosPathNameType();
+ if (pRtlIsDosDeviceName_U)
+ test_RtlIsDosDeviceName();
+ if (pRtlIsNameLegalDOS8Dot3)
+ test_RtlIsNameLegalDOS8Dot3();
+ if (pRtlGetFullPathName_U && pRtlMultiByteToUnicodeN)
+ test_RtlGetFullPathName_U();
+}
--- /dev/null
+/* Unit test suite for Rtl* Registry API functions
+ *
+ * Copyright 2003 Thomas Mertes
+ * Copyright 2005 Brad DeMorrow
+ *
+ * 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
+ *
+ * NOTE: I don't test every RelativeTo value because it would be redundant, all calls go through
+ * helper function RTL_GetKeyHandle().--Brad DeMorrow
+ *
+ */
+
+#include "ntdll_test.h"
+#include "winternl.h"
+//#include "wine/library.h"
+#include "stdio.h"
+#include "winnt.h"
+#include "winnls.h"
+#include "stdlib.h"
+#include "wine/unicode.h"
+
+#ifndef __WINE_WINTERNL_H
+
+/* RtlQueryRegistryValues structs and defines */
+#define RTL_REGISTRY_ABSOLUTE 0
+#define RTL_REGISTRY_SERVICES 1
+#define RTL_REGISTRY_CONTROL 2
+#define RTL_REGISTRY_WINDOWS_NT 3
+#define RTL_REGISTRY_DEVICEMAP 4
+#define RTL_REGISTRY_USER 5
+
+#define RTL_REGISTRY_HANDLE 0x40000000
+#define RTL_REGISTRY_OPTIONAL 0x80000000
+
+#define RTL_QUERY_REGISTRY_SUBKEY 0x00000001
+#define RTL_QUERY_REGISTRY_TOPKEY 0x00000002
+#define RTL_QUERY_REGISTRY_REQUIRED 0x00000004
+#define RTL_QUERY_REGISTRY_NOVALUE 0x00000008
+#define RTL_QUERY_REGISTRY_NOEXPAND 0x00000010
+#define RTL_QUERY_REGISTRY_DIRECT 0x00000020
+#define RTL_QUERY_REGISTRY_DELETE 0x00000040
+
+typedef NTSTATUS (WINAPI *PRTL_QUERY_REGISTRY_ROUTINE)( PCWSTR ValueName,
+ ULONG ValueType,
+ PVOID ValueData,
+ ULONG ValueLength,
+ PVOID Context,
+ PVOID EntryContext);
+
+typedef struct _RTL_QUERY_REGISTRY_TABLE {
+ PRTL_QUERY_REGISTRY_ROUTINE QueryRoutine;
+ ULONG Flags;
+ PWSTR Name;
+ PVOID EntryContext;
+ ULONG DefaultType;
+ PVOID DefaultData;
+ ULONG DefaultLength;
+} RTL_QUERY_REGISTRY_TABLE, *PRTL_QUERY_REGISTRY_TABLE;
+
+#endif
+
+static NTSTATUS (WINAPI * pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING, LPCSTR);
+static NTSTATUS (WINAPI * pRtlFreeUnicodeString)(PUNICODE_STRING);
+static NTSTATUS (WINAPI * pNtDeleteValueKey)(IN HANDLE, IN PUNICODE_STRING);
+static NTSTATUS (WINAPI * pRtlQueryRegistryValues)(IN ULONG, IN PCWSTR,IN PRTL_QUERY_REGISTRY_TABLE, IN PVOID,IN PVOID);
+static NTSTATUS (WINAPI * pRtlCheckRegistryKey)(IN ULONG,IN PWSTR);
+static NTSTATUS (WINAPI * pRtlOpenCurrentUser)(IN ACCESS_MASK, OUT PHKEY);
+static NTSTATUS (WINAPI * pNtOpenKey)(PHANDLE, IN ACCESS_MASK, IN POBJECT_ATTRIBUTES);
+static NTSTATUS (WINAPI * pNtClose)(IN HANDLE);
+static NTSTATUS (WINAPI * pNtDeleteValueKey)(IN HANDLE, IN PUNICODE_STRING);
+static NTSTATUS (WINAPI * pNtDeleteKey)(HKEY);
+static NTSTATUS (WINAPI * pNtCreateKey)( PHKEY retkey, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
+ ULONG TitleIndex, const UNICODE_STRING *class, ULONG options,
+ PULONG dispos );
+static NTSTATUS (WINAPI * pNtSetValueKey)( PHKEY, const PUNICODE_STRING, ULONG,
+ ULONG, const PVOID, ULONG );
+static NTSTATUS (WINAPI * pRtlFormatCurrentUserKeyPath)(PUNICODE_STRING);
+static NTSTATUS (WINAPI * pRtlCreateUnicodeString)( PUNICODE_STRING, LPCWSTR);
+static NTSTATUS (WINAPI * pRtlReAllocateHeap)(IN PVOID, IN ULONG, IN PVOID, IN ULONG);
+static NTSTATUS (WINAPI * pRtlAppendUnicodeToString)(PUNICODE_STRING, PCWSTR);
+static NTSTATUS (WINAPI * pRtlUnicodeStringToAnsiString)(PSTRING, PUNICODE_STRING, BOOL);
+static NTSTATUS (WINAPI * pRtlFreeHeap)(PVOID, ULONG, PVOID);
+static NTSTATUS (WINAPI * pRtlAllocateHeap)(PVOID,ULONG,ULONG);
+static NTSTATUS (WINAPI * pRtlZeroMemory)(PVOID, ULONG);
+
+static HMODULE hntdll = 0;
+static int CurrentTest = 0;
+static UNICODE_STRING winetestpath;
+
+#define NTDLL_GET_PROC(func) \
+ p ## func = (void*)GetProcAddress(hntdll, #func); \
+ if(!p ## func) { \
+ trace("GetProcAddress(%s) failed\n", #func); \
+ FreeLibrary(hntdll); \
+ return FALSE; \
+ }
+
+static BOOL InitFunctionPtrs(void)
+{
+ hntdll = LoadLibraryA("ntdll.dll");
+ if(!hntdll) {
+ trace("Could not load ntdll.dll\n");
+ return FALSE;
+ }
+ if (hntdll)
+ {
+ NTDLL_GET_PROC(RtlCreateUnicodeStringFromAsciiz)
+ NTDLL_GET_PROC(RtlCreateUnicodeString)
+ NTDLL_GET_PROC(RtlFreeUnicodeString)
+ NTDLL_GET_PROC(NtDeleteValueKey)
+ NTDLL_GET_PROC(RtlQueryRegistryValues)
+ NTDLL_GET_PROC(RtlCheckRegistryKey)
+ NTDLL_GET_PROC(RtlOpenCurrentUser)
+ NTDLL_GET_PROC(NtClose)
+ NTDLL_GET_PROC(NtDeleteValueKey)
+ NTDLL_GET_PROC(NtCreateKey)
+ NTDLL_GET_PROC(NtDeleteKey)
+ NTDLL_GET_PROC(NtSetValueKey)
+ NTDLL_GET_PROC(NtOpenKey)
+ NTDLL_GET_PROC(RtlFormatCurrentUserKeyPath)
+ NTDLL_GET_PROC(RtlReAllocateHeap)
+ NTDLL_GET_PROC(RtlAppendUnicodeToString)
+ NTDLL_GET_PROC(RtlUnicodeStringToAnsiString)
+ NTDLL_GET_PROC(RtlFreeHeap)
+ NTDLL_GET_PROC(RtlAllocateHeap)
+ NTDLL_GET_PROC(RtlZeroMemory)
+ }
+ return TRUE;
+}
+#undef NTDLL_GET_PROC
+
+static NTSTATUS WINAPI QueryRoutine (IN PCWSTR ValueName, IN ULONG ValueType, IN PVOID ValueData,
+ IN ULONG ValueLength, IN PVOID Context, IN PVOID EntryContext)
+{
+ NTSTATUS ret = STATUS_SUCCESS;
+ int ValueNameLength = 0;
+ LPSTR ValName = 0;
+ trace("**Test %d**\n", CurrentTest);
+
+ if(ValueName)
+ {
+ ValueNameLength = strlenW(ValueName);
+
+ ValName = (LPSTR)pRtlAllocateHeap(GetProcessHeap(), 0, ValueNameLength);
+
+ WideCharToMultiByte(0, 0, ValueName, ValueNameLength+1,ValName, ValueNameLength, 0, 0);
+
+ trace("ValueName: %s\n", ValName);
+ }
+ else
+ trace("ValueName: (null)\n");
+
+ switch(ValueType)
+ {
+ case REG_NONE:
+ trace("ValueType: REG_NONE\n");
+ trace("ValueData: %d\n", (int)ValueData);
+ break;
+
+ case REG_BINARY:
+ trace("ValueType: REG_BINARY\n");
+ trace("ValueData: %d\n", (int)ValueData);
+ break;
+
+ case REG_SZ:
+ trace("ValueType: REG_SZ\n");
+ trace("ValueData: %s\n", (char*)ValueData);
+ break;
+
+ case REG_MULTI_SZ:
+ trace("ValueType: REG_MULTI_SZ\n");
+ trace("ValueData: %s\n", (char*)ValueData);
+ break;
+
+ case REG_EXPAND_SZ:
+ trace("ValueType: REG_EXPAND_SZ\n");
+ trace("ValueData: %s\n", (char*)ValueData);
+ break;
+
+ case REG_DWORD:
+ trace("ValueType: REG_DWORD\n");
+ trace("ValueData: %d\n", (int)ValueData);
+ break;
+ };
+ trace("ValueLength: %d\n", (int)ValueLength);
+
+ if(CurrentTest == 0)
+ ok(1, "\n"); /*checks that QueryRoutine is called*/
+ if(CurrentTest > 7)
+ ok(!1, "Invalid Test Specified!\n");
+
+ CurrentTest++;
+
+ if(ValName)
+ pRtlFreeHeap(GetProcessHeap(), 0, ValName);
+
+ return ret;
+}
+
+static void test_RtlQueryRegistryValues(void)
+{
+
+ /*
+ ******************************
+ * QueryTable Flags *
+ ******************************
+ *RTL_QUERY_REGISTRY_SUBKEY * Name is the name of a subkey relative to Path
+ *RTL_QUERY_REGISTRY_TOPKEY * Resets location to original RelativeTo and Path
+ *RTL_QUERY_REGISTRY_REQUIRED * Key required. returns STATUS_OBJECT_NAME_NOT_FOUND if not present
+ *RTL_QUERY_REGISTRY_NOVALUE * We just want a call-back
+ *RTL_QUERY_REGISTRY_NOEXPAND * Don't expand the variables!
+ *RTL_QUERY_REGISTRY_DIRECT * Results of query will be stored in EntryContext(QueryRoutine ignored)
+ *RTL_QUERY_REGISTRY_DELETE * Delete value key after query
+ ******************************
+
+
+ **Test layout(numbered according to CurrentTest value)**
+ 0)NOVALUE Just make sure call-back works
+ 1)Null Name See if QueryRoutine is called for every value in current key
+ 2)SUBKEY See if we can use SUBKEY to change the current path on the fly
+ 3)REQUIRED Test for value that's not there
+ 4)NOEXPAND See if it will return multiple strings(no expand should split strings up)
+ 5)DIRECT Make it store data directly in EntryContext and not call QueryRoutine
+ 6)DefaultType Test return values when key isn't present
+ 7)DefaultValue Test Default Value returned with key isn't present(and no REQUIRED flag set)
+ 8)DefaultLength Test Default Length with DefaultType = REG_SZ
+ 9)DefaultLength Test Default Length with DefaultType = REG_MULTI_SZ
+ 10)DefaultLength Test Default Length with DefaultType = REG_EXPAND_SZ
+ 11)DefaultData Test whether DefaultData is used while DefaltType = REG_NONE(shouldn't be)
+ 12)Delete Try to delete value key
+
+ */
+ NTSTATUS status;
+ ULONG RelativeTo;
+
+ PRTL_QUERY_REGISTRY_TABLE QueryTable = NULL;
+ RelativeTo = RTL_REGISTRY_ABSOLUTE;/*Only using absolute - no need to test all relativeto variables*/
+
+ QueryTable = (PRTL_QUERY_REGISTRY_TABLE)pRtlAllocateHeap(GetProcessHeap(), 0, sizeof(RTL_QUERY_REGISTRY_TABLE)*26);
+
+ pRtlZeroMemory( QueryTable, sizeof(RTL_QUERY_REGISTRY_TABLE) * 26);
+
+ QueryTable[0].QueryRoutine = QueryRoutine;
+ QueryTable[0].Flags = RTL_QUERY_REGISTRY_NOVALUE;
+ QueryTable[0].Name = NULL;
+ QueryTable[0].EntryContext = NULL;
+ QueryTable[0].DefaultType = REG_BINARY;
+ QueryTable[0].DefaultData = NULL;
+ QueryTable[0].DefaultLength = 100;
+
+ QueryTable[1].QueryRoutine = QueryRoutine;
+ QueryTable[1].Flags = 0;
+ QueryTable[1].Name = NULL;
+ QueryTable[1].EntryContext = 0;
+ QueryTable[1].DefaultType = REG_NONE;
+ QueryTable[1].DefaultData = NULL;
+ QueryTable[1].DefaultLength = 0;
+
+ QueryTable[2].QueryRoutine = NULL;
+ QueryTable[2].Flags = 0;
+ QueryTable[2].Name = NULL;
+ QueryTable[2].EntryContext = 0;
+ QueryTable[2].DefaultType = REG_NONE;
+ QueryTable[2].DefaultData = NULL;
+ QueryTable[2].DefaultLength = 0;
+
+ status = pRtlQueryRegistryValues(RelativeTo, winetestpath.Buffer, QueryTable, 0, 0);
+ ok(status == STATUS_SUCCESS, "RtlQueryRegistryValues return: 0x%08lx\n", status);
+
+ pRtlFreeHeap(GetProcessHeap(), 0, QueryTable);
+}
+
+static void test_NtCreateKey(void)
+{
+ /*Create WineTest*/
+ OBJECT_ATTRIBUTES attr;
+ UNICODE_STRING ValName;
+ HKEY key;
+ ACCESS_MASK am = GENERIC_ALL;
+ NTSTATUS status;
+
+ InitializeObjectAttributes(&attr, &winetestpath, 0, 0, 0);
+ status = pNtCreateKey(&key, am, &attr, 0, 0, 0, 0);
+ ok(status == STATUS_SUCCESS, "NtCreateKey Failed: 0x%08lx\n", status);
+
+ pRtlFreeUnicodeString(&ValName);
+ pNtClose(&key);
+}
+
+static void test_NtSetValueKey(void)
+{
+ HANDLE key;
+ NTSTATUS status;
+ OBJECT_ATTRIBUTES attr;
+ ACCESS_MASK am = KEY_WRITE;
+ UNICODE_STRING ValName;
+ DWORD data = 711;
+
+ pRtlCreateUnicodeStringFromAsciiz(&ValName, "deletetest");
+
+ InitializeObjectAttributes(&attr, &winetestpath, 0, 0, 0);
+ status = pNtOpenKey(&key, am, &attr);
+ ok(status == STATUS_SUCCESS, "NtOpenKey Failed: 0x%08lx\n", status);
+
+ status = pNtSetValueKey(key, &ValName, 0, REG_DWORD, &data, sizeof(data));
+ ok(status == STATUS_SUCCESS, "NtSetValueKey Failed: 0x%08lx\n", status);
+
+ pRtlFreeUnicodeString(&ValName);
+ pNtClose(&key);
+}
+
+static void test_RtlOpenCurrentUser(void)
+{
+ NTSTATUS status;
+ HKEY handle;
+ status=pRtlOpenCurrentUser(KEY_READ, &handle);
+ ok(status == STATUS_SUCCESS, "RtlOpenCurrentUser Failed: 0x%08lx\n", status);
+ pNtClose(&handle);
+}
+
+static void test_RtlCheckRegistryKey(void)
+{
+ NTSTATUS status;
+
+ status = pRtlCheckRegistryKey(RTL_REGISTRY_ABSOLUTE, winetestpath.Buffer);
+ ok(status == STATUS_SUCCESS, "RtlCheckRegistryKey with RTL_REGISTRY_ABSOLUTE: 0x%08lx\n", status);
+
+ status = pRtlCheckRegistryKey((RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL), winetestpath.Buffer);
+ ok(status == STATUS_SUCCESS, "RtlCheckRegistryKey with RTL_REGISTRY_ABSOLUTE and RTL_REGISTRY_OPTIONAL: 0x%08lx\n", status);
+}
+
+static void test_NtDeleteKey(void)
+{
+ NTSTATUS status;
+ HANDLE hkey;
+ OBJECT_ATTRIBUTES attr;
+ ACCESS_MASK am = KEY_ALL_ACCESS;
+
+ InitializeObjectAttributes(&attr, &winetestpath, 0, 0, 0);
+ status = pNtOpenKey(&hkey, am, &attr);
+
+ status = pNtDeleteKey(hkey);
+ ok(status == STATUS_SUCCESS, "NtDeleteKey Failed: 0x%08lx\n", status);
+}
+
+START_TEST(reg)
+{
+ static const WCHAR winetest[] = {'\\','W','i','n','e','T','e','s','t','\\',0};
+ if(!InitFunctionPtrs())
+ return;
+ pRtlFormatCurrentUserKeyPath(&winetestpath);
+ winetestpath.Buffer = (PWSTR)pRtlReAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, winetestpath.Buffer,
+ winetestpath.MaximumLength + sizeof(winetest)*sizeof(WCHAR));
+ winetestpath.MaximumLength = winetestpath.MaximumLength + sizeof(winetest)*sizeof(WCHAR);
+
+ pRtlAppendUnicodeToString(&winetestpath, winetest);
+
+ test_NtCreateKey();
+ test_NtSetValueKey();
+ test_RtlCheckRegistryKey();
+ test_RtlOpenCurrentUser();
+ test_RtlQueryRegistryValues();
+ test_NtDeleteKey();
+
+ pRtlFreeUnicodeString(&winetestpath);
+
+ FreeLibrary(hntdll);
+}
--- /dev/null
+/* 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 "ntdll_test.h"
+
+/* Function ptrs for ntdll calls */
+static HMODULE hntdll = 0;
+static SIZE_T (WINAPI *pRtlCompareMemory)(LPCVOID,LPCVOID,SIZE_T);
+static SIZE_T (WINAPI *pRtlCompareMemoryUlong)(PULONG, SIZE_T, ULONG);
+static VOID (WINAPI *pRtlMoveMemory)(LPVOID,LPCVOID,SIZE_T);
+static VOID (WINAPI *pRtlFillMemory)(LPVOID,SIZE_T,BYTE);
+static VOID (WINAPI *pRtlFillMemoryUlong)(LPVOID,SIZE_T,ULONG);
+static VOID (WINAPI *pRtlZeroMemory)(LPVOID,SIZE_T);
+static ULONGLONG (WINAPIV *pRtlUlonglongByteSwap)(ULONGLONG source);
+static ULONG (WINAPI *pRtlUniform)(PULONG);
+static ULONG (WINAPI *pRtlRandom)(PULONG);
+static BOOLEAN (WINAPI *pRtlAreAllAccessesGranted)(ACCESS_MASK, ACCESS_MASK);
+static BOOLEAN (WINAPI *pRtlAreAnyAccessesGranted)(ACCESS_MASK, ACCESS_MASK);
+static DWORD (WINAPI *pRtlComputeCrc32)(DWORD,const BYTE*,INT);
+static void (WINAPI * pRtlInitializeHandleTable)(ULONG, ULONG, RTL_HANDLE_TABLE *);
+static BOOLEAN (WINAPI * pRtlIsValidIndexHandle)(const RTL_HANDLE_TABLE *, ULONG, RTL_HANDLE **);
+static NTSTATUS (WINAPI * pRtlDestroyHandleTable)(RTL_HANDLE_TABLE *);
+static RTL_HANDLE * (WINAPI * pRtlAllocateHandle)(RTL_HANDLE_TABLE *, ULONG *);
+static BOOLEAN (WINAPI * pRtlFreeHandle)(RTL_HANDLE_TABLE *, RTL_HANDLE *);
+#define LEN 16
+static const char* src_src = "This is a test!"; /* 16 bytes long, incl NUL */
+static ULONG src_aligned_block[4];
+static ULONG dest_aligned_block[32];
+static const char *src = (const char*)src_aligned_block;
+static char* dest = (char*)dest_aligned_block;
+
+static void InitFunctionPtrs(void)
+{
+ hntdll = LoadLibraryA("ntdll.dll");
+ ok(hntdll != 0, "LoadLibrary failed\n");
+ if (hntdll) {
+ pRtlCompareMemory = (void *)GetProcAddress(hntdll, "RtlCompareMemory");
+ pRtlCompareMemoryUlong = (void *)GetProcAddress(hntdll, "RtlCompareMemoryUlong");
+ pRtlMoveMemory = (void *)GetProcAddress(hntdll, "RtlMoveMemory");
+ pRtlFillMemory = (void *)GetProcAddress(hntdll, "RtlFillMemory");
+ pRtlFillMemoryUlong = (void *)GetProcAddress(hntdll, "RtlFillMemoryUlong");
+ pRtlZeroMemory = (void *)GetProcAddress(hntdll, "RtlZeroMemory");
+ pRtlUlonglongByteSwap = (void *)GetProcAddress(hntdll, "RtlUlonglongByteSwap");
+ pRtlUniform = (void *)GetProcAddress(hntdll, "RtlUniform");
+ pRtlRandom = (void *)GetProcAddress(hntdll, "RtlRandom");
+ pRtlAreAllAccessesGranted = (void *)GetProcAddress(hntdll, "RtlAreAllAccessesGranted");
+ pRtlAreAnyAccessesGranted = (void *)GetProcAddress(hntdll, "RtlAreAnyAccessesGranted");
+ pRtlComputeCrc32 = (void *)GetProcAddress(hntdll, "RtlComputeCrc32");
+ pRtlInitializeHandleTable = (void *)GetProcAddress(hntdll, "RtlInitializeHandleTable");
+ pRtlIsValidIndexHandle = (void *)GetProcAddress(hntdll, "RtlIsValidIndexHandle");
+ pRtlDestroyHandleTable = (void *)GetProcAddress(hntdll, "RtlDestroyHandleTable");
+ pRtlAllocateHandle = (void *)GetProcAddress(hntdll, "RtlAllocateHandle");
+ pRtlFreeHandle = (void *)GetProcAddress(hntdll, "RtlFreeHandle");
+ }
+ strcpy((char*)src_aligned_block, src_src);
+ ok(strlen(src) == 15, "Source must be 16 bytes long!\n");
+}
+
+#define COMP(str1,str2,cmplen,len) size = pRtlCompareMemory(str1, str2, cmplen); \
+ ok(size == len, "Expected %ld, got %ld\n", size, (SIZE_T)len)
+
+static void test_RtlCompareMemory(void)
+{
+ SIZE_T size;
+
+ if (!pRtlCompareMemory)
+ return;
+
+ strcpy(dest, src);
+
+ COMP(src,src,0,0);
+ COMP(src,src,LEN,LEN);
+ dest[0] = 'x';
+ COMP(src,dest,LEN,0);
+}
+
+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);
+}
+
+#define COPY(len) memset(dest,0,sizeof(dest_aligned_block)); pRtlMoveMemory(dest, src, len)
+#define CMP(str) ok(strcmp(dest,str) == 0, "Expected '%s', got '%s'\n", str, dest)
+
+static void test_RtlMoveMemory(void)
+{
+ if (!pRtlMoveMemory)
+ return;
+
+ /* Length should be in bytes and not rounded. Use strcmp to ensure we
+ * didn't write past the end (it checks for the final NUL left by memset)
+ */
+ COPY(0); CMP("");
+ COPY(1); CMP("T");
+ COPY(2); CMP("Th");
+ COPY(3); CMP("Thi");
+ COPY(4); CMP("This");
+ COPY(5); CMP("This ");
+ COPY(6); CMP("This i");
+ COPY(7); CMP("This is");
+ COPY(8); CMP("This is ");
+ COPY(9); CMP("This is a");
+
+ /* Overlapping */
+ strcpy(dest, src); pRtlMoveMemory(dest, dest + 1, strlen(src) - 1);
+ CMP("his is a test!!");
+ strcpy(dest, src); pRtlMoveMemory(dest + 1, dest, strlen(src));
+ CMP("TThis is a test!");
+}
+
+#define FILL(len) memset(dest,0,sizeof(dest_aligned_block)); strcpy(dest, src); pRtlFillMemory(dest,len,'x')
+
+static void test_RtlFillMemory(void)
+{
+ if (!pRtlFillMemory)
+ return;
+
+ /* Length should be in bytes and not rounded. Use strcmp to ensure we
+ * didn't write past the end (the remainder of the string should match)
+ */
+ FILL(0); CMP("This is a test!");
+ FILL(1); CMP("xhis is a test!");
+ FILL(2); CMP("xxis is a test!");
+ FILL(3); CMP("xxxs is a test!");
+ FILL(4); CMP("xxxx is a test!");
+ FILL(5); CMP("xxxxxis a test!");
+ FILL(6); CMP("xxxxxxs a test!");
+ FILL(7); CMP("xxxxxxx a test!");
+ FILL(8); CMP("xxxxxxxxa test!");
+ FILL(9); CMP("xxxxxxxxx test!");
+}
+
+#define LFILL(len) memset(dest,0,sizeof(dest_aligned_block)); strcpy(dest, src); pRtlFillMemoryUlong(dest,len,val)
+
+static void test_RtlFillMemoryUlong(void)
+{
+ ULONG val = ('x' << 24) | ('x' << 16) | ('x' << 8) | 'x';
+ if (!pRtlFillMemoryUlong)
+ return;
+
+ /* Length should be in bytes and not rounded. Use strcmp to ensure we
+ * didn't write past the end (the remainder of the string should match)
+ */
+ LFILL(0); CMP("This is a test!");
+ LFILL(1); CMP("This is a test!");
+ LFILL(2); CMP("This is a test!");
+ LFILL(3); CMP("This is a test!");
+ LFILL(4); CMP("xxxx is a test!");
+ LFILL(5); CMP("xxxx is a test!");
+ LFILL(6); CMP("xxxx is a test!");
+ LFILL(7); CMP("xxxx is a test!");
+ LFILL(8); CMP("xxxxxxxxa test!");
+ LFILL(9); CMP("xxxxxxxxa test!");
+}
+
+#define ZERO(len) memset(dest,0,sizeof(dest_aligned_block)); strcpy(dest, src); pRtlZeroMemory(dest,len)
+#define MCMP(str) ok(memcmp(dest,str,LEN) == 0, "Memcmp failed\n")
+
+static void test_RtlZeroMemory(void)
+{
+ if (!pRtlZeroMemory)
+ return;
+
+ /* Length should be in bytes and not rounded. */
+ ZERO(0); MCMP("This is a test!");
+ ZERO(1); MCMP("\0his is a test!");
+ ZERO(2); MCMP("\0\0is is a test!");
+ ZERO(3); MCMP("\0\0\0s is a test!");
+ ZERO(4); MCMP("\0\0\0\0 is a test!");
+ ZERO(5); MCMP("\0\0\0\0\0is a test!");
+ ZERO(6); MCMP("\0\0\0\0\0\0s a test!");
+ ZERO(7); MCMP("\0\0\0\0\0\0\0 a test!");
+ ZERO(8); MCMP("\0\0\0\0\0\0\0\0a test!");
+ ZERO(9); MCMP("\0\0\0\0\0\0\0\0\0 test!");
+}
+
+static void test_RtlUlonglongByteSwap(void)
+{
+ ULONGLONG result;
+
+ result = pRtlUlonglongByteSwap( ((ULONGLONG)0x76543210 << 32) | 0x87654321 );
+ ok( (((ULONGLONG)0x21436587 << 32) | 0x10325476) == result,
+ "RtlUlonglongByteSwap(0x7654321087654321) returns 0x%llx, expected 0x2143658710325476\n",
+ 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 0x7fffffff (and MAXLONG + 1 is 0x80000000) the
+ * algorithm can be expressed without division 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\n",
+ 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\n",
+ 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\n",
+ 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\n",
+ result, expected);
+
+ seed = 0x6bca1aa;
+ expected = seed * 0xffffffed + 0x7fffffc3;
+ result = pRtlUniform(&seed);
+ ok(result == expected,
+ "RtlUniform(&seed (seed == 0x6bca1aa)) returns %lx, expected %lx\n",
+ result, expected);
+
+ seed = 0x6bca1ab;
+ expected = seed * 0xffffffed + 0x7fffffc3 + 1;
+ result = pRtlUniform(&seed);
+ ok(result == expected,
+ "RtlUniform(&seed (seed == 0x6bca1ab)) returns %lx, expected %lx\n",
+ 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\n",
+ 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\n",
+ result, expected);
+
+ seed = 0x6bca1ae;
+ expected = (seed * 0xffffffed + 0x7fffffc3 + 1) & MAXLONG;
+ result = pRtlUniform(&seed);
+ ok(result == expected,
+ "RtlUniform(&seed (seed == 0x6bca1ae)) returns %lx, expected %lx\n",
+ 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\n",
+ num, seed_bak, result, expected);
+ ok(seed == expected,
+ "test: %llu RtlUniform(&seed (seed == %lx)) sets seed to %lx, expected %lx\n",
+ 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 a simplified algorithm:
+ *
+ * seed = seed * 0xffffffed + 0x7fffffc3;
+ * if (seed == 0xffffffff || seed == 0x7ffffffe) {
+ * seed = (seed + 2) & MAXLONG;
+ * } else if (seed == 0x7fffffff) {
+ * seed = 0;
+ * } else if ((seed & 0x80000000) == 0) {
+ * seed = seed + (~seed & 1);
+ * } else {
+ * seed = (seed + (seed & 1)) & MAXLONG;
+ * }
+ *
+ * This is also the algorithm used for RtlUniform of wine (see dlls/ntdll/rtl.c).
+ *
+ * Now comes the funny part:
+ * It took me one weekend, to find the complicated algorithm and one day more,
+ * to find the simplified algorithm. Several weeks later I found out: The value
+ * MAXLONG (=0x7fffffff) is never returned, neither with the native function
+ * nor with the simplified algorithm. In reality the native function and our
+ * function return a random number distributed over [0..MAXLONG-1]. Note
+ * that this is different from what native documentation states [0..MAXLONG].
+ * Expressed with D.H. Lehmer's 1948 algorithm it looks like:
+ *
+ * seed = (seed * const_1 + const_2) % MAXLONG;
+ *
+ * Further investigations show that the real algorithm is:
+ *
+ * seed = (seed * 0x7fffffed + 0x7fffffc3) % MAXLONG;
+ *
+ * This is checked with the test below:
+ */
+ seed = 0;
+ for (num = 0; num <= 100000; num++) {
+ expected = (seed * 0x7fffffed + 0x7fffffc3) % 0x7fffffff;
+ seed_bak = seed;
+ result = pRtlUniform(&seed);
+ ok(result == expected,
+ "test: %llu RtlUniform(&seed (seed == %lx)) returns %lx, expected %lx\n",
+ num, seed_bak, result, expected);
+ ok(seed == expected,
+ "test: %llu RtlUniform(&seed (seed == %lx)) sets seed to %lx, expected %lx\n",
+ num, seed_bak, seed, expected);
+ } /* for */
+/*
+ * More tests show that RtlUniform does not return 0x7ffffffd for seed values
+ * in the range [0..MAXLONG-1]. Additionally 2 is returned twice. This shows
+ * that there is more than one cycle of generated randon numbers ...
+ */
+}
+
+
+static ULONG WINAPI my_RtlRandom(PULONG seed)
+{
+ static ULONG saved_value[128] =
+ { /* 0 */ 0x4c8bc0aa, 0x4c022957, 0x2232827a, 0x2f1e7626, 0x7f8bdafb, 0x5c37d02a, 0x0ab48f72, 0x2f0c4ffa,
+ /* 8 */ 0x290e1954, 0x6b635f23, 0x5d3885c0, 0x74b49ff8, 0x5155fa54, 0x6214ad3f, 0x111e9c29, 0x242a3a09,
+ /* 16 */ 0x75932ae1, 0x40ac432e, 0x54f7ba7a, 0x585ccbd5, 0x6df5c727, 0x0374dad1, 0x7112b3f1, 0x735fc311,
+ /* 24 */ 0x404331a9, 0x74d97781, 0x64495118, 0x323e04be, 0x5974b425, 0x4862e393, 0x62389c1d, 0x28a68b82,
+ /* 32 */ 0x0f95da37, 0x7a50bbc6, 0x09b0091c, 0x22cdb7b4, 0x4faaed26, 0x66417ccd, 0x189e4bfa, 0x1ce4e8dd,
+ /* 40 */ 0x5274c742, 0x3bdcf4dc, 0x2d94e907, 0x32eac016, 0x26d33ca3, 0x60415a8a, 0x31f57880, 0x68c8aa52,
+ /* 48 */ 0x23eb16da, 0x6204f4a1, 0x373927c1, 0x0d24eb7c, 0x06dd7379, 0x2b3be507, 0x0f9c55b1, 0x2c7925eb,
+ /* 56 */ 0x36d67c9a, 0x42f831d9, 0x5e3961cb, 0x65d637a8, 0x24bb3820, 0x4d08e33d, 0x2188754f, 0x147e409e,
+ /* 64 */ 0x6a9620a0, 0x62e26657, 0x7bd8ce81, 0x11da0abb, 0x5f9e7b50, 0x23e444b6, 0x25920c78, 0x5fc894f0,
+ /* 72 */ 0x5e338cbb, 0x404237fd, 0x1d60f80f, 0x320a1743, 0x76013d2b, 0x070294ee, 0x695e243b, 0x56b177fd,
+ /* 80 */ 0x752492e1, 0x6decd52f, 0x125f5219, 0x139d2e78, 0x1898d11e, 0x2f7ee785, 0x4db405d8, 0x1a028a35,
+ /* 88 */ 0x63f6f323, 0x1f6d0078, 0x307cfd67, 0x3f32a78a, 0x6980796c, 0x462b3d83, 0x34b639f2, 0x53fce379,
+ /* 96 */ 0x74ba50f4, 0x1abc2c4b, 0x5eeaeb8d, 0x335a7a0d, 0x3973dd20, 0x0462d66b, 0x159813ff, 0x1e4643fd,
+ /* 104 */ 0x06bc5c62, 0x3115e3fc, 0x09101613, 0x47af2515, 0x4f11ec54, 0x78b99911, 0x3db8dd44, 0x1ec10b9b,
+ /* 112 */ 0x5b5506ca, 0x773ce092, 0x567be81a, 0x5475b975, 0x7a2cde1a, 0x494536f5, 0x34737bb4, 0x76d9750b,
+ /* 120 */ 0x2a1f6232, 0x2e49644d, 0x7dddcbe7, 0x500cebdb, 0x619dab9e, 0x48c626fe, 0x1cda3193, 0x52dabe9d };
+ ULONG rand;
+ int pos;
+ ULONG result;
+
+ rand = (*seed * 0x7fffffed + 0x7fffffc3) % 0x7fffffff;
+ *seed = (rand * 0x7fffffed + 0x7fffffc3) % 0x7fffffff;
+ pos = *seed & 0x7f;
+ result = saved_value[pos];
+ saved_value[pos] = rand;
+ return(result);
+}
+
+
+static void test_RtlRandom(void)
+{
+ ULONGLONG num;
+ ULONG seed;
+ ULONG seed_bak;
+ ULONG seed_expected;
+ ULONG result;
+ ULONG result_expected;
+
+/*
+ * Unlike RtlUniform, RtlRandom is not documented. We guess that for
+ * RtlRandom D.H. Lehmer's 1948 algorithm is used like stated in
+ * the documentation of the RtlUniform function. This algorithm is:
+ *
+ * seed = (seed * const_1 + const_2) % const_3;
+ *
+ * According to the RtlUniform documentation the random number is
+ * distributed over [0..MAXLONG], but in reality it is distributed
+ * over [0..MAXLONG-1]. Therefore const_3 might be MAXLONG + 1 or
+ * MAXLONG:
+ *
+ * seed = (seed * const_1 + const_2) % (MAXLONG + 1);
+ *
+ * or
+ *
+ * seed = (seed * const_1 + const_2) % MAXLONG;
+ *
+ * To find out const_2 we just call RtlRandom with seed set to 0:
+ */
+ seed = 0;
+ result_expected = 0x320a1743;
+ seed_expected =0x44b;
+ result = pRtlRandom(&seed);
+ ok(result == result_expected,
+ "pRtlRandom(&seed (seed == 0)) returns %lx, expected %lx\n",
+ result, result_expected);
+ ok(seed == seed_expected,
+ "pRtlRandom(&seed (seed == 0)) sets seed to %lx, expected %lx\n",
+ seed, seed_expected);
+/*
+ * Seed is not equal to result as with RtlUniform. To see more we
+ * call RtlRandom aggain with seed set to 0:
+ */
+ seed = 0;
+ result_expected = 0x7fffffc3;
+ seed_expected =0x44b;
+ result = pRtlRandom(&seed);
+ ok(result == result_expected,
+ "RtlRandom(&seed (seed == 0)) returns %lx, expected %lx\n",
+ result, result_expected);
+ ok(seed == seed_expected,
+ "RtlRandom(&seed (seed == 0)) sets seed to %lx, expected %lx\n",
+ seed, seed_expected);
+/*
+ * Seed is set to the same value as before but the result is different.
+ * To see more we call RtlRandom aggain with seed set to 0:
+ */
+ seed = 0;
+ result_expected = 0x7fffffc3;
+ seed_expected =0x44b;
+ result = pRtlRandom(&seed);
+ ok(result == result_expected,
+ "RtlRandom(&seed (seed == 0)) returns %lx, expected %lx\n",
+ result, result_expected);
+ ok(seed == seed_expected,
+ "RtlRandom(&seed (seed == 0)) sets seed to %lx, expected %lx\n",
+ seed, seed_expected);
+/*
+ * Seed is aggain set to the same value as before. This time we also
+ * have the same result as before. Interestingly the value of the
+ * result is 0x7fffffc3 which is the same value used in RtlUniform
+ * as const_2. If we do
+ *
+ * seed = 0;
+ * result = RtlUniform(&seed);
+ *
+ * we get the same result (0x7fffffc3) as with
+ *
+ * seed = 0;
+ * RtlRandom(&seed);
+ * seed = 0;
+ * result = RtlRandom(&seed);
+ *
+ * And there is another interesting thing. If we do
+ *
+ * seed = 0;
+ * RtlUniform(&seed);
+ * RtlUniform(&seed);
+ *
+ * seed is set to the value 0x44b which ist the same value that
+ *
+ * seed = 0;
+ * RtlRandom(&seed);
+ *
+ * assigns to seed. Putting these two findings together leads to
+ * the concluson that RtlRandom saves the value in some variable,
+ * like in the following algorithm:
+ *
+ * result = saved_value;
+ * saved_value = RtlUniform(&seed);
+ * RtlUniform(&seed);
+ * return(result);
+ *
+ * Now we do further tests with seed set to 1:
+ */
+ seed = 1;
+ result_expected = 0x7a50bbc6;
+ seed_expected =0x5a1;
+ result = pRtlRandom(&seed);
+ ok(result == result_expected,
+ "RtlRandom(&seed (seed == 1)) returns %lx, expected %lx\n",
+ result, result_expected);
+ ok(seed == seed_expected,
+ "RtlRandom(&seed (seed == 1)) sets seed to %lx, expected %lx\n",
+ seed, seed_expected);
+/*
+ * If there is just one saved_value the result now would be
+ * 0x7fffffc3. From this test we can see that there is more than
+ * one saved_value, like with this algorithm:
+ *
+ * result = saved_value[pos];
+ * saved_value[pos] = RtlUniform(&seed);
+ * RtlUniform(&seed);
+ * return(result);
+ *
+ * But how is the value of pos determined? The calls to RtlUniform
+ * create a sequence of random numbers. Every second random number
+ * is put into the saved_value array and is used in some later call
+ * of RtlRandom as result. The only reasonable source to determine
+ * pos are the random numbers generated by RtlUniform which are not
+ * put into the saved_value array. This are the values of seed
+ * between the two calls of RtlUniform as in this algorithm:
+ *
+ * rand = RtlUniform(&seed);
+ * RtlUniform(&seed);
+ * pos = position(seed);
+ * result = saved_value[pos];
+ * saved_value[pos] = rand;
+ * return(result);
+ *
+ * What remains to be determined is: The size of the saved_value array,
+ * the initial values of the saved_value array and the function
+ * position(seed). These tests are not shown here.
+ * The result of these tests is: The size of the saved_value array
+ * is 128, the initial values can be seen in the my_RtlRandom
+ * function and the position(seed) function is (seed & 0x7f).
+ *
+ * For a full test of RtlRandom 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++) {
+ seed_bak = seed;
+ seed_expected = seed;
+ result_expected = my_RtlRandom(&seed_expected);
+ /* The following corrections are necessary because the */
+ /* previous tests changed the saved_value array */
+ if (num == 0) {
+ result_expected = 0x7fffffc3;
+ } else if (num == 81) {
+ result_expected = 0x7fffffb1;
+ } /* if */
+ result = pRtlRandom(&seed);
+ ok(result == result_expected,
+ "test: %llu RtlUniform(&seed (seed == %lx)) returns %lx, expected %lx\n",
+ num, seed_bak, result, result_expected);
+ ok(seed == seed_expected,
+ "test: %llu RtlUniform(&seed (seed == %lx)) sets seed to %lx, expected %lx\n",
+ num, seed_bak, seed, seed_expected);
+ } /* for */
+}
+
+
+typedef struct {
+ ACCESS_MASK GrantedAccess;
+ ACCESS_MASK DesiredAccess;
+ BOOLEAN result;
+} all_accesses_t;
+
+static const all_accesses_t all_accesses[] = {
+ {0xFEDCBA76, 0xFEDCBA76, 1},
+ {0x00000000, 0xFEDCBA76, 0},
+ {0xFEDCBA76, 0x00000000, 1},
+ {0x00000000, 0x00000000, 1},
+ {0xFEDCBA76, 0xFEDCBA70, 1},
+ {0xFEDCBA70, 0xFEDCBA76, 0},
+ {0xFEDCBA76, 0xFEDC8A76, 1},
+ {0xFEDC8A76, 0xFEDCBA76, 0},
+ {0xFEDCBA76, 0xC8C4B242, 1},
+ {0xC8C4B242, 0xFEDCBA76, 0},
+};
+#define NB_ALL_ACCESSES (sizeof(all_accesses)/sizeof(*all_accesses))
+
+
+static void test_RtlAreAllAccessesGranted(void)
+{
+ size_t test_num;
+ BOOLEAN result;
+
+ for (test_num = 0; test_num < NB_ALL_ACCESSES; test_num++) {
+ result = pRtlAreAllAccessesGranted(all_accesses[test_num].GrantedAccess,
+ all_accesses[test_num].DesiredAccess);
+ ok(all_accesses[test_num].result == result,
+ "(test %d): RtlAreAllAccessesGranted(%08lx, %08lx) returns %d, expected %d\n",
+ test_num, all_accesses[test_num].GrantedAccess,
+ all_accesses[test_num].DesiredAccess,
+ result, all_accesses[test_num].result);
+ } /* for */
+}
+
+
+typedef struct {
+ ACCESS_MASK GrantedAccess;
+ ACCESS_MASK DesiredAccess;
+ BOOLEAN result;
+} any_accesses_t;
+
+static const any_accesses_t any_accesses[] = {
+ {0xFEDCBA76, 0xFEDCBA76, 1},
+ {0x00000000, 0xFEDCBA76, 0},
+ {0xFEDCBA76, 0x00000000, 0},
+ {0x00000000, 0x00000000, 0},
+ {0xFEDCBA76, 0x01234589, 0},
+ {0x00040000, 0xFEDCBA76, 1},
+ {0x00040000, 0xFED8BA76, 0},
+ {0xFEDCBA76, 0x00040000, 1},
+ {0xFED8BA76, 0x00040000, 0},
+};
+#define NB_ANY_ACCESSES (sizeof(any_accesses)/sizeof(*any_accesses))
+
+
+static void test_RtlAreAnyAccessesGranted(void)
+{
+ size_t test_num;
+ BOOLEAN result;
+
+ for (test_num = 0; test_num < NB_ANY_ACCESSES; test_num++) {
+ result = pRtlAreAnyAccessesGranted(any_accesses[test_num].GrantedAccess,
+ any_accesses[test_num].DesiredAccess);
+ ok(any_accesses[test_num].result == result,
+ "(test %d): RtlAreAnyAccessesGranted(%08lx, %08lx) returns %d, expected %d\n",
+ test_num, any_accesses[test_num].GrantedAccess,
+ any_accesses[test_num].DesiredAccess,
+ result, any_accesses[test_num].result);
+ } /* for */
+}
+
+static void test_RtlComputeCrc32(void)
+{
+ DWORD crc = 0;
+
+ if (!pRtlComputeCrc32)
+ return;
+
+ crc = pRtlComputeCrc32(crc, src, LEN);
+ ok(crc == 0x40861dc2,"Expected 0x40861dc2, got %8lx\n", crc);
+}
+
+
+typedef struct MY_HANDLE
+{
+ RTL_HANDLE RtlHandle;
+ void * MyValue;
+} MY_HANDLE;
+
+static inline void RtlpMakeHandleAllocated(RTL_HANDLE * Handle)
+{
+ ULONG_PTR *AllocatedBit = (ULONG_PTR *)(&Handle->Next);
+ *AllocatedBit = *AllocatedBit | 1;
+}
+
+static void test_HandleTables(void)
+{
+ BOOLEAN result;
+ NTSTATUS status;
+ ULONG Index;
+ MY_HANDLE * MyHandle;
+ RTL_HANDLE_TABLE HandleTable;
+
+ pRtlInitializeHandleTable(0x3FFF, sizeof(MY_HANDLE), &HandleTable);
+ MyHandle = (MY_HANDLE *)pRtlAllocateHandle(&HandleTable, &Index);
+ ok(MyHandle != NULL, "RtlAllocateHandle failed\n");
+ RtlpMakeHandleAllocated(&MyHandle->RtlHandle);
+ MyHandle = NULL;
+ result = pRtlIsValidIndexHandle(&HandleTable, Index, (RTL_HANDLE **)&MyHandle);
+ ok(result, "Handle %p wasn't valid\n", MyHandle);
+ result = pRtlFreeHandle(&HandleTable, &MyHandle->RtlHandle);
+ ok(result, "Couldn't free handle %p\n", MyHandle);
+ status = pRtlDestroyHandleTable(&HandleTable);
+ ok(status == STATUS_SUCCESS, "RtlDestroyHandleTable failed with error 0x%08lx\n", status);
+}
+
+START_TEST(rtl)
+{
+ InitFunctionPtrs();
+
+ if (pRtlCompareMemory)
+ test_RtlCompareMemory();
+ if (pRtlCompareMemoryUlong)
+ test_RtlCompareMemoryUlong();
+ if (pRtlMoveMemory)
+ test_RtlMoveMemory();
+ if (pRtlFillMemory)
+ test_RtlFillMemory();
+ if (pRtlFillMemoryUlong)
+ test_RtlFillMemoryUlong();
+ if (pRtlZeroMemory)
+ test_RtlZeroMemory();
+ if (pRtlUlonglongByteSwap)
+ test_RtlUlonglongByteSwap();
+ if (pRtlUniform)
+ test_RtlUniform();
+ if (pRtlRandom)
+ test_RtlRandom();
+ if (pRtlAreAllAccessesGranted)
+ test_RtlAreAllAccessesGranted();
+ if (pRtlAreAnyAccessesGranted)
+ test_RtlAreAnyAccessesGranted();
+ if (pRtlComputeCrc32)
+ test_RtlComputeCrc32();
+ if (pRtlInitializeHandleTable)
+ test_HandleTables();
+}
--- /dev/null
+/* Unit test suite for Rtl bitmap functions
+ *
+ * Copyright 2002 Jon Griffiths
+ *
+ * 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 some of the bitmap functions exist only
+ * in later versions of ntdll.
+ */
+
+#include "ntdll_test.h"
+
+#ifdef __WINE_WINTERNL_H
+
+/* Function ptrs for ordinal calls */
+static HMODULE hntdll = 0;
+static VOID (WINAPI *pRtlInitializeBitMap)(PRTL_BITMAP,LPBYTE,ULONG);
+static VOID (WINAPI *pRtlSetAllBits)(PRTL_BITMAP);
+static VOID (WINAPI *pRtlClearAllBits)(PRTL_BITMAP);
+static VOID (WINAPI *pRtlSetBits)(PRTL_BITMAP,ULONG,ULONG);
+static VOID (WINAPI *pRtlClearBits)(PRTL_BITMAP,ULONG,ULONG);
+static BOOLEAN (WINAPI *pRtlAreBitsSet)(PRTL_BITMAP,ULONG,ULONG);
+static BOOLEAN (WINAPI *pRtlAreBitsClear)(PRTL_BITMAP,ULONG,ULONG);
+static ULONG (WINAPI *pRtlFindSetBitsAndClear)(PRTL_BITMAP,ULONG,ULONG);
+static ULONG (WINAPI *pRtlFindClearBitsAndSet)(PRTL_BITMAP,ULONG,ULONG);
+static CCHAR (WINAPI *pRtlFindMostSignificantBit)(ULONGLONG);
+static CCHAR (WINAPI *pRtlFindLeastSignificantBit)(ULONGLONG);
+static ULONG (WINAPI *pRtlFindSetRuns)(PRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
+static ULONG (WINAPI *pRtlFindClearRuns)(PRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
+static ULONG (WINAPI *pRtlNumberOfSetBits)(PRTL_BITMAP);
+static ULONG (WINAPI *pRtlNumberOfClearBits)(PRTL_BITMAP);
+static ULONG (WINAPI *pRtlFindLongestRunSet)(PRTL_BITMAP,PULONG);
+static ULONG (WINAPI *pRtlFindLongestRunClear)(PRTL_BITMAP,PULONG);
+
+static BYTE buff[256];
+static RTL_BITMAP bm;
+
+static void InitFunctionPtrs(void)
+{
+ hntdll = LoadLibraryA("ntdll.dll");
+ ok(hntdll != 0, "LoadLibrary failed\n");
+ if (hntdll)
+ {
+ pRtlInitializeBitMap = (void *)GetProcAddress(hntdll, "RtlInitializeBitMap");
+ pRtlSetAllBits = (void *)GetProcAddress(hntdll, "RtlSetAllBits");
+ pRtlClearAllBits = (void *)GetProcAddress(hntdll, "RtlClearAllBits");
+ pRtlSetBits = (void *)GetProcAddress(hntdll, "RtlSetBits");
+ pRtlClearBits = (void *)GetProcAddress(hntdll, "RtlClearBits");
+ pRtlAreBitsSet = (void *)GetProcAddress(hntdll, "RtlAreBitsSet");
+ pRtlAreBitsClear = (void *)GetProcAddress(hntdll, "RtlAreBitsClear");
+ pRtlNumberOfSetBits = (void *)GetProcAddress(hntdll, "RtlNumberOfSetBits");
+ pRtlNumberOfClearBits = (void *)GetProcAddress(hntdll, "RtlNumberOfClearBits");
+ pRtlFindSetBitsAndClear = (void *)GetProcAddress(hntdll, "RtlFindSetBitsAndClear");
+ pRtlFindClearBitsAndSet = (void *)GetProcAddress(hntdll, "RtlFindClearBitsAndSet");
+ pRtlFindMostSignificantBit = (void *)GetProcAddress(hntdll, "RtlFindMostSignificantBit");
+ pRtlFindLeastSignificantBit = (void *)GetProcAddress(hntdll, "RtlFindLeastSignificantBit");
+ pRtlFindSetRuns = (void *)GetProcAddress(hntdll, "RtlFindSetRuns");
+ pRtlFindClearRuns = (void *)GetProcAddress(hntdll, "RtlFindClearRuns");
+ pRtlFindLongestRunSet = (void *)GetProcAddress(hntdll, "RtlFindLongestRunSet");
+ pRtlFindLongestRunClear = (void *)GetProcAddress(hntdll, "RtlFindLongestRunClear");
+ }
+}
+
+static void test_RtlInitializeBitMap(void)
+{
+ bm.SizeOfBitMap = 0;
+ bm.Buffer = 0;
+
+ memset(buff, 0, sizeof(buff));
+ buff[0] = 77; /* Check buffer is not written to during init */
+ buff[79] = 77;
+
+ pRtlInitializeBitMap(&bm, buff, 800);
+ ok(bm.SizeOfBitMap == 800, "size uninitialised\n");
+ ok(bm.Buffer == (PULONG)buff,"buffer uninitialised\n");
+ ok(buff[0] == 77 && buff[79] == 77, "wrote to buffer\n");
+}
+
+static void test_RtlSetAllBits(void)
+{
+ if (!pRtlSetAllBits)
+ return;
+
+ memset(buff, 0 , sizeof(buff));
+ pRtlInitializeBitMap(&bm, buff, 1);
+
+ pRtlSetAllBits(&bm);
+ ok(buff[0] == 0xff && buff[1] == 0xff && buff[2] == 0xff &&
+ buff[3] == 0xff, "didn't round up size\n");
+ ok(buff[4] == 0, "set more than rounded size\n");
+}
+
+static void test_RtlClearAllBits(void)
+{
+ if (!pRtlClearAllBits)
+ return;
+
+ memset(buff, 0xff , sizeof(buff));
+ pRtlInitializeBitMap(&bm, buff, 1);
+
+ pRtlClearAllBits(&bm);
+ ok(!buff[0] && !buff[1] && !buff[2] && !buff[3], "didn't round up size\n");
+ ok(buff[4] == 0xff, "cleared more than rounded size\n");
+}
+
+static void test_RtlSetBits(void)
+{
+ if (!pRtlSetBits)
+ return;
+
+ memset(buff, 0 , sizeof(buff));
+ pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
+
+ pRtlSetBits(&bm, 0, 1);
+ ok(buff[0] == 1, "didn't set 1st bit\n");
+
+ buff[0] = 0;
+ pRtlSetBits(&bm, 7, 2);
+ ok(buff[0] == 0x80 && buff[1] == 1, "didn't span w/len < 8\n");
+
+ buff[0] = buff[1] = 0;
+ pRtlSetBits(&bm, 7, 10);
+ ok(buff[0] == 0x80 && buff[1] == 0xff && buff[2] == 1, "didn't span w/len > 8\n");
+
+ buff[0] = buff[1] = buff[2] = 0;
+ pRtlSetBits(&bm, 0, 8); /* 1st byte */
+ ok(buff[0] == 0xff, "didn't set all bits\n");
+ ok(!buff[1], "set too many bits\n");
+
+ pRtlSetBits(&bm, sizeof(buff)*8-1, 1); /* last bit */
+ ok(buff[sizeof(buff)-1] == 0x80, "didn't set last bit\n");
+}
+
+static void test_RtlClearBits(void)
+{
+ if (!pRtlClearBits)
+ return;
+
+ memset(buff, 0xff , sizeof(buff));
+ pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
+
+ pRtlClearBits(&bm, 0, 1);
+ ok(buff[0] == 0xfe, "didn't clear 1st bit\n");
+
+ buff[0] = 0xff;
+ pRtlClearBits(&bm, 7, 2);
+ ok(buff[0] == 0x7f && buff[1] == 0xfe, "didn't span w/len < 8\n");
+
+ buff[0] = buff[1] = 0xff;
+ pRtlClearBits(&bm, 7, 10);
+ ok(buff[0] == 0x7f && buff[1] == 0 && buff[2] == 0xfe, "didn't span w/len > 8\n");
+
+ buff[0] = buff[1] = buff[2] = 0xff;
+ pRtlClearBits(&bm, 0, 8); /* 1st byte */
+ ok(!buff[0], "didn't clear all bits\n");
+ ok(buff[1] == 0xff, "cleared too many bits\n");
+
+ pRtlClearBits(&bm, sizeof(buff)*8-1, 1);
+ ok(buff[sizeof(buff)-1] == 0x7f, "didn't set last bit\n");
+}
+
+static void test_RtlCheckBit(void)
+{
+ BOOLEAN bRet;
+
+ memset(buff, 0 , sizeof(buff));
+ pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
+ pRtlSetBits(&bm, 0, 1);
+ pRtlSetBits(&bm, 7, 2);
+ pRtlSetBits(&bm, sizeof(buff)*8-1, 1);
+
+ bRet = RtlCheckBit(&bm, 0);
+ ok (bRet, "didn't find set bit\n");
+ bRet = RtlCheckBit(&bm, 7);
+ ok (bRet, "didn't find set bit\n");
+ bRet = RtlCheckBit(&bm, 8);
+ ok (bRet, "didn't find set bit\n");
+ bRet = RtlCheckBit(&bm, sizeof(buff)*8-1);
+ ok (bRet, "didn't find set bit\n");
+ bRet = RtlCheckBit(&bm, 1);
+ ok (!bRet, "found non set bit\n");
+ bRet = RtlCheckBit(&bm, sizeof(buff)*8-2);
+ ok (!bRet, "found non set bit\n");
+}
+
+static void test_RtlAreBitsSet(void)
+{
+ BOOLEAN bRet;
+
+ if (!pRtlAreBitsSet)
+ return;
+
+ memset(buff, 0 , sizeof(buff));
+ pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
+
+ bRet = pRtlAreBitsSet(&bm, 0, 1);
+ ok (!bRet, "found set bits after init\n");
+
+ pRtlSetBits(&bm, 0, 1);
+ bRet = pRtlAreBitsSet(&bm, 0, 1);
+ ok (bRet, "didn't find set bits\n");
+
+ buff[0] = 0;
+ pRtlSetBits(&bm, 7, 2);
+ bRet = pRtlAreBitsSet(&bm, 7, 2);
+ ok(bRet, "didn't find w/len < 8\n");
+ bRet = pRtlAreBitsSet(&bm, 6, 3);
+ ok(!bRet, "found non set bit\n");
+ bRet = pRtlAreBitsSet(&bm, 7, 3);
+ ok(!bRet, "found non set bit\n");
+
+ buff[0] = buff[1] = 0;
+ pRtlSetBits(&bm, 7, 10);
+ bRet = pRtlAreBitsSet(&bm, 7, 10);
+ ok(bRet, "didn't find w/len < 8\n");
+ bRet = pRtlAreBitsSet(&bm, 6, 11);
+ ok(!bRet, "found non set bit\n");
+ bRet = pRtlAreBitsSet(&bm, 7, 11);
+ ok(!bRet, "found non set bit\n");
+
+ buff[0] = buff[1] = buff[2] = 0;
+ pRtlSetBits(&bm, 0, 8); /* 1st byte */
+ bRet = pRtlAreBitsSet(&bm, 0, 8);
+ ok(bRet, "didn't find whole byte\n");
+
+ pRtlSetBits(&bm, sizeof(buff)*8-1, 1);
+ bRet = pRtlAreBitsSet(&bm, sizeof(buff)*8-1, 1);
+ ok(bRet, "didn't find last bit\n");
+}
+
+static void test_RtlAreBitsClear(void)
+{
+ BOOLEAN bRet;
+
+ if (!pRtlAreBitsClear)
+ return;
+
+ memset(buff, 0xff , sizeof(buff));
+ pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
+
+ bRet = pRtlAreBitsClear(&bm, 0, 1);
+ ok (!bRet, "found clear bits after init\n");
+
+ pRtlClearBits(&bm, 0, 1);
+ bRet = pRtlAreBitsClear(&bm, 0, 1);
+ ok (bRet, "didn't find set bits\n");
+
+ buff[0] = 0xff;
+ pRtlClearBits(&bm, 7, 2);
+ bRet = pRtlAreBitsClear(&bm, 7, 2);
+ ok(bRet, "didn't find w/len < 8\n");
+ bRet = pRtlAreBitsClear(&bm, 6, 3);
+ ok(!bRet, "found non clear bit\n");
+ bRet = pRtlAreBitsClear(&bm, 7, 3);
+ ok(!bRet, "found non clear bit\n");
+
+ buff[0] = buff[1] = 0xff;
+ pRtlClearBits(&bm, 7, 10);
+ bRet = pRtlAreBitsClear(&bm, 7, 10);
+ ok(bRet, "didn't find w/len < 8\n");
+ bRet = pRtlAreBitsClear(&bm, 6, 11);
+ ok(!bRet, "found non clear bit\n");
+ bRet = pRtlAreBitsClear(&bm, 7, 11);
+ ok(!bRet, "found non clear bit\n");
+
+ buff[0] = buff[1] = buff[2] = 0xff;
+ pRtlClearBits(&bm, 0, 8); /* 1st byte */
+ bRet = pRtlAreBitsClear(&bm, 0, 8);
+ ok(bRet, "didn't find whole byte\n");
+
+ pRtlClearBits(&bm, sizeof(buff)*8-1, 1);
+ bRet = pRtlAreBitsClear(&bm, sizeof(buff)*8-1, 1);
+ ok(bRet, "didn't find last bit\n");
+}
+
+static void test_RtlNumberOfSetBits(void)
+{
+ ULONG ulCount;
+
+ if (!pRtlNumberOfSetBits)
+ return;
+
+ memset(buff, 0 , sizeof(buff));
+ pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
+
+ ulCount = pRtlNumberOfSetBits(&bm);
+ ok(ulCount == 0, "set bits after init\n");
+
+ pRtlSetBits(&bm, 0, 1); /* Set 1st bit */
+ ulCount = pRtlNumberOfSetBits(&bm);
+ ok(ulCount == 1, "count wrong\n");
+
+ pRtlSetBits(&bm, 7, 8); /* 8 more, spanning bytes 1-2 */
+ ulCount = pRtlNumberOfSetBits(&bm);
+ ok(ulCount == 8+1, "count wrong\n");
+
+ pRtlSetBits(&bm, 17, 33); /* 33 more crossing ULONG boundary */
+ ulCount = pRtlNumberOfSetBits(&bm);
+ ok(ulCount == 8+1+33, "count wrong\n");
+
+ pRtlSetBits(&bm, sizeof(buff)*8-1, 1); /* Set last bit */
+ ulCount = pRtlNumberOfSetBits(&bm);
+ ok(ulCount == 8+1+33+1, "count wrong\n");
+}
+
+static void test_RtlNumberOfClearBits(void)
+{
+ ULONG ulCount;
+
+ if (!pRtlNumberOfClearBits)
+ return;
+
+ memset(buff, 0xff , sizeof(buff));
+ pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
+
+ ulCount = pRtlNumberOfClearBits(&bm);
+ ok(ulCount == 0, "cleared bits after init\n");
+
+ pRtlClearBits(&bm, 0, 1); /* Set 1st bit */
+ ulCount = pRtlNumberOfClearBits(&bm);
+ ok(ulCount == 1, "count wrong\n");
+
+ pRtlClearBits(&bm, 7, 8); /* 8 more, spanning bytes 1-2 */
+ ulCount = pRtlNumberOfClearBits(&bm);
+ ok(ulCount == 8+1, "count wrong\n");
+
+ pRtlClearBits(&bm, 17, 33); /* 33 more crossing ULONG boundary */
+ ulCount = pRtlNumberOfClearBits(&bm);
+ ok(ulCount == 8+1+33, "count wrong\n");
+
+ pRtlClearBits(&bm, sizeof(buff)*8-1, 1); /* Set last bit */
+ ulCount = pRtlNumberOfClearBits(&bm);
+ ok(ulCount == 8+1+33+1, "count wrong\n");
+}
+
+/* Note: this tests RtlFindSetBits also */
+static void test_RtlFindSetBitsAndClear(void)
+{
+ BOOLEAN bRet;
+ ULONG ulPos;
+
+ if (!pRtlFindSetBitsAndClear)
+ return;
+
+ memset(buff, 0, sizeof(buff));
+ pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
+
+ pRtlSetBits(&bm, 0, 32);
+ ulPos = pRtlFindSetBitsAndClear(&bm, 32, 0);
+ ok (ulPos == 0, "didn't find bits\n");
+ if(ulPos == 0)
+ {
+ bRet = pRtlAreBitsClear(&bm, 0, 32);
+ ok (bRet, "found but didn't clear\n");
+ }
+
+ memset(buff, 0 , sizeof(buff));
+ pRtlSetBits(&bm, 40, 77);
+ ulPos = pRtlFindSetBitsAndClear(&bm, 77, 0);
+ ok (ulPos == 40, "didn't find bits\n");
+ if(ulPos == 40)
+ {
+ bRet = pRtlAreBitsClear(&bm, 40, 77);
+ ok (bRet, "found but didn't clear\n");
+ }
+}
+
+/* Note: this tests RtlFindClearBits also */
+static void test_RtlFindClearBitsAndSet(void)
+{
+ BOOLEAN bRet;
+ ULONG ulPos;
+
+ if (!pRtlFindClearBitsAndSet)
+ return;
+
+ pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
+
+ memset(buff, 0xff, sizeof(buff));
+ pRtlSetBits(&bm, 0, 32);
+ ulPos = pRtlFindSetBitsAndClear(&bm, 32, 0);
+ ok (ulPos == 0, "didn't find bits\n");
+ if(ulPos == 0)
+ {
+ bRet = pRtlAreBitsClear(&bm, 0, 32);
+ ok (bRet, "found but didn't clear\n");
+ }
+
+ memset(buff, 0xff , sizeof(buff));
+ pRtlClearBits(&bm, 40, 77);
+ ulPos = pRtlFindClearBitsAndSet(&bm, 77, 50);
+ ok (ulPos == 40, "didn't find bits\n");
+ if(ulPos == 40)
+ {
+ bRet = pRtlAreBitsSet(&bm, 40, 77);
+ ok (bRet, "found but didn't set\n");
+ }
+}
+
+static void test_RtlFindMostSignificantBit(void)
+{
+ int i;
+ CCHAR cPos;
+ ULONGLONG ulLong;
+
+ if (!pRtlFindMostSignificantBit)
+ return;
+
+ for (i = 0; i < 64; i++)
+ {
+ ulLong = 1ul;
+ ulLong <<= i;
+
+ cPos = pRtlFindMostSignificantBit(ulLong);
+ ok (cPos == i, "didn't find MSB %llx %d %d\n", ulLong, i, cPos);
+
+ /* Set all bits lower than bit i */
+ ulLong = ((ulLong - 1) << 1) | 1;
+
+ cPos = pRtlFindMostSignificantBit(ulLong);
+ ok (cPos == i, "didn't find MSB %llx %d %d\n", ulLong, i, cPos);
+ }
+ cPos = pRtlFindMostSignificantBit(0);
+ ok (cPos == -1, "found bit when not set\n");
+}
+
+static void test_RtlFindLeastSignificantBit(void)
+{
+ int i;
+ CCHAR cPos;
+ ULONGLONG ulLong;
+
+ if (!pRtlFindLeastSignificantBit)
+ return;
+
+ for (i = 0; i < 64; i++)
+ {
+ ulLong = (ULONGLONG)1 << i;
+
+ cPos = pRtlFindLeastSignificantBit(ulLong);
+ ok (cPos == i, "didn't find LSB %llx %d %d\n", ulLong, i, cPos);
+
+ ulLong = ~((ULONGLONG)0) << i;
+
+ cPos = pRtlFindLeastSignificantBit(ulLong);
+ ok (cPos == i, "didn't find LSB %llx %d %d\n", ulLong, i, cPos);
+ }
+ cPos = pRtlFindLeastSignificantBit(0);
+ ok (cPos == -1, "found bit when not set\n");
+}
+
+/* Note: Also tests RtlFindLongestRunSet() */
+static void test_RtlFindSetRuns(void)
+{
+ RTL_BITMAP_RUN runs[16];
+ ULONG ulCount;
+
+ if (!pRtlFindSetRuns)
+ return;
+
+ pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
+
+ memset(buff, 0, sizeof(buff));
+ ulCount = pRtlFindSetRuns(&bm, runs, 16, TRUE);
+ ok (ulCount == 0, "found set bits in empty bitmap\n");
+
+ memset(runs, 0, sizeof(runs));
+ memset(buff, 0xff, sizeof(buff));
+ ulCount = pRtlFindSetRuns(&bm, runs, 16, TRUE);
+ ok (ulCount == 1, "didn't find set bits\n");
+ ok (runs[0].StartingIndex == 0,"bad start\n");
+ ok (runs[0].NumberOfBits == sizeof(buff)*8,"bad size\n");
+
+ /* Set up 3 runs */
+ memset(runs, 0, sizeof(runs));
+ memset(buff, 0, sizeof(buff));
+ pRtlSetBits(&bm, 7, 19);
+ pRtlSetBits(&bm, 101, 3);
+ pRtlSetBits(&bm, 1877, 33);
+
+ /* Get first 2 */
+ ulCount = pRtlFindSetRuns(&bm, runs, 2, FALSE);
+ ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 101,"bad find\n");
+ ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 101,"bad find\n");
+ ok (runs[0].NumberOfBits + runs[1].NumberOfBits == 19 + 3,"bad size\n");
+ ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
+ ok (runs[2].StartingIndex == 0,"found extra run\n");
+
+ /* Get longest 3 */
+ memset(runs, 0, sizeof(runs));
+ ulCount = pRtlFindSetRuns(&bm, runs, 2, TRUE);
+ ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 1877,"bad find\n");
+ ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 1877,"bad find\n");
+ ok (runs[0].NumberOfBits + runs[1].NumberOfBits == 33 + 19,"bad size\n");
+ ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
+ ok (runs[2].StartingIndex == 0,"found extra run\n");
+
+ /* Get all 3 */
+ memset(runs, 0, sizeof(runs));
+ ulCount = pRtlFindSetRuns(&bm, runs, 3, TRUE);
+ ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 101 ||
+ runs[0].StartingIndex == 1877,"bad find\n");
+ ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 101 ||
+ runs[1].StartingIndex == 1877,"bad find\n");
+ ok (runs[2].StartingIndex == 7 || runs[2].StartingIndex == 101 ||
+ runs[2].StartingIndex == 1877,"bad find\n");
+ ok (runs[0].NumberOfBits + runs[1].NumberOfBits
+ + runs[2].NumberOfBits == 19 + 3 + 33,"bad size\n");
+ ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
+ ok (runs[1].StartingIndex != runs[2].StartingIndex,"found run twice\n");
+ ok (runs[3].StartingIndex == 0,"found extra run\n");
+
+ if (pRtlFindLongestRunSet)
+ {
+ ULONG ulStart = 0;
+
+ ulCount = pRtlFindLongestRunSet(&bm, &ulStart);
+ ok(ulCount == 33 && ulStart == 1877,"didn't find longest %ld %ld\n",ulCount,ulStart);
+
+ memset(buff, 0, sizeof(buff));
+ ulCount = pRtlFindLongestRunSet(&bm, &ulStart);
+ ok(ulCount == 0,"found longest when none set\n");
+ }
+}
+
+/* Note: Also tests RtlFindLongestRunClear() */
+static void test_RtlFindClearRuns(void)
+{
+ RTL_BITMAP_RUN runs[16];
+ ULONG ulCount;
+
+ if (!pRtlFindClearRuns)
+ return;
+
+ pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
+
+ memset(buff, 0xff, sizeof(buff));
+ ulCount = pRtlFindClearRuns(&bm, runs, 16, TRUE);
+ ok (ulCount == 0, "found clear bits in full bitmap\n");
+
+ memset(runs, 0, sizeof(runs));
+ memset(buff, 0, sizeof(buff));
+ ulCount = pRtlFindClearRuns(&bm, runs, 16, TRUE);
+ ok (ulCount == 1, "didn't find clear bits\n");
+ ok (runs[0].StartingIndex == 0,"bad start\n");
+ ok (runs[0].NumberOfBits == sizeof(buff)*8,"bad size\n");
+
+ /* Set up 3 runs */
+ memset(runs, 0, sizeof(runs));
+ memset(buff, 0xff, sizeof(buff));
+ pRtlClearBits(&bm, 7, 19);
+ pRtlClearBits(&bm, 101, 3);
+ pRtlClearBits(&bm, 1877, 33);
+
+ /* Get first 2 */
+ ulCount = pRtlFindClearRuns(&bm, runs, 2, FALSE);
+ ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 101,"bad find\n");
+ ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 101,"bad find\n");
+ ok (runs[0].NumberOfBits + runs[1].NumberOfBits == 19 + 3,"bad size\n");
+ ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
+ ok (runs[2].StartingIndex == 0,"found extra run\n");
+
+ /* Get longest 3 */
+ memset(runs, 0, sizeof(runs));
+ ulCount = pRtlFindClearRuns(&bm, runs, 2, TRUE);
+ ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 1877,"bad find\n");
+ ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 1877,"bad find\n");
+ ok (runs[0].NumberOfBits + runs[1].NumberOfBits == 33 + 19,"bad size\n");
+ ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
+ ok (runs[2].StartingIndex == 0,"found extra run\n");
+
+ /* Get all 3 */
+ memset(runs, 0, sizeof(runs));
+ ulCount = pRtlFindClearRuns(&bm, runs, 3, TRUE);
+ ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 101 ||
+ runs[0].StartingIndex == 1877,"bad find\n");
+ ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 101 ||
+ runs[1].StartingIndex == 1877,"bad find\n");
+ ok (runs[2].StartingIndex == 7 || runs[2].StartingIndex == 101 ||
+ runs[2].StartingIndex == 1877,"bad find\n");
+ ok (runs[0].NumberOfBits + runs[1].NumberOfBits
+ + runs[2].NumberOfBits == 19 + 3 + 33,"bad size\n");
+ ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
+ ok (runs[1].StartingIndex != runs[2].StartingIndex,"found run twice\n");
+ ok (runs[3].StartingIndex == 0,"found extra run\n");
+
+ if (pRtlFindLongestRunClear)
+ {
+ ULONG ulStart = 0;
+
+ ulCount = pRtlFindLongestRunClear(&bm, &ulStart);
+ ok(ulCount == 33 && ulStart == 1877,"didn't find longest\n");
+
+ memset(buff, 0xff, sizeof(buff));
+ ulCount = pRtlFindLongestRunClear(&bm, &ulStart);
+ ok(ulCount == 0,"found longest when none clear\n");
+ }
+
+}
+#endif
+
+START_TEST(rtlbitmap)
+{
+#ifdef __WINE_WINTERNL_H
+ InitFunctionPtrs();
+
+ if (pRtlInitializeBitMap)
+ {
+ test_RtlInitializeBitMap();
+ test_RtlSetAllBits();
+ test_RtlClearAllBits();
+ test_RtlSetBits();
+ test_RtlClearBits();
+ test_RtlCheckBit();
+ test_RtlAreBitsSet();
+ test_RtlAreBitsClear();
+ test_RtlNumberOfSetBits();
+ test_RtlNumberOfClearBits();
+ test_RtlFindSetBitsAndClear();
+ test_RtlFindClearBitsAndSet();
+ test_RtlFindMostSignificantBit();
+ test_RtlFindLeastSignificantBit();
+ test_RtlFindSetRuns();
+ test_RtlFindClearRuns();
+ }
+#endif
+}
--- /dev/null
+/* Unit test suite for Rtl string functions
+ *
+ * Copyright 2002 Robert Shearman
+ * 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>
+
+#define INITGUID
+
+#include "ntdll_test.h"
+#include "winnls.h"
+#include "guiddef.h"
+
+/* Function ptrs for ntdll calls */
+static HMODULE hntdll = 0;
+static NTSTATUS (WINAPI *pRtlAnsiStringToUnicodeString)(PUNICODE_STRING, PCANSI_STRING, BOOLEAN);
+static NTSTATUS (WINAPI *pRtlAppendAsciizToString)(STRING *, LPCSTR);
+static NTSTATUS (WINAPI *pRtlAppendStringToString)(STRING *, const STRING *);
+static NTSTATUS (WINAPI *pRtlAppendUnicodeStringToString)(UNICODE_STRING *, const UNICODE_STRING *);
+static NTSTATUS (WINAPI *pRtlAppendUnicodeToString)(UNICODE_STRING *, LPCWSTR);
+static NTSTATUS (WINAPI *pRtlCharToInteger)(PCSZ, ULONG, int *);
+static VOID (WINAPI *pRtlCopyString)(STRING *, const STRING *);
+static BOOLEAN (WINAPI *pRtlCreateUnicodeString)(PUNICODE_STRING, LPCWSTR);
+static BOOLEAN (WINAPI *pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING, LPCSTR);
+static NTSTATUS (WINAPI *pRtlDowncaseUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);
+static NTSTATUS (WINAPI *pRtlDuplicateUnicodeString)(long, UNICODE_STRING *, UNICODE_STRING *);
+static BOOLEAN (WINAPI *pRtlEqualUnicodeString)(const UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);
+static NTSTATUS (WINAPI *pRtlFindCharInUnicodeString)(int, const UNICODE_STRING *, const UNICODE_STRING *, USHORT *);
+static VOID (WINAPI *pRtlFreeAnsiString)(PSTRING);
+static VOID (WINAPI *pRtlInitAnsiString)(PSTRING, LPCSTR);
+static VOID (WINAPI *pRtlInitString)(PSTRING, LPCSTR);
+static VOID (WINAPI *pRtlInitUnicodeString)(PUNICODE_STRING, LPCWSTR);
+static NTSTATUS (WINAPI *pRtlInitUnicodeStringEx)(PUNICODE_STRING, LPCWSTR);
+static NTSTATUS (WINAPI *pRtlIntegerToChar)(ULONG, ULONG, ULONG, PCHAR);
+static NTSTATUS (WINAPI *pRtlIntegerToUnicodeString)(ULONG, ULONG, UNICODE_STRING *);
+static NTSTATUS (WINAPI *pRtlMultiAppendUnicodeStringBuffer)(UNICODE_STRING *, long, UNICODE_STRING *);
+static NTSTATUS (WINAPI *pRtlUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN);
+static NTSTATUS (WINAPI *pRtlUnicodeStringToInteger)(const UNICODE_STRING *, int, int *);
+static WCHAR (WINAPI *pRtlUpcaseUnicodeChar)(WCHAR);
+static NTSTATUS (WINAPI *pRtlUpcaseUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);
+static CHAR (WINAPI *pRtlUpperChar)(CHAR);
+static NTSTATUS (WINAPI *pRtlUpperString)(STRING *, const STRING *);
+static NTSTATUS (WINAPI *pRtlValidateUnicodeString)(long, UNICODE_STRING *);
+static NTSTATUS (WINAPI *pRtlGUIDFromString)(const UNICODE_STRING*,GUID*);
+static NTSTATUS (WINAPI *pRtlStringFromGUID)(const GUID*, UNICODE_STRING*);
+
+/*static VOID (WINAPI *pRtlFreeOemString)(PSTRING);*/
+/*static VOID (WINAPI *pRtlFreeUnicodeString)(PUNICODE_STRING);*/
+/*static VOID (WINAPI *pRtlCopyUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *);*/
+/*static VOID (WINAPI *pRtlEraseUnicodeString)(UNICODE_STRING *);*/
+/*static LONG (WINAPI *pRtlCompareString)(const STRING *,const STRING *,BOOLEAN);*/
+/*static LONG (WINAPI *pRtlCompareUnicodeString)(const UNICODE_STRING *,const UNICODE_STRING *,BOOLEAN);*/
+/*static BOOLEAN (WINAPI *pRtlEqualString)(const STRING *,const STRING *,BOOLEAN);*/
+/*static BOOLEAN (WINAPI *pRtlPrefixString)(const STRING *, const STRING *, BOOLEAN);*/
+/*static BOOLEAN (WINAPI *pRtlPrefixUnicodeString)(const UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);*/
+/*static NTSTATUS (WINAPI *pRtlOemStringToUnicodeString)(PUNICODE_STRING, const STRING *, BOOLEAN);*/
+/*static NTSTATUS (WINAPI *pRtlUnicodeStringToOemString)(STRING *, const UNICODE_STRING *, BOOLEAN);*/
+/*static NTSTATUS (WINAPI *pRtlMultiByteToUnicodeN)(LPWSTR, DWORD, LPDWORD, LPCSTR, DWORD);*/
+/*static NTSTATUS (WINAPI *pRtlOemToUnicodeN)(LPWSTR, DWORD, LPDWORD, LPCSTR, DWORD);*/
+/*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN);*/
+/*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeStringToOemString)(STRING *, const UNICODE_STRING *, BOOLEAN);*/
+/*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeToMultiByteN)(LPSTR, DWORD, LPDWORD, LPCWSTR, DWORD);*/
+/*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeToOemN)(LPSTR, DWORD, LPDWORD, LPCWSTR, DWORD);*/
+/*static UINT (WINAPI *pRtlOemToUnicodeSize)(const STRING *);*/
+/*static DWORD (WINAPI *pRtlAnsiStringToUnicodeSize)(const STRING *);*/
+/*static DWORD (WINAPI *pRtlIsTextUnicode)(LPVOID, DWORD, DWORD *);*/
+
+
+static WCHAR* AtoW( const char* p )
+{
+ WCHAR* buffer;
+ DWORD len = MultiByteToWideChar( CP_ACP, 0, p, -1, NULL, 0 );
+ buffer = malloc( len * sizeof(WCHAR) );
+ MultiByteToWideChar( CP_ACP, 0, p, -1, buffer, len );
+ return buffer;
+}
+
+
+static void InitFunctionPtrs(void)
+{
+ 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");
+ 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");
+ 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");
+ }
+}
+
+
+static void test_RtlInitString(void)
+{
+ 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); */
+}
+
+
+static void test_RtlInitUnicodeString(void)
+{
+#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); */
+}
+
+
+#define TESTSTRING2_LEN 1000000
+/* #define TESTSTRING2_LEN 32766 */
+
+
+static void test_RtlInitUnicodeStringEx(void)
+{
+ 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;
+
+ teststring2 = (WCHAR *) malloc((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 %x\n",
+ result, STATUS_SUCCESS);
+ 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 %x\n",
+ result, STATUS_NAME_TOO_LONG);
+ ok(uni.Length == 12345,
+ "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u\n",
+ uni.Length, 12345);
+ ok(uni.MaximumLength == 12345,
+ "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u\n",
+ uni.MaximumLength, 12345);
+ ok(uni.Buffer == (void *) 0xdeadbeef,
+ "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %x\n",
+ uni.Buffer, 0xdeadbeef);
+
+ uni.Length = 12345;
+ uni.MaximumLength = 12345;
+ uni.Buffer = (void *) 0xdeadbeef;
+ pRtlInitUnicodeString(&uni, teststring2);
+ ok(uni.Length == 33920,
+ "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n",
+ uni.Length, 33920);
+ ok(uni.MaximumLength == 33922,
+ "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n",
+ uni.MaximumLength, 33922);
+ 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 %x\n",
+ result, STATUS_SUCCESS);
+ 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);
+}
+
+
+typedef struct {
+ int add_nul;
+ int source_Length;
+ int source_MaximumLength;
+ int source_buf_size;
+ const char *source_buf;
+ int dest_Length;
+ int dest_MaximumLength;
+ int dest_buf_size;
+ const char *dest_buf;
+ int res_Length;
+ int res_MaximumLength;
+ int res_buf_size;
+ const char *res_buf;
+ NTSTATUS result;
+} dupl_ustr_t;
+
+static const dupl_ustr_t dupl_ustr[] = {
+ { 0, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 32, 32, 32, "This is a string", STATUS_SUCCESS},
+ { 0, 32, 32, 32, "This is a string", 40, 42, 42, "--------------------", 32, 32, 32, "This is a string", STATUS_SUCCESS},
+ { 0, 32, 30, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 0, 32, 34, 34, "This is a string", 40, 42, 42, NULL, 32, 32, 32, "This is a string", STATUS_SUCCESS},
+ { 0, 32, 32, 32, "This is a string", 40, 42, 42, NULL, 32, 32, 32, "This is a string", STATUS_SUCCESS},
+ { 0, 32, 30, 34, "This is a string", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 1, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 32, 34, 34, "This is a string", STATUS_SUCCESS},
+ { 1, 32, 32, 32, "This is a string", 40, 42, 42, "--------------------", 32, 34, 34, "This is a string", STATUS_SUCCESS},
+ { 1, 32, 30, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 1, 32, 34, 34, "This is a string", 40, 42, 42, NULL, 32, 34, 34, "This is a string", STATUS_SUCCESS},
+ { 1, 32, 32, 32, "This is a string", 40, 42, 42, NULL, 32, 34, 34, "This is a string", STATUS_SUCCESS},
+ { 1, 32, 30, 34, "This is a string", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 2, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 2, 32, 32, 32, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 2, 32, 30, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 2, 32, 34, 34, "This is a string", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 2, 32, 32, 32, "This is a string", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 2, 32, 30, 34, "This is a string", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 3, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 32, 34, 34, "This is a string", STATUS_SUCCESS},
+ { 3, 32, 32, 32, "This is a string", 40, 42, 42, "--------------------", 32, 34, 34, "This is a string", STATUS_SUCCESS},
+ { 3, 32, 30, 32, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 3, 32, 34, 34, "This is a string", 40, 42, 42, NULL, 32, 34, 34, "This is a string", STATUS_SUCCESS},
+ { 3, 32, 32, 32, "This is a string", 40, 42, 42, NULL, 32, 34, 34, "This is a string", STATUS_SUCCESS},
+ { 3, 32, 30, 32, "This is a string", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 4, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 5, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 6, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 7, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 8, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 9, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ {10, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ {11, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ {12, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ {13, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ {14, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ {15, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ {16, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ {-1, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ {-5, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ {-9, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 0, 0, 2, 2, "", 40, 42, 42, "--------------------", 0, 0, 0, NULL, STATUS_SUCCESS},
+ { 0, 0, 0, 0, "", 40, 42, 42, "--------------------", 0, 0, 0, NULL, STATUS_SUCCESS},
+ { 0, 0, 2, 2, "", 40, 42, 42, NULL, 0, 0, 0, NULL, STATUS_SUCCESS},
+ { 0, 0, 0, 0, "", 40, 42, 42, NULL, 0, 0, 0, NULL, STATUS_SUCCESS},
+ { 0, 0, 2, 2, NULL, 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 0, 0, 0, 0, NULL, 40, 42, 42, "--------------------", 0, 0, 0, NULL, STATUS_SUCCESS},
+ { 0, 0, 2, 2, NULL, 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 0, 0, 0, 0, NULL, 40, 42, 42, NULL, 0, 0, 0, NULL, STATUS_SUCCESS},
+ { 1, 0, 2, 2, "", 40, 42, 42, "--------------------", 0, 0, 0, NULL, STATUS_SUCCESS},
+ { 1, 0, 0, 0, "", 40, 42, 42, "--------------------", 0, 0, 0, NULL, STATUS_SUCCESS},
+ { 1, 0, 2, 2, "", 40, 42, 42, NULL, 0, 0, 0, NULL, STATUS_SUCCESS},
+ { 1, 0, 0, 0, "", 40, 42, 42, NULL, 0, 0, 0, NULL, STATUS_SUCCESS},
+ { 1, 0, 2, 2, NULL, 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 1, 0, 0, 0, NULL, 40, 42, 42, "--------------------", 0, 0, 0, NULL, STATUS_SUCCESS},
+ { 1, 0, 2, 2, NULL, 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 1, 0, 0, 0, NULL, 40, 42, 42, NULL, 0, 0, 0, NULL, STATUS_SUCCESS},
+ { 2, 0, 2, 2, "", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 2, 0, 0, 0, "", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 2, 0, 2, 2, "", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 2, 0, 0, 0, "", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 2, 0, 2, 2, NULL, 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 2, 0, 0, 0, NULL, 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 2, 0, 2, 2, NULL, 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 2, 0, 0, 0, NULL, 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 3, 0, 2, 2, "", 40, 42, 42, "--------------------", 0, 2, 2, "", STATUS_SUCCESS},
+ { 3, 0, 0, 0, "", 40, 42, 42, "--------------------", 0, 2, 2, "", STATUS_SUCCESS},
+ { 3, 0, 2, 2, "", 40, 42, 42, NULL, 0, 2, 2, "", STATUS_SUCCESS},
+ { 3, 0, 0, 0, "", 40, 42, 42, NULL, 0, 2, 2, "", STATUS_SUCCESS},
+ { 3, 0, 2, 2, NULL, 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
+ { 3, 0, 0, 0, NULL, 40, 42, 42, "--------------------", 0, 2, 2, "", STATUS_SUCCESS},
+ { 3, 0, 2, 2, NULL, 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER},
+ { 3, 0, 0, 0, NULL, 40, 42, 42, NULL, 0, 2, 2, "", STATUS_SUCCESS},
+};
+#define NB_DUPL_USTR (sizeof(dupl_ustr)/sizeof(*dupl_ustr))
+
+
+static void test_RtlDuplicateUnicodeString(void)
+{
+ 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;
+ size_t test_num;
+
+ for (test_num = 0; test_num < NB_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);
+ } 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);
+ }
+ }
+}
+
+
+static void test_RtlCopyString(void)
+{
+ 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");
+}
+
+
+static void test_RtlUpperChar(void)
+{
+ 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);
+ }
+}
+
+
+static void test_RtlUpperString(void)
+{
+ 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");
+}
+
+
+static void test_RtlUpcaseUnicodeChar(void)
+{
+ 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);
+ }
+}
+
+
+static void test_RtlUpcaseUnicodeString(void)
+{
+ int i;
+ 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]);
+ }
+}
+
+
+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 */
+ }
+ 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,
+ "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]);
+ }
+}
+
+
+typedef struct {
+ int ansi_Length;
+ int ansi_MaximumLength;
+ int ansi_buf_size;
+ const char *ansi_buf;
+ int uni_Length;
+ int uni_MaximumLength;
+ int uni_buf_size;
+ const char *uni_buf;
+ BOOLEAN doalloc;
+ int res_Length;
+ int res_MaximumLength;
+ int res_buf_size;
+ const char *res_buf;
+ NTSTATUS result;
+} ustr2astr_t;
+
+static const ustr2astr_t ustr2astr[] = {
+ { 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},
+ { 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},
+ { 0, 0, 12, NULL, 10, 10, 12, NULL, FALSE, 5, 0, 0, NULL, STATUS_BUFFER_OVERFLOW},
+};
+#define NB_USTR2ASTR (sizeof(ustr2astr)/sizeof(*ustr2astr))
+
+
+static void test_RtlUnicodeStringToAnsiString(void)
+{
+ size_t pos;
+ CHAR ansi_buf[257];
+ WCHAR uni_buf[257];
+ STRING ansi_str;
+ UNICODE_STRING uni_str;
+ NTSTATUS result;
+ size_t test_num;
+
+ for (test_num = 0; test_num < NB_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,
+ "(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);
+ }
+}
+
+
+typedef struct {
+ int dest_Length;
+ int dest_MaximumLength;
+ int dest_buf_size;
+ const char *dest_buf;
+ const char *src;
+ int res_Length;
+ int res_MaximumLength;
+ int res_buf_size;
+ const char *res_buf;
+ NTSTATUS result;
+} app_asc2str_t;
+
+static const app_asc2str_t app_asc2str[] = {
+ { 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},
+};
+#define NB_APP_ASC2STR (sizeof(app_asc2str)/sizeof(*app_asc2str))
+
+
+static void test_RtlAppendAsciizToString(void)
+{
+ CHAR dest_buf[257];
+ STRING dest_str;
+ NTSTATUS result;
+ size_t test_num;
+
+ for (test_num = 0; test_num < NB_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);
+ }
+ }
+}
+
+
+typedef struct {
+ int dest_Length;
+ int dest_MaximumLength;
+ int dest_buf_size;
+ const char *dest_buf;
+ int src_Length;
+ int src_MaximumLength;
+ int src_buf_size;
+ const char *src_buf;
+ int res_Length;
+ int res_MaximumLength;
+ int res_buf_size;
+ const char *res_buf;
+ NTSTATUS result;
+} app_str2str_t;
+
+static const app_str2str_t app_str2str[] = {
+ { 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},
+};
+#define NB_APP_STR2STR (sizeof(app_str2str)/sizeof(*app_str2str))
+
+
+static void test_RtlAppendStringToString(void)
+{
+ CHAR dest_buf[257];
+ CHAR src_buf[257];
+ STRING dest_str;
+ STRING src_str;
+ NTSTATUS result;
+ size_t test_num;
+
+ for (test_num = 0; test_num < NB_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);
+ }
+ }
+}
+
+
+typedef struct {
+ int dest_Length;
+ int dest_MaximumLength;
+ int dest_buf_size;
+ const char *dest_buf;
+ const char *src;
+ int res_Length;
+ int res_MaximumLength;
+ int res_buf_size;
+ const char *res_buf;
+ NTSTATUS result;
+} app_uni2str_t;
+
+static const app_uni2str_t app_uni2str[] = {
+ { 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},
+/* In the following test the native function writes beyond MaximumLength
+ * { 4, 9, 14, "Fake0123abcdef", "Ustr\0", 8, 9, 14, "FakeUstrabcdef", 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},
+};
+#define NB_APP_UNI2STR (sizeof(app_uni2str)/sizeof(*app_uni2str))
+
+
+static void test_RtlAppendUnicodeToString(void)
+{
+ WCHAR dest_buf[257];
+ UNICODE_STRING dest_str;
+ NTSTATUS result;
+ size_t test_num;
+
+ for (test_num = 0; test_num < NB_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);
+ }
+ }
+}
+
+
+typedef struct {
+ int dest_Length;
+ int dest_MaximumLength;
+ int dest_buf_size;
+ const char *dest_buf;
+ int src_Length;
+ int src_MaximumLength;
+ int src_buf_size;
+ const char *src_buf;
+ int res_Length;
+ int res_MaximumLength;
+ int res_buf_size;
+ const char *res_buf;
+ NTSTATUS result;
+} app_ustr2str_t;
+
+static const app_ustr2str_t app_ustr2str[] = {
+ { 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},
+/* In the following test the native function writes beyond MaximumLength
+ * { 4, 9, 14, "Fake0123abcdef", 4, 6, 8, "UstrZYXW", 8, 9, 14, "FakeUstrabcdef", 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},
+};
+#define NB_APP_USTR2STR (sizeof(app_ustr2str)/sizeof(*app_ustr2str))
+
+
+static void test_RtlAppendUnicodeStringToString(void)
+{
+ WCHAR dest_buf[257];
+ WCHAR src_buf[257];
+ UNICODE_STRING dest_str;
+ UNICODE_STRING src_str;
+ NTSTATUS result;
+ size_t test_num;
+
+ for (test_num = 0; test_num < NB_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);
+ }
+ }
+}
+
+
+typedef struct {
+ int flags;
+ const char *main_str;
+ const char *search_chars;
+ USHORT pos;
+ NTSTATUS result;
+} find_ch_in_ustr_t;
+
+static const find_ch_in_ustr_t find_ch_in_ustr[] = {
+ { 0, "Some Wild String", "S", 2, STATUS_SUCCESS},
+ { 0, "This is a String", "String", 6, STATUS_SUCCESS},
+ { 1, "This is a String", "String", 30, STATUS_SUCCESS},
+ { 2, "This is a String", "String", 2, STATUS_SUCCESS},
+ { 3, "This is a String", "String", 18, STATUS_SUCCESS},
+ { 0, "This is a String", "Wild", 6, STATUS_SUCCESS},
+ { 1, "This is a String", "Wild", 26, STATUS_SUCCESS},
+ { 2, "This is a String", "Wild", 2, STATUS_SUCCESS},
+ { 3, "This is a String", "Wild", 30, STATUS_SUCCESS},
+ { 0, "abcdefghijklmnopqrstuvwxyz", "", 0, STATUS_NOT_FOUND},
+ { 0, "abcdefghijklmnopqrstuvwxyz", "123", 0, STATUS_NOT_FOUND},
+ { 0, "abcdefghijklmnopqrstuvwxyz", "a", 2, STATUS_SUCCESS},
+ { 0, "abcdefghijklmnopqrstuvwxyz", "12a34", 2, STATUS_SUCCESS},
+ { 0, "abcdefghijklmnopqrstuvwxyz", "12b34", 4, STATUS_SUCCESS},
+ { 0, "abcdefghijklmnopqrstuvwxyz", "12y34", 50, STATUS_SUCCESS},
+ { 0, "abcdefghijklmnopqrstuvwxyz", "12z34", 52, STATUS_SUCCESS},
+ { 0, "abcdefghijklmnopqrstuvwxyz", "rvz", 36, STATUS_SUCCESS},
+ { 0, "abcdefghijklmmlkjihgfedcba", "egik", 10, STATUS_SUCCESS},
+ { 1, "abcdefghijklmnopqrstuvwxyz", "", 0, STATUS_NOT_FOUND},
+ { 1, "abcdefghijklmnopqrstuvwxyz", "rvz", 50, STATUS_SUCCESS},
+ { 1, "abcdefghijklmnopqrstuvwxyz", "ravy", 48, STATUS_SUCCESS},
+ { 1, "abcdefghijklmnopqrstuvwxyz", "raxv", 46, STATUS_SUCCESS},
+ { 2, "abcdefghijklmnopqrstuvwxyz", "", 2, STATUS_SUCCESS},
+ { 2, "abcdefghijklmnopqrstuvwxyz", "rvz", 2, STATUS_SUCCESS},
+ { 2, "abcdefghijklmnopqrstuvwxyz", "vaz", 4, STATUS_SUCCESS},
+ { 2, "abcdefghijklmnopqrstuvwxyz", "ravbz", 6, STATUS_SUCCESS},
+ { 3, "abcdefghijklmnopqrstuvwxyz", "", 50, STATUS_SUCCESS},
+ { 3, "abcdefghijklmnopqrstuvwxyz", "123", 50, STATUS_SUCCESS},
+ { 3, "abcdefghijklmnopqrstuvwxyz", "ahp", 50, STATUS_SUCCESS},
+ { 3, "abcdefghijklmnopqrstuvwxyz", "rvz", 48, STATUS_SUCCESS},
+ { 0, NULL, "abc", 0, STATUS_NOT_FOUND},
+ { 1, NULL, "abc", 0, STATUS_NOT_FOUND},
+ { 2, NULL, "abc", 0, STATUS_NOT_FOUND},
+ { 3, NULL, "abc", 0, STATUS_NOT_FOUND},
+ { 0, "abcdefghijklmnopqrstuvwxyz", NULL, 0, STATUS_NOT_FOUND},
+ { 1, "abcdefghijklmnopqrstuvwxyz", NULL, 0, STATUS_NOT_FOUND},
+ { 2, "abcdefghijklmnopqrstuvwxyz", NULL, 2, STATUS_SUCCESS},
+ { 3, "abcdefghijklmnopqrstuvwxyz", NULL, 50, STATUS_SUCCESS},
+ { 0, NULL, NULL, 0, STATUS_NOT_FOUND},
+ { 1, NULL, NULL, 0, STATUS_NOT_FOUND},
+ { 2, NULL, NULL, 0, STATUS_NOT_FOUND},
+ { 3, NULL, NULL, 0, STATUS_NOT_FOUND},
+ { 0, "abcdabcdabcdabcdabcdabcd", "abcd", 2, STATUS_SUCCESS},
+ { 1, "abcdabcdabcdabcdabcdabcd", "abcd", 46, STATUS_SUCCESS},
+ { 2, "abcdabcdabcdabcdabcdabcd", "abcd", 0, STATUS_NOT_FOUND},
+ { 3, "abcdabcdabcdabcdabcdabcd", "abcd", 0, STATUS_NOT_FOUND},
+};
+#define NB_FIND_CH_IN_USTR (sizeof(find_ch_in_ustr)/sizeof(*find_ch_in_ustr))
+
+
+static void test_RtlFindCharInUnicodeStri
projects / reactos.git / commitdiff