Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-04-05 13:11:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Update ntdll winetests

Browse source 
- Warning: the reg test may bsod/restart your Windows system- not a problem in ros though

svn path=/trunk/; revision=38035
This commit is contained in:
Gregor Schneider 2008-12-12 23:42:40 +00:00
parent 88f1899dcb
commit 9bb14d43db
13 changed files with 790 additions and 351 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
rostests/winetests/ntdll/atom.c
View file

@ -54,6 +54,7 @@ static NTSTATUS (WINAPI *pRtlPinAtomInAtomTable)(RTL_ATOM_TABLE,RTL_ATOM);
static NTSTATUS (WINAPI *pRtlQueryAtomInAtomTable)(RTL_ATOM_TABLE,RTL_ATOM,PULONG,PULONG,PWSTR,PULONG);
static NTSTATUS (WINAPI* pNtAddAtom)(LPCWSTR,ULONG,RTL_ATOM*);
static NTSTATUS (WINAPI* pNtAddAtomNT4)(LPCWSTR,RTL_ATOM*);
static NTSTATUS (WINAPI* pNtQueryInformationAtom)(RTL_ATOM,DWORD,void*,ULONG,PULONG);
static const WCHAR EmptyAtom[] = {0};
@ -266,7 +267,8 @@ static void test_NtAtom(void)
Len = 0;
res = pRtlQueryAtomInAtomTable(AtomTable, Atom1, NULL, NULL, Name, &Len);
ok(res == STATUS_BUFFER_TOO_SMALL, "Got wrong retval, retval: %x\n", res);
ok((lstrlenW(testAtom1) * sizeof(WCHAR)) == Len, "Got wrong length %x\n", Len);
ok((lstrlenW(testAtom1) * sizeof(WCHAR)) == Len || broken(!Len) /* nt4 */, "Got wrong length %x\n", Len);
if (!Len) pNtAddAtomNT4 = (void *)pNtAddAtom;
res = pRtlPinAtomInAtomTable(AtomTable, Atom1);
ok(!res, "Unable to pin atom in atom table, retval: %x\n", res);
@ -305,7 +307,7 @@ static void test_NtIntAtom(void)
{
/* According to the kernel32 functions, integer atoms are only allowed from
* 0x0001 to 0xbfff and not 0xc000 to 0xffff, which is correct */
res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)0, &testAtom);
res = pRtlAddAtomToAtomTable(AtomTable, NULL, &testAtom);
ok(res == STATUS_INVALID_PARAMETER, "Didn't get expected result from adding 0 int atom, retval: %x\n", res);
for (i = 1; i <= 0xbfff; i++)
{
@ -433,7 +435,11 @@ static void test_Global(void)
ATOM_BASIC_INFORMATION* abi = (ATOM_BASIC_INFORMATION*)ptr;
ULONG ptr_size = sizeof(ATOM_BASIC_INFORMATION) + 255 * sizeof(WCHAR);
res = pNtAddAtom(testAtom1, lstrlenW(testAtom1) * sizeof(WCHAR), &atom);
if (pNtAddAtomNT4)
res = pNtAddAtomNT4(testAtom1, &atom);
else
res = pNtAddAtom(testAtom1, lstrlenW(testAtom1) * sizeof(WCHAR), &atom);
ok(!res, "Added atom (%x)\n", res);
memset(abi->Name, 0xcc, 255 * sizeof(WCHAR));
@ -447,7 +453,8 @@ static void test_Global(void)
ptr_size = sizeof(ATOM_BASIC_INFORMATION);
res = pNtQueryInformationAtom( atom, AtomBasicInformation, (void*)ptr, ptr_size, NULL );
ok(res == STATUS_BUFFER_TOO_SMALL, "wrong return status (%x)\n", res);
ok(abi->NameLength == lstrlenW(testAtom1) * sizeof(WCHAR), "ok string length\n");
ok(abi->NameLength == lstrlenW(testAtom1) * sizeof(WCHAR) || broken(abi->NameLength == sizeof(WCHAR)), /* nt4 */
"string length %u\n",abi->NameLength);
memset(abi->Name, 0xcc, lstrlenW(testAtom1) * sizeof(WCHAR));
ptr_size = sizeof(ATOM_BASIC_INFORMATION) + lstrlenW(testAtom1) * sizeof(WCHAR);
@ -476,4 +483,8 @@ START_TEST(atom)
test_NtRefPinAtom();
test_Global();
}
else
win_skip("Needed atom functions are not available\n");
FreeLibrary(hntdll);
}

52
rostests/winetests/ntdll/env.c
View file

@ -57,6 +57,7 @@ static void testQuery(void)
int len;
NTSTATUS status;
const char *val;
NTSTATUS alt;
};
static const struct test tests[] =
@ -67,12 +68,13 @@ static void testQuery(void)
{"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"},
{"foo", 4, STATUS_SUCCESS, "toto", STATUS_BUFFER_TOO_SMALL},
{"foo", 5, 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=an", 256, STATUS_SUCCESS, "ouo", STATUS_VARIABLE_NOT_FOUND},
{"sr", 256, STATUS_SUCCESS, "an=ouo"},
{"=oOH", 256, STATUS_SUCCESS, "III"},
{"", 256, STATUS_VARIABLE_NOT_FOUND, NULL},
@ -99,7 +101,8 @@ static void testQuery(void)
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 %x got %x\n",
ok( nts == test->status || (test->alt && nts == test->alt),
"[%d]: Wrong status for '%s', expecting %x got %x\n",
test - tests, test->var, test->status, nts );
if (nts == test->status) switch (nts)
{
@ -120,7 +123,7 @@ static void testQuery(void)
}
}
static void testSetHelper(LPWSTR* env, const char* var, const char* val, NTSTATUS ret)
static void testSetHelper(LPWSTR* env, const char* var, const char* val, NTSTATUS ret, NTSTATUS alt)
{
WCHAR bvar[256], bval1[256], bval2[256];
UNICODE_STRING uvar;
@ -139,7 +142,7 @@ static void testSetHelper(LPWSTR* env, const char* var, const char* val, NTSTATU
pRtlMultiByteToUnicodeN( bval1, sizeof(bval1), NULL, val, strlen(val)+1 );
}
nts = pRtlSetEnvironmentVariable(env, &uvar, val ? &uval : NULL);
ok(nts == ret, "Setting var %s=%s (%x/%x)\n", var, val, nts, ret);
ok(nts == ret || (alt && nts == alt), "Setting var %s=%s (%x/%x)\n", var, val, nts, ret);
if (nts == STATUS_SUCCESS)
{
uval.Length = 0;
@ -152,7 +155,9 @@ static void testSetHelper(LPWSTR* env, const char* var, const char* val, NTSTATU
ok(lstrcmpW(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);
ok(val == NULL ||
broken(strchr(var,'=') != NULL), /* variable containing '=' may be set but not found again on NT4 */
"Couldn't find variable, but didn't delete it. val = %s\n", val);
break;
default:
ok(0, "Wrong ret %u for %s\n", nts, var);
@ -168,31 +173,30 @@ static void testSet(void)
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);
testSetHelper(&env, "cat", "dog", STATUS_SUCCESS, 0);
testSetHelper(&env, "cat", "horse", STATUS_SUCCESS, 0);
testSetHelper(&env, "cat", "zz", STATUS_SUCCESS, 0);
testSetHelper(&env, "cat", NULL, STATUS_SUCCESS, 0);
testSetHelper(&env, "cat", NULL, STATUS_SUCCESS, STATUS_VARIABLE_NOT_FOUND);
testSetHelper(&env, "foo", "meouw", STATUS_SUCCESS, 0);
testSetHelper(&env, "me=too", "also", STATUS_SUCCESS, STATUS_INVALID_PARAMETER);
testSetHelper(&env, "me", "too=also", STATUS_SUCCESS, 0);
testSetHelper(&env, "=too", "also", STATUS_SUCCESS, 0);
testSetHelper(&env, "=", "also", STATUS_SUCCESS, 0);
for (i = 0; i < 128; i++)
{
sprintf(tmp, "zork%03d", i);
testSetHelper(&env, tmp, "is alive", STATUS_SUCCESS);
testSetHelper(&env, tmp, "is alive", STATUS_SUCCESS, 0);
}
for (i = 0; i < 128; i++)
{
sprintf(tmp, "zork%03d", i);
testSetHelper(&env, tmp, NULL, STATUS_SUCCESS);
testSetHelper(&env, tmp, NULL, STATUS_SUCCESS, 0);
}
testSetHelper(&env, "fOo", NULL, STATUS_SUCCESS);
testSetHelper(&env, "fOo", NULL, STATUS_SUCCESS, 0);
ok(pRtlDestroyEnvironment(env) == STATUS_SUCCESS, "Destroying environment\n");
}
@ -263,9 +267,6 @@ static void testExpand(void)
ok(nts == STATUS_BUFFER_TOO_SMALL, "Call failed (%u)\n", nts);
ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR),
"Wrong returned length for %s (with buffer too small): %u\n", test->src, ul);
ok(memcmp(dst, rst, 8*sizeof(WCHAR)) == 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]);
}
@ -274,6 +275,11 @@ static void testExpand(void)
START_TEST(env)
{
HMODULE mod = GetModuleHandleA("ntdll.dll");
if (!mod)
{
win_skip("Not running on NT, skipping tests\n");
return;
}
pRtlMultiByteToUnicodeN = (void *)GetProcAddress(mod,"RtlMultiByteToUnicodeN");
pRtlCreateEnvironment = (void*)GetProcAddress(mod, "RtlCreateEnvironment");

9
rostests/winetests/ntdll/error.c
View file

@ -57,7 +57,10 @@ static int prepare_test(void)
ntdll = LoadLibraryA("ntdll.dll");
pRtlNtStatusToDosError = (void*)GetProcAddress(ntdll, "RtlNtStatusToDosError");
if (!pRtlNtStatusToDosError)
{
win_skip("RtlNtStatusToDosError is not available\n");
return 0;
}
argc = winetest_get_mainargs(&argv);
strict=(argc >= 3 && strcmp(argv[2],"strict")==0);
@ -186,7 +189,7 @@ static void run_error_tests(void)
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);
cmp3(STATUS_LPC_REPLY_LOST, ERROR_INTERNAL_ERROR, ERROR_CONNECTION_ABORTED);
cmp(STATUS_INVALID_PARAMETER, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_1, ERROR_INVALID_PARAMETER);
cmp(STATUS_INVALID_PARAMETER_2, ERROR_INVALID_PARAMETER);
@ -735,8 +738,8 @@ static void run_error_tests(void)
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);
cmp3(STATUS_DUPLICATE_OBJECTID, STATUS_DUPLICATE_OBJECTID, ERROR_OBJECT_ALREADY_EXISTS);
cmp3(STATUS_OBJECTID_EXISTS, STATUS_OBJECTID_EXISTS, ERROR_OBJECT_ALREADY_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);

104
rostests/winetests/ntdll/exception.c
View file

@ -21,6 +21,10 @@
#include <stdarg.h>
#include <stdio.h>
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x500 /* For NTSTATUS */
#endif
#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "windef.h"
@ -61,110 +65,115 @@ static const struct exception
} exceptions[] =
{
/* test some privileged instructions */
{ { 0xfb, 0xc3 }, /* sti; ret */
{ { 0xfb, 0xc3 }, /* 0: sti; ret */
0, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0x6c, 0xc3 }, /* insb (%dx); ret */
{ { 0x6c, 0xc3 }, /* 1: insb (%dx); ret */
0, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0x6d, 0xc3 }, /* insl (%dx); ret */
{ { 0x6d, 0xc3 }, /* 2: insl (%dx); ret */
0, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0x6e, 0xc3 }, /* outsb (%dx); ret */
{ { 0x6e, 0xc3 }, /* 3: outsb (%dx); ret */
0, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0x6f, 0xc3 }, /* outsl (%dx); ret */
{ { 0x6f, 0xc3 }, /* 4: outsl (%dx); ret */
0, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0xe4, 0x11, 0xc3 }, /* inb $0x11,%al; ret */
{ { 0xe4, 0x11, 0xc3 }, /* 5: inb $0x11,%al; ret */
0, 2, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0xe5, 0x11, 0xc3 }, /* inl $0x11,%eax; ret */
{ { 0xe5, 0x11, 0xc3 }, /* 6: inl $0x11,%eax; ret */
0, 2, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0xe6, 0x11, 0xc3 }, /* outb %al,$0x11; ret */
{ { 0xe6, 0x11, 0xc3 }, /* 7: outb %al,$0x11; ret */
0, 2, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0xe7, 0x11, 0xc3 }, /* outl %eax,$0x11; ret */
{ { 0xe7, 0x11, 0xc3 }, /* 8: outl %eax,$0x11; ret */
0, 2, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0xed, 0xc3 }, /* inl (%dx),%eax; ret */
{ { 0xed, 0xc3 }, /* 9: inl (%dx),%eax; ret */
0, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0xee, 0xc3 }, /* outb %al,(%dx); ret */
{ { 0xee, 0xc3 }, /* 10: outb %al,(%dx); ret */
0, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0xef, 0xc3 }, /* outl %eax,(%dx); ret */
{ { 0xef, 0xc3 }, /* 11: outl %eax,(%dx); ret */
0, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0xf4, 0xc3 }, /* hlt; ret */
{ { 0xf4, 0xc3 }, /* 12: hlt; ret */
0, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0xfa, 0xc3 }, /* cli; ret */
{ { 0xfa, 0xc3 }, /* 13: cli; ret */
0, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 },
/* test long jump to invalid selector */
{ { 0xea, 0, 0, 0, 0, 0, 0, 0xc3 }, /* ljmp $0,$0; ret */
{ { 0xea, 0, 0, 0, 0, 0, 0, 0xc3 }, /* 14: ljmp $0,$0; ret */
0, 7, STATUS_ACCESS_VIOLATION, 2, { 0, 0xffffffff } },
/* test iret to invalid selector */
{ { 0x6a, 0x00, 0x6a, 0x00, 0x6a, 0x00, 0xcf, 0x83, 0xc4, 0x0c, 0xc3 },
/* pushl $0; pushl $0; pushl $0; iret; addl $12,%esp; ret */
/* 15: pushl $0; pushl $0; pushl $0; iret; addl $12,%esp; ret */
6, 1, STATUS_ACCESS_VIOLATION, 2, { 0, 0xffffffff } },
/* test loading an invalid selector */
{ { 0xb8, 0xef, 0xbe, 0x00, 0x00, 0x8e, 0xe8, 0xc3 }, /* mov $beef,%ax; mov %ax,%gs; ret */
{ { 0xb8, 0xef, 0xbe, 0x00, 0x00, 0x8e, 0xe8, 0xc3 }, /* 16: mov $beef,%ax; mov %ax,%gs; ret */
5, 2, STATUS_ACCESS_VIOLATION, 2, { 0, 0xbee8 } }, /* 0xbee8 or 0xffffffff */
/* test accessing a zero selector */
{ { 0x06, 0x31, 0xc0, 0x8e, 0xc0, 0x26, 0xa1, 0, 0, 0, 0, 0x07, 0xc3 },
/* push %es; xor %eax,%eax; mov %ax,%es; mov %es:(0),%ax; pop %es */
/* 17: push %es; xor %eax,%eax; mov %ax,%es; mov %es:(0),%ax; pop %es; ret */
5, 6, STATUS_ACCESS_VIOLATION, 2, { 0, 0xffffffff } },
/* test moving %cs -> %ss */
{ { 0x0e, 0x17, 0x58, 0xc3 }, /* pushl %cs; popl %ss; popl %eax; ret */
{ { 0x0e, 0x17, 0x58, 0xc3 }, /* 18: pushl %cs; popl %ss; popl %eax; ret */
1, 1, STATUS_ACCESS_VIOLATION, 2, { 0, 0xffffffff } },
/* test overlong instruction (limit is 16 bytes) */
/* 19: test overlong instruction (limit is 16 bytes) */
{ { 0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0xfa,0xc3 },
0, 16, STATUS_ILLEGAL_INSTRUCTION, 0 },
{ { 0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0xfa,0xc3 },
0, 15, STATUS_PRIVILEGED_INSTRUCTION, 0 },
/* test invalid interrupt */
{ { 0xcd, 0xff, 0xc3 }, /* int $0xff; ret */
{ { 0xcd, 0xff, 0xc3 }, /* 21: int $0xff; ret */
0, 2, STATUS_ACCESS_VIOLATION, 2, { 0, 0xffffffff } },
/* test moves to/from Crx */
{ { 0x0f, 0x20, 0xc0, 0xc3 }, /* movl %cr0,%eax; ret */
{ { 0x0f, 0x20, 0xc0, 0xc3 }, /* 22: movl %cr0,%eax; ret */
0, 3, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0x0f, 0x20, 0xe0, 0xc3 }, /* movl %cr4,%eax; ret */
{ { 0x0f, 0x20, 0xe0, 0xc3 }, /* 23: movl %cr4,%eax; ret */
0, 3, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0x0f, 0x22, 0xc0, 0xc3 }, /* movl %eax,%cr0; ret */
{ { 0x0f, 0x22, 0xc0, 0xc3 }, /* 24: movl %eax,%cr0; ret */
0, 3, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0x0f, 0x22, 0xe0, 0xc3 }, /* movl %eax,%cr4; ret */
{ { 0x0f, 0x22, 0xe0, 0xc3 }, /* 25: movl %eax,%cr4; ret */
0, 3, STATUS_PRIVILEGED_INSTRUCTION, 0 },
/* test moves to/from Drx */
{ { 0x0f, 0x21, 0xc0, 0xc3 }, /* movl %dr0,%eax; ret */
{ { 0x0f, 0x21, 0xc0, 0xc3 }, /* 26: movl %dr0,%eax; ret */
0, 3, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0x0f, 0x21, 0xc8, 0xc3 }, /* movl %dr1,%eax; ret */
{ { 0x0f, 0x21, 0xc8, 0xc3 }, /* 27: movl %dr1,%eax; ret */
0, 3, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0x0f, 0x21, 0xf8, 0xc3 }, /* movl %dr7,%eax; ret */
{ { 0x0f, 0x21, 0xf8, 0xc3 }, /* 28: movl %dr7,%eax; ret */
0, 3, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0x0f, 0x23, 0xc0, 0xc3 }, /* movl %eax,%dr0; ret */
{ { 0x0f, 0x23, 0xc0, 0xc3 }, /* 29: movl %eax,%dr0; ret */
0, 3, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0x0f, 0x23, 0xc8, 0xc3 }, /* movl %eax,%dr1; ret */
{ { 0x0f, 0x23, 0xc8, 0xc3 }, /* 30: movl %eax,%dr1; ret */
0, 3, STATUS_PRIVILEGED_INSTRUCTION, 0 },
{ { 0x0f, 0x23, 0xf8, 0xc3 }, /* movl %eax,%dr7; ret */
{ { 0x0f, 0x23, 0xf8, 0xc3 }, /* 31: movl %eax,%dr7; ret */
0, 3, STATUS_PRIVILEGED_INSTRUCTION, 0 },
/* test memory reads */
{ { 0xa1, 0xfc, 0xff, 0xff, 0xff, 0xc3 }, /* movl 0xfffffffc,%eax; ret */
{ { 0xa1, 0xfc, 0xff, 0xff, 0xff, 0xc3 }, /* 32: movl 0xfffffffc,%eax; ret */
0, 5, STATUS_ACCESS_VIOLATION, 2, { 0, 0xfffffffc } },
{ { 0xa1, 0xfd, 0xff, 0xff, 0xff, 0xc3 }, /* movl 0xfffffffd,%eax; ret */
{ { 0xa1, 0xfd, 0xff, 0xff, 0xff, 0xc3 }, /* 33: movl 0xfffffffd,%eax; ret */
0, 5, STATUS_ACCESS_VIOLATION, 2, { 0, 0xfffffffd } },
{ { 0xa1, 0xfe, 0xff, 0xff, 0xff, 0xc3 }, /* movl 0xfffffffe,%eax; ret */
{ { 0xa1, 0xfe, 0xff, 0xff, 0xff, 0xc3 }, /* 34: movl 0xfffffffe,%eax; ret */
0, 5, STATUS_ACCESS_VIOLATION, 2, { 0, 0xfffffffe } },
{ { 0xa1, 0xff, 0xff, 0xff, 0xff, 0xc3 }, /* movl 0xffffffff,%eax; ret */
{ { 0xa1, 0xff, 0xff, 0xff, 0xff, 0xc3 }, /* 35: movl 0xffffffff,%eax; ret */
0, 5, STATUS_ACCESS_VIOLATION, 2, { 0, 0xffffffff } },
/* test memory writes */
{ { 0xa3, 0xfc, 0xff, 0xff, 0xff, 0xc3 }, /* movl %eax,0xfffffffc; ret */
{ { 0xa3, 0xfc, 0xff, 0xff, 0xff, 0xc3 }, /* 36: movl %eax,0xfffffffc; ret */
0, 5, STATUS_ACCESS_VIOLATION, 2, { 1, 0xfffffffc } },
{ { 0xa3, 0xfd, 0xff, 0xff, 0xff, 0xc3 }, /* movl %eax,0xfffffffd; ret */
{ { 0xa3, 0xfd, 0xff, 0xff, 0xff, 0xc3 }, /* 37: movl %eax,0xfffffffd; ret */
0, 5, STATUS_ACCESS_VIOLATION, 2, { 1, 0xfffffffd } },
{ { 0xa3, 0xfe, 0xff, 0xff, 0xff, 0xc3 }, /* movl %eax,0xfffffffe; ret */
{ { 0xa3, 0xfe, 0xff, 0xff, 0xff, 0xc3 }, /* 38: movl %eax,0xfffffffe; ret */
0, 5, STATUS_ACCESS_VIOLATION, 2, { 1, 0xfffffffe } },
{ { 0xa3, 0xff, 0xff, 0xff, 0xff, 0xc3 }, /* movl %eax,0xffffffff; ret */
{ { 0xa3, 0xff, 0xff, 0xff, 0xff, 0xc3 }, /* 39: movl %eax,0xffffffff; ret */
0, 5, STATUS_ACCESS_VIOLATION, 2, { 1, 0xffffffff } },
/* 40: test exception with cleared %ds and %es */
{ { 0x1e, 0x06, 0x31, 0xc0, 0x8e, 0xd8, 0x8e, 0xc0, 0xfa, 0x07, 0x1f, 0xc3 },
/* push %ds; push %es; xorl %eax,%eax; mov %ax,%ds; mov %ax,%es; cli; pop %es; pop %ds; ret */
8, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 },
};
static int got_exception;
@ -190,7 +199,7 @@ static void run_exception_test(void *handler, const void* context,
pNtCurrentTeb()->Tib.ExceptionList = exc_frame.frame.Prev;
}
LONG CALLBACK rtlraiseexception_vectored_handler(EXCEPTION_POINTERS *ExceptionInfo)
static LONG CALLBACK rtlraiseexception_vectored_handler(EXCEPTION_POINTERS *ExceptionInfo)
{
PCONTEXT context = ExceptionInfo->ContextRecord;
PEXCEPTION_RECORD rec = ExceptionInfo->ExceptionRecord;
@ -211,8 +220,10 @@ LONG CALLBACK rtlraiseexception_vectored_handler(EXCEPTION_POINTERS *ExceptionIn
*/
if(rec->ExceptionCode == EXCEPTION_BREAKPOINT)
{
ok(context->Eip == (DWORD)code_mem + 0xa, "Eip at %x instead of %x\n",
context->Eip, (DWORD)code_mem + 0xa);
ok(context->Eip == (DWORD)code_mem + 0xa ||
broken(context->Eip == (DWORD)code_mem + 0xb), /* win2k3 */
"Eip at %x instead of %x or %x\n", context->Eip,
(DWORD)code_mem + 0xa, (DWORD)code_mem + 0xb);
}
else
{
@ -241,8 +252,10 @@ static DWORD rtlraiseexception_handler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTR
*/
if(rec->ExceptionCode == EXCEPTION_BREAKPOINT)
{
ok(context->Eip == (DWORD)code_mem + 0xa, "Eip at %x instead of %x\n",
context->Eip, (DWORD)code_mem + 0xa);
ok(context->Eip == (DWORD)code_mem + 0xa ||
broken(context->Eip == (DWORD)code_mem + 0xb), /* win2k3 */
"Eip at %x instead of %x or %x\n", context->Eip,
(DWORD)code_mem + 0xa, (DWORD)code_mem + 0xb);
}
else
{
@ -488,13 +501,14 @@ static DWORD direction_flag_handler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATI
{
#ifdef __GNUC__
unsigned int flags;
__asm__("pushfl; popl %0" : "=r" (flags) );
__asm__("pushfl; popl %0; cld" : "=r" (flags) );
/* older windows versions don't clear DF properly so don't test */
if (flags & 0x400) trace( "eflags has DF bit set\n" );
#endif
ok( context->EFlags & 0x400, "context eflags has DF bit cleared\n" );
got_exception++;
context->Eip++; /* skip cli */
context->EFlags &= ~0x400; /* make sure it is cleared on return */
return ExceptionContinueExecution;
}

142
rostests/winetests/ntdll/file.c
View file

@ -2,6 +2,7 @@
*
* Copyright 2007 Jeff Latimer
* Copyright 2007 Andrey Turkin
* Copyright 2008 Jeff Zaroyko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@ -26,7 +27,6 @@
#include <stdarg.h>
#include "ntstatus.h"
/* Define WIN32_NO_STATUS so MSVC does not give us duplicate macro
* definition errors when we get to winnt.h
*/
@ -39,9 +39,12 @@
#define IO_COMPLETION_ALL_ACCESS 0x001F0003
#endif
static NTSTATUS (WINAPI *pRtlFreeUnicodeString)( PUNICODE_STRING );
static VOID (WINAPI *pRtlInitUnicodeString)( PUNICODE_STRING, LPCWSTR );
static BOOL (WINAPI *pRtlDosPathNameToNtPathName_U)( LPCWSTR, PUNICODE_STRING, PWSTR*, CURDIR* );
static NTSTATUS (WINAPI *pNtCreateMailslotFile)( PHANDLE, ULONG, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK,
ULONG, ULONG, ULONG, PLARGE_INTEGER );
static NTSTATUS (WINAPI *pNtDeleteFile)(POBJECT_ATTRIBUTES ObjectAttributes);
static NTSTATUS (WINAPI *pNtReadFile)(HANDLE hFile, HANDLE hEvent,
PIO_APC_ROUTINE apc, void* apc_user,
PIO_STATUS_BLOCK io_status, void* buffer, ULONG length,
@ -66,6 +69,7 @@ static inline BOOL is_signaled( HANDLE obj )
}
#define PIPENAME "\\\\.\\pipe\\ntdll_tests_file.c"
#define TEST_BUF_LEN 3
static BOOL create_pipe( HANDLE *read, HANDLE *write, ULONG flags, ULONG size )
{
@ -136,6 +140,68 @@ static void WINAPI apc( void *arg, IO_STATUS_BLOCK *iosb, ULONG reserved )
ok( !reserved, "reserved is not 0: %x\n", reserved );
}
static void delete_file_test(void)
{
NTSTATUS ret;
OBJECT_ATTRIBUTES attr;
UNICODE_STRING nameW;
WCHAR pathW[MAX_PATH];
WCHAR pathsubW[MAX_PATH];
static const WCHAR testdirW[] = {'n','t','d','e','l','e','t','e','f','i','l','e',0};
static const WCHAR subdirW[] = {'\\','s','u','b',0};
ret = GetTempPathW(MAX_PATH, pathW);
if (!ret)
{
ok(0, "couldn't get temp dir\n");
return;
}
if (ret + sizeof(testdirW)/sizeof(WCHAR)-1 + sizeof(subdirW)/sizeof(WCHAR)-1 >= MAX_PATH)
{
ok(0, "MAX_PATH exceeded in constructing paths\n");
return;
}
lstrcatW(pathW, testdirW);
lstrcpyW(pathsubW, pathW);
lstrcatW(pathsubW, subdirW);
ret = CreateDirectoryW(pathW, NULL);
ok(ret == TRUE, "couldn't create directory ntdeletefile\n");
if (!pRtlDosPathNameToNtPathName_U(pathW, &nameW, NULL, NULL))
{
ok(0,"RtlDosPathNametoNtPathName_U failed\n");
return;
}
attr.Length = sizeof(attr);
attr.RootDirectory = 0;
attr.Attributes = OBJ_CASE_INSENSITIVE;
attr.ObjectName = &nameW;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
/* test NtDeleteFile on an empty directory */
ret = pNtDeleteFile(&attr);
ok(ret == STATUS_SUCCESS, "NtDeleteFile should succeed in removing an empty directory\n");
ret = RemoveDirectoryW(pathW);
ok(ret == FALSE, "expected to fail removing directory, NtDeleteFile should have removed it\n");
/* test NtDeleteFile on a non-empty directory */
ret = CreateDirectoryW(pathW, NULL);
ok(ret == TRUE, "couldn't create directory ntdeletefile ?!\n");
ret = CreateDirectoryW(pathsubW, NULL);
ok(ret == TRUE, "couldn't create directory subdir\n");
ret = pNtDeleteFile(&attr);
ok(ret == STATUS_SUCCESS, "expected NtDeleteFile to ret STATUS_SUCCESS\n");
ret = RemoveDirectoryW(pathsubW);
ok(ret == TRUE, "expected to remove directory ntdeletefile\\sub\n");
ret = RemoveDirectoryW(pathW);
ok(ret == TRUE, "expected to remove directory ntdeletefile, NtDeleteFile failed.\n");
pRtlFreeUnicodeString( &nameW );
}
static void read_file_test(void)
{
const char text[] = "foobar";
@ -311,7 +377,9 @@ static void read_file_test(void)
offset.QuadPart = 0;
ResetEvent( event );
status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, strlen(text) + 10, &offset, NULL );
ok( status == STATUS_SUCCESS, "wrong status %x\n", status );
ok( status == STATUS_SUCCESS ||
status == STATUS_PENDING, /* vista */
"wrong status %x\n", status );
ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
ok( is_signaled( event ), "event is signaled\n" );
@ -325,13 +393,25 @@ static void read_file_test(void)
iosb.Information = 0xdeadbeef;
offset.QuadPart = strlen(text) + 2;
status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, &offset, NULL );
ok( status == STATUS_END_OF_FILE, "wrong status %x\n", status );
ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
ok( !is_signaled( event ), "event is signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( !apc_count, "apc was called\n" );
if (status == STATUS_PENDING) /* vista */
{
ok( U(iosb).Status == STATUS_END_OF_FILE, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
ok( is_signaled( event ), "event is signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( apc_count == 1, "apc was not called\n" );
}
else
{
ok( status == STATUS_END_OF_FILE, "wrong status %x\n", status );
ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
ok( !is_signaled( event ), "event is signaled\n" );
ok( !apc_count, "apc was called\n" );
SleepEx( 1, TRUE ); /* alertable sleep */
ok( !apc_count, "apc was called\n" );
}
CloseHandle( handle );
/* now a non-overlapped file */
@ -341,7 +421,9 @@ static void read_file_test(void)
iosb.Information = 0xdeadbeef;
offset.QuadPart = 0;
pNtWriteFile( handle, event, apc, &apc_count, &iosb, text, strlen(text), &offset, NULL );
ok( status == STATUS_END_OF_FILE, "wrong status %x\n", status );
ok( status == STATUS_END_OF_FILE ||
status == STATUS_PENDING, /* vista */
"wrong status %x\n", status );
ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
ok( is_signaled( event ), "event is signaled\n" );
@ -403,7 +485,8 @@ static void nt_mailslot_test(void)
pRtlInitUnicodeString(&str, buffer1);
InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
DesiredAccess = CreateOptions = MailslotQuota = MaxMessageSize = 0;
CreateOptions = MailslotQuota = MaxMessageSize = 0;
DesiredAccess = GENERIC_READ;
/*
* Check for NULL pointer handling
@ -411,15 +494,20 @@ static void nt_mailslot_test(void)
rc = pNtCreateMailslotFile(NULL, DesiredAccess,
&attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
&TimeOut);
ok( rc == STATUS_ACCESS_VIOLATION, "rc = %x not c0000005 STATUS_ACCESS_VIOLATION\n", rc);
ok( rc == STATUS_ACCESS_VIOLATION ||
rc == STATUS_INVALID_PARAMETER, /* win2k3 */
"rc = %x not STATUS_ACCESS_VIOLATION or STATUS_INVALID_PARAMETER\n", rc);
/*
* Test to see if the Timeout can be NULL
*/
hslot = (HANDLE)0xdeadbeef;
rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
&attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
NULL);
ok( rc == STATUS_SUCCESS, "rc = %x not STATUS_SUCCESS\n", rc);
ok( rc == STATUS_SUCCESS ||
rc == STATUS_INVALID_PARAMETER, /* win2k3 */
"rc = %x not STATUS_SUCCESS or STATUS_INVALID_PARAMETER\n", rc);
ok( hslot != 0, "Handle is invalid\n");
if ( rc == STATUS_SUCCESS ) rc = pNtClose(hslot);
@ -451,7 +539,9 @@ static void nt_mailslot_test(void)
rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
&attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
&TimeOut);
ok( rc == STATUS_OBJECT_PATH_SYNTAX_BAD, "rc = %x not c000003b STATUS_OBJECT_PATH_SYNTAX_BAD\n", rc);
ok( rc == STATUS_OBJECT_PATH_SYNTAX_BAD ||
rc == STATUS_INVALID_PARAMETER,
"rc = %x not STATUS_OBJECT_PATH_SYNTAX_BAD or STATUS_INVALID_PARAMETER\n", rc);
if (rc == STATUS_SUCCESS) pNtClose(hslot);
@ -462,7 +552,7 @@ static void nt_mailslot_test(void)
rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
&attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
&TimeOut);
ok( rc == STATUS_SUCCESS, "Create MailslotFile failed rc = %x %u\n", rc, GetLastError());
ok( rc == STATUS_SUCCESS, "Create MailslotFile failed rc = %x\n", rc);
ok( hslot != 0, "Handle is invalid\n");
rc = pNtClose(hslot);
@ -526,7 +616,7 @@ static void test_iocp_fileio(HANDLE h)
if (hPipeClt != INVALID_HANDLE_VALUE)
{
OVERLAPPED o = {0,};
BYTE buf[3];
BYTE send_buf[TEST_BUF_LEN], recv_buf[TEST_BUF_LEN];
DWORD read;
long count;
@ -534,12 +624,14 @@ static void test_iocp_fileio(HANDLE h)
ok( res == STATUS_SUCCESS, "NtSetInformationFile failed: %x\n", res );
ok( U(iosb).Status == STATUS_SUCCESS, "iosb.Status invalid: %x\n", U(iosb).Status );
memset( send_buf, 0, TEST_BUF_LEN );
memset( recv_buf, 0xde, TEST_BUF_LEN );
count = get_pending_msgs(h);
ok( !count, "Unexpected msg count: %ld\n", count );
ReadFile( hPipeSrv, buf, 3, &read, &o);
ReadFile( hPipeSrv, recv_buf, TEST_BUF_LEN, &read, &o);
count = get_pending_msgs(h);
ok( !count, "Unexpected msg count: %ld\n", count );
WriteFile( hPipeClt, buf, 3, &read, NULL );
WriteFile( hPipeClt, send_buf, TEST_BUF_LEN, &read, NULL );
if (get_msg(h))
{
@ -547,14 +639,17 @@ static void test_iocp_fileio(HANDLE h)
ok( ioSb.Information == 3, "Invalid ioSb.Information: %ld\n", ioSb.Information );
ok( U(ioSb).Status == STATUS_SUCCESS, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
ok( completionValue == (ULONG_PTR)&o, "Invalid completion value: %lx\n", completionValue );
ok( !memcmp( send_buf, recv_buf, TEST_BUF_LEN ), "Receive buffer (%x %x %x) did not match send buffer (%x %x %x)\n", recv_buf[0], recv_buf[1], recv_buf[2], send_buf[0], send_buf[1], send_buf[2] );
}
count = get_pending_msgs(h);
ok( !count, "Unexpected msg count: %ld\n", count );
WriteFile( hPipeClt, buf, 2, &read, NULL );
memset( send_buf, 0, TEST_BUF_LEN );
memset( recv_buf, 0xde, TEST_BUF_LEN );
WriteFile( hPipeClt, send_buf, 2, &read, NULL );
count = get_pending_msgs(h);
ok( !count, "Unexpected msg count: %ld\n", count );
ReadFile( hPipeSrv, buf, 2, &read, &o);
ReadFile( hPipeSrv, recv_buf, 2, &read, &o);
count = get_pending_msgs(h);
ok( count == 1, "Unexpected msg count: %ld\n", count );
if (get_msg(h))
@ -563,9 +658,10 @@ static void test_iocp_fileio(HANDLE h)
ok( ioSb.Information == 2, "Invalid ioSb.Information: %ld\n", ioSb.Information );
ok( U(ioSb).Status == STATUS_SUCCESS, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
ok( completionValue == (ULONG_PTR)&o, "Invalid completion value: %lx\n", completionValue );
ok( !memcmp( send_buf, recv_buf, 2 ), "Receive buffer (%x %x) did not match send buffer (%x %x)\n", recv_buf[0], recv_buf[1], send_buf[0], send_buf[1] );
}
ReadFile( hPipeSrv, buf, sizeof(buf), &read, &o);
ReadFile( hPipeSrv, recv_buf, TEST_BUF_LEN, &read, &o);
CloseHandle( hPipeSrv );
count = get_pending_msgs(h);
ok( count == 1, "Unexpected msg count: %ld\n", count );
@ -609,8 +705,11 @@ START_TEST(file)
return;
}
pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
pRtlInitUnicodeString = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString");
pRtlDosPathNameToNtPathName_U = (void *)GetProcAddress(hntdll, "RtlDosPathNameToNtPathName_U");
pNtCreateMailslotFile = (void *)GetProcAddress(hntdll, "NtCreateMailslotFile");
pNtDeleteFile = (void *)GetProcAddress(hntdll, "NtDeleteFile");
pNtReadFile = (void *)GetProcAddress(hntdll, "NtReadFile");
pNtWriteFile = (void *)GetProcAddress(hntdll, "NtWriteFile");
pNtClose = (void *)GetProcAddress(hntdll, "NtClose");
@ -621,6 +720,7 @@ START_TEST(file)
pNtSetIoCompletion = (void *)GetProcAddress(hntdll, "NtSetIoCompletion");
pNtSetInformationFile = (void *)GetProcAddress(hntdll, "NtSetInformationFile");
delete_file_test();
read_file_test();
nt_mailslot_test();
test_iocompletion();

123
rostests/winetests/ntdll/info.c
View file

@ -57,7 +57,7 @@ static BOOL InitFunctionPtrs(void)
static void test_query_basic(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
SYSTEM_BASIC_INFORMATION sbi;
@ -68,7 +68,8 @@ static void test_query_basic(void)
/* 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 %08x\n", status);
ok( status == STATUS_INVALID_INFO_CLASS || status == STATUS_NOT_IMPLEMENTED /* vista */,
"Expected STATUS_INVALID_INFO_CLASS or STATUS_NOT_IMPLEMENTED, got %08x\n", status);
/* Use an existing class but with a zero-length buffer */
trace("Check zero-length buffer\n");
@ -78,7 +79,8 @@ static void test_query_basic(void)
/* 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 %08x\n", status);
ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER /* vista */,
"Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_PARAMETER, got %08x\n", status);
/* Use a existing class, correct length, a pointer to a buffer but no ReturnLength pointer */
trace("Check no ReturnLength pointer\n");
@ -118,7 +120,7 @@ static void test_query_cpu(void)
static void test_query_performance(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
SYSTEM_PERFORMANCE_INFORMATION spi;
@ -138,7 +140,7 @@ static void test_query_performance(void)
static void test_query_timeofday(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
/* Copy of our winternl.h structure turned into a private one */
@ -202,7 +204,8 @@ static void test_query_timeofday(void)
status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, 49, &ReturnLength);
ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
ok( 0 == ReturnLength, "ReturnLength should be 0, it is (%d)\n", ReturnLength);
ok( ReturnLength == 0 || ReturnLength == sizeof(sti) /* vista */,
"ReturnLength should be 0, it is (%d)\n", ReturnLength);
status = pNtQuerySystemInformation(SystemTimeOfDayInformation, &sti, sizeof(sti), &ReturnLength);
ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
@ -215,7 +218,7 @@ static void test_query_timeofday(void)
static void test_query_process(void)
{
DWORD status;
NTSTATUS status;
DWORD last_pid;
ULONG ReturnLength;
int i = 0, k = 0;
@ -243,20 +246,20 @@ static void test_query_process(void)
} SYSTEM_PROCESS_INFORMATION_PRIVATE, *PSYSTEM_PROCESS_INFORMATION_PRIVATE;
ULONG SystemInformationLength = sizeof(SYSTEM_PROCESS_INFORMATION_PRIVATE);
SYSTEM_PROCESS_INFORMATION_PRIVATE* spi = HeapAlloc(GetProcessHeap(), 0, SystemInformationLength);
SYSTEM_PROCESS_INFORMATION_PRIVATE *spi, *spi_buf = 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);
status = pNtQuerySystemInformation(SystemProcessInformation, spi_buf, SystemInformationLength, &ReturnLength);
if (status != STATUS_INFO_LENGTH_MISMATCH) break;
spi = HeapReAlloc(GetProcessHeap(), 0, spi , SystemInformationLength *= 2);
spi_buf = HeapReAlloc(GetProcessHeap(), 0, spi_buf , SystemInformationLength *= 2);
}
ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
spi = spi_buf;
/* Get the first dwOffset, from this we can deduce the OS version we're running
*
@ -320,12 +323,12 @@ static void test_query_process(void)
if (one_before_last_pid == 0) one_before_last_pid = last_pid;
HeapFree( GetProcessHeap(), 0, spi);
HeapFree( GetProcessHeap(), 0, spi_buf);
}
static void test_query_procperf(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
ULONG NeededLength;
SYSTEM_BASIC_INFORMATION sbi;
@ -341,29 +344,57 @@ static void test_query_procperf(void)
ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
/* Try it for 1 processor */
sppi->KernelTime.QuadPart = 0xdeaddead;
sppi->UserTime.QuadPart = 0xdeaddead;
sppi->IdleTime.QuadPart = 0xdeaddead;
status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi,
sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION), &ReturnLength);
ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
ok( sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) == ReturnLength,
"Inconsistent length %d\n", ReturnLength);
ok (sppi->KernelTime.QuadPart != 0xdeaddead, "KernelTime unchanged\n");
ok (sppi->UserTime.QuadPart != 0xdeaddead, "UserTime unchanged\n");
ok (sppi->IdleTime.QuadPart != 0xdeaddead, "IdleTime unchanged\n");
/* Try it for all processors */
sppi->KernelTime.QuadPart = 0xdeaddead;
sppi->UserTime.QuadPart = 0xdeaddead;
sppi->IdleTime.QuadPart = 0xdeaddead;
status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi, NeededLength, &ReturnLength);
ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
ok( NeededLength == ReturnLength, "Inconsistent length (%d) <-> (%d)\n", NeededLength, ReturnLength);
ok (sppi->KernelTime.QuadPart != 0xdeaddead, "KernelTime unchanged\n");
ok (sppi->UserTime.QuadPart != 0xdeaddead, "UserTime unchanged\n");
ok (sppi->IdleTime.QuadPart != 0xdeaddead, "IdleTime unchanged\n");
/* A too large given buffer size */
sppi = HeapReAlloc(GetProcessHeap(), 0, sppi , NeededLength + 2);
sppi->KernelTime.QuadPart = 0xdeaddead;
sppi->UserTime.QuadPart = 0xdeaddead;
sppi->IdleTime.QuadPart = 0xdeaddead;
status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi, NeededLength + 2, &ReturnLength);
ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
ok( status == STATUS_SUCCESS || status == STATUS_INFO_LENGTH_MISMATCH /* vista */,
"Expected STATUS_SUCCESS or STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
ok( NeededLength == ReturnLength, "Inconsistent length (%d) <-> (%d)\n", NeededLength, ReturnLength);
if (status == STATUS_SUCCESS)
{
ok (sppi->KernelTime.QuadPart != 0xdeaddead, "KernelTime unchanged\n");
ok (sppi->UserTime.QuadPart != 0xdeaddead, "UserTime unchanged\n");
ok (sppi->IdleTime.QuadPart != 0xdeaddead, "IdleTime unchanged\n");
}
else /* vista and 2008 */
{
ok (sppi->KernelTime.QuadPart == 0xdeaddead, "KernelTime changed\n");
ok (sppi->UserTime.QuadPart == 0xdeaddead, "UserTime changed\n");
ok (sppi->IdleTime.QuadPart == 0xdeaddead, "IdleTime changed\n");
}
HeapFree( GetProcessHeap(), 0, sppi);
}
static void test_query_module(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
ULONG ModuleCount, i;
@ -398,40 +429,37 @@ static void test_query_module(void)
static void test_query_handle(void)
{
DWORD status;
NTSTATUS 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 %08x\n", status);
}
ok( ReturnLength > 0, "Expected ReturnLength to be > 0, it was %d\n", ReturnLength);
todo_wine ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
SystemInformationLength = ReturnLength;
shi = HeapReAlloc(GetProcessHeap(), 0, shi , SystemInformationLength);
status = pNtQuerySystemInformation(SystemHandleInformation, shi, SystemInformationLength, &ReturnLength);
ok( status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %08x\n", status);
/* Check if we have some return values */
trace("Number of Handles : %d\n", shi->Count);
todo_wine
if (status != STATUS_INFO_LENGTH_MISMATCH) /* vista */
{
/* our implementation is a stub for now */
ok( shi->Count > 1, "Expected more than 1 handles, got (%d)\n", shi->Count);
}
ok( status == STATUS_SUCCESS,
"Expected STATUS_SUCCESS, got %08x\n", status);
/* Check if we have some return values */
trace("Number of Handles : %d\n", shi->Count);
todo_wine
{
/* our implementation is a stub for now */
ok( shi->Count > 1, "Expected more than 1 handles, got (%d)\n", shi->Count);
}
}
HeapFree( GetProcessHeap(), 0, shi);
}
static void test_query_cache(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
SYSTEM_CACHE_INFORMATION sci;
@ -449,7 +477,7 @@ static void test_query_cache(void)
static void test_query_interrupt(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
ULONG NeededLength;
SYSTEM_BASIC_INFORMATION sbi;
@ -477,7 +505,7 @@ static void test_query_interrupt(void)
static void test_query_kerndebug(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
SYSTEM_KERNEL_DEBUGGER_INFORMATION skdi;
@ -495,7 +523,7 @@ static void test_query_kerndebug(void)
static void test_query_regquota(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
SYSTEM_REGISTRY_QUOTA_INFORMATION srqi;
@ -513,7 +541,7 @@ static void test_query_regquota(void)
static void test_query_process_basic(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
typedef struct _PROCESS_BASIC_INFORMATION_PRIVATE {
@ -534,7 +562,8 @@ static void test_query_process_basic(void)
/* 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 %08x\n", status);
ok( status == STATUS_INVALID_INFO_CLASS || status == STATUS_NOT_IMPLEMENTED /* vista */,
"Expected STATUS_INVALID_INFO_CLASS or STATUS_NOT_IMPLEMENTED, got %08x\n", status);
/* Do not give a handle and buffer */
trace("Check NULL handle and buffer and zero-length buffersize\n");
@ -581,7 +610,7 @@ static void test_query_process_basic(void)
static void test_query_process_vm(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
VM_COUNTERS pvi;
@ -619,7 +648,7 @@ static void test_query_process_vm(void)
static void test_query_process_io(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
IO_COUNTERS pii;
@ -659,7 +688,7 @@ static void test_query_process_io(void)
static void test_query_process_times(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
HANDLE process;
SYSTEMTIME UTC, Local;
@ -708,12 +737,13 @@ static void test_query_process_times(void)
status = pNtQueryInformationProcess( GetCurrentProcess(), ProcessTimes, &spti, sizeof(spti) * 2, &ReturnLength);
ok( status == STATUS_INFO_LENGTH_MISMATCH, "Expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status);
ok( sizeof(spti) == ReturnLength, "Inconsistent length %d\n", ReturnLength);
ok( sizeof(spti) == ReturnLength || ReturnLength == 0 /* vista */,
"Inconsistent length %d\n", ReturnLength);
}
static void test_query_process_handlecount(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
DWORD handlecount;
HANDLE process;
@ -757,7 +787,7 @@ static void test_query_process_handlecount(void)
static void test_query_process_image_file_name(void)
{
DWORD status;
NTSTATUS status;
ULONG ReturnLength;
UNICODE_STRING image_file_name;
void *buffer;
@ -795,7 +825,7 @@ static void test_query_process_image_file_name(void)
static void test_readvirtualmemory(void)
{
HANDLE process;
DWORD status;
NTSTATUS status;
SIZE_T readcount;
static const char teststring[] = "test string";
char buffer[12];
@ -818,8 +848,9 @@ static void test_readvirtualmemory(void)
/* illegal remote address */
todo_wine{
status = pNtReadVirtualMemory(process, (void *) 0x1234, buffer, 12, &readcount);
ok( status == STATUS_PARTIAL_COPY, "Expected STATUS_PARTIAL_COPY, got %08x\n", status);
ok( readcount == 0, "Expected to read 0 bytes, got %ld\n",readcount);
ok( status == STATUS_PARTIAL_COPY || broken(status == STATUS_ACCESS_VIOLATION), "Expected STATUS_PARTIAL_COPY, got %08x\n", status);
if (status == STATUS_PARTIAL_COPY)
ok( readcount == 0, "Expected to read 0 bytes, got %ld\n",readcount);
}
/* 0 handle */

211
rostests/winetests/ntdll/om.c
View file

@ -130,21 +130,24 @@ static void test_namespace_pipe(void)
ok(status == STATUS_INSTANCE_NOT_AVAILABLE,
"NtCreateNamedPipeFile should have failed with STATUS_INSTANCE_NOT_AVAILABLE got(%08x)\n", status);
attr.Attributes = OBJ_CASE_INSENSITIVE;
status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN);
ok(status == STATUS_SUCCESS, "Failed to open NamedPipe(%08x)\n", status);
h = CreateFileA("\\\\.\\pipe\\test\\pipe", GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, 0, 0 );
ok(h != INVALID_HANDLE_VALUE, "Failed to open NamedPipe (%u)\n", GetLastError());
pNtClose(h);
pRtlInitUnicodeString(&str, buffer3);
InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN);
ok(status == STATUS_OBJECT_PATH_NOT_FOUND || status == STATUS_PIPE_NOT_AVAILABLE,
ok(status == STATUS_OBJECT_PATH_NOT_FOUND ||
status == STATUS_PIPE_NOT_AVAILABLE ||
status == STATUS_OBJECT_NAME_INVALID, /* vista */
"NtOpenFile should have failed with STATUS_OBJECT_PATH_NOT_FOUND got(%08x)\n", status);
pRtlInitUnicodeString(&str, buffer4);
InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN);
ok(status == STATUS_OBJECT_NAME_NOT_FOUND,
ok(status == STATUS_OBJECT_NAME_NOT_FOUND ||
status == STATUS_OBJECT_NAME_INVALID, /* vista */
"NtOpenFile should have failed with STATUS_OBJECT_NAME_NOT_FOUND got(%08x)\n", status);
pNtClose(pipe);
@ -175,6 +178,64 @@ static void test_namespace_pipe(void)
DIR_TEST_CREATE_SUCCESS(&h) pNtClose(h); DIR_TEST_OPEN_SUCCESS(&h) pNtClose(h); \
pRtlFreeUnicodeString(&str);
static BOOL is_correct_dir( HANDLE dir, const char *name )
{
NTSTATUS status;
UNICODE_STRING str;
OBJECT_ATTRIBUTES attr;
HANDLE h = 0;
pRtlCreateUnicodeStringFromAsciiz(&str, name);
InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, dir, NULL);
status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
pRtlFreeUnicodeString(&str);
if (h) pNtClose( h );
return (status == STATUS_OBJECT_NAME_EXISTS);
}
/* return a handle to the BaseNamedObjects dir where kernel32 objects get created */
static HANDLE get_base_dir(void)
{
static const char objname[] = "om.c_get_base_dir_obj";
NTSTATUS status;
UNICODE_STRING str;
OBJECT_ATTRIBUTES attr;
HANDLE dir, h;
unsigned int i;
h = CreateMutexA(NULL, FALSE, objname);
ok(h != 0, "CreateMutexA failed got ret=%p (%d)\n", h, GetLastError());
InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, 0, NULL);
pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Local");
status = pNtOpenDirectoryObject(&dir, DIRECTORY_QUERY, &attr);
pRtlFreeUnicodeString(&str);
if (!status && is_correct_dir( dir, objname )) goto done;
if (!status) pNtClose( dir );
pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects");
status = pNtOpenDirectoryObject(&dir, DIRECTORY_QUERY, &attr);
pRtlFreeUnicodeString(&str);
if (!status && is_correct_dir( dir, objname )) goto done;
if (!status) pNtClose( dir );
for (i = 0; i < 20; i++)
{
char name[40];
sprintf( name, "\\BaseNamedObjects\\Session\\%u", i );
pRtlCreateUnicodeStringFromAsciiz(&str, name );
status = pNtOpenDirectoryObject(&dir, DIRECTORY_QUERY, &attr);
pRtlFreeUnicodeString(&str);
if (!status && is_correct_dir( dir, objname )) goto done;
if (!status) pNtClose( dir );
}
dir = 0;
done:
pNtClose( h );
return dir;
}
static void test_name_collisions(void)
{
NTSTATUS status;
@ -202,12 +263,13 @@ static void test_name_collisions(void)
"NtCreateMutant should have failed with STATUS_OBJECT_TYPE_MISMATCH got(%08x)\n", status);
pRtlFreeUnicodeString(&str);
pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects");
DIR_TEST_OPEN_SUCCESS(&dir)
if (!(dir = get_base_dir()))
{
win_skip( "couldn't find the BaseNamedObjects dir\n" );
return;
}
pRtlCreateUnicodeStringFromAsciiz(&str, "om.c-test");
InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, dir, NULL);
h = CreateMutexA(NULL, FALSE, "om.c-test");
ok(h != 0, "CreateMutexA failed got ret=%p (%d)\n", h, GetLastError());
status = pNtCreateMutant(&h1, GENERIC_ALL, &attr, FALSE);
@ -285,13 +347,14 @@ static void test_directory(void)
UNICODE_STRING str;
OBJECT_ATTRIBUTES attr;
HANDLE dir, dir1, h;
BOOL is_nt4;
/* No name and/or no attributes */
status = pNtCreateDirectoryObject(NULL, DIRECTORY_QUERY, &attr);
ok(status == STATUS_ACCESS_VIOLATION,
ok(status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER,
"NtCreateDirectoryObject should have failed with STATUS_ACCESS_VIOLATION got(%08x)\n", status);
status = pNtOpenDirectoryObject(NULL, DIRECTORY_QUERY, &attr);
ok(status == STATUS_ACCESS_VIOLATION,
ok(status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER,
"NtOpenDirectoryObject should have failed with STATUS_ACCESS_VIOLATION got(%08x)\n", status);
status = pNtCreateDirectoryObject(&h, DIRECTORY_QUERY, NULL);
@ -335,14 +398,18 @@ static void test_directory(void)
pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Local");
InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
status = pNtOpenSymbolicLinkObject(&dir, SYMBOLIC_LINK_QUERY, &attr);
ok(status == STATUS_SUCCESS, "Failed to open SymbolicLink(%08x)\n", status);
pRtlFreeUnicodeString(&str);
InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
pRtlCreateUnicodeStringFromAsciiz(&str, "one more level");
DIR_TEST_CREATE_FAILURE(&h, STATUS_OBJECT_TYPE_MISMATCH)
pRtlFreeUnicodeString(&str);
pNtClose(h);
pNtClose(dir);
is_nt4 = (status == STATUS_OBJECT_NAME_NOT_FOUND); /* nt4 doesn't have Local\\ symlink */
if (!is_nt4)
{
ok(status == STATUS_SUCCESS, "Failed to open SymbolicLink(%08x)\n", status);
pRtlFreeUnicodeString(&str);
InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
pRtlCreateUnicodeStringFromAsciiz(&str, "one more level");
DIR_TEST_CREATE_FAILURE(&h, STATUS_OBJECT_TYPE_MISMATCH)
pRtlFreeUnicodeString(&str);
pNtClose(h);
pNtClose(dir);
}
pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects");
InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
@ -393,22 +460,23 @@ static void test_directory(void)
pNtClose(dir);
InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Global\\om.c-test");
DIR_TEST_CREATE_SUCCESS(&dir)
pRtlFreeUnicodeString(&str);
pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Local\\om.c-test\\one more level");
DIR_TEST_CREATE_SUCCESS(&h)
pRtlFreeUnicodeString(&str);
pNtClose(h);
InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
pRtlCreateUnicodeStringFromAsciiz(&str, "one more level");
DIR_TEST_CREATE_SUCCESS(&dir)
pRtlFreeUnicodeString(&str);
pNtClose(h);
pNtClose(dir);
if (!is_nt4)
{
InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Global\\om.c-test");
DIR_TEST_CREATE_SUCCESS(&dir)
pRtlFreeUnicodeString(&str);
pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Local\\om.c-test\\one more level");
DIR_TEST_CREATE_SUCCESS(&h)
pRtlFreeUnicodeString(&str);
pNtClose(h);
InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
pRtlCreateUnicodeStringFromAsciiz(&str, "one more level");
DIR_TEST_CREATE_SUCCESS(&dir)
pRtlFreeUnicodeString(&str);
pNtClose(h);
pNtClose(dir);
}
/* Create other objects using RootDirectory */
@ -445,26 +513,19 @@ static void test_directory(void)
pNtClose(dir);
}
#define SYMLNK_TEST_CREATE_FAILURE(h,e) \
status = pNtCreateSymbolicLinkObject(h, SYMBOLIC_LINK_QUERY, &attr, &target);\
ok(status == e,"NtCreateSymbolicLinkObject should have failed with %s got(%08x)\n", #e, status);
#define SYMLNK_TEST_OPEN_FAILURE(h,e) \
status = pNtOpenSymbolicLinkObject(h, SYMBOLIC_LINK_QUERY, &attr);\
ok(status == e,"NtOpenSymbolicLinkObject should have failed with %s got(%08x)\n", #e, status);
#define SYMLNK_TEST_CREATE_OPEN_FAILURE(h,n,t,e) \
#define SYMLNK_TEST_CREATE_OPEN_FAILURE2(h,n,t,e,e2) \
pRtlCreateUnicodeStringFromAsciiz(&str, n);\
pRtlCreateUnicodeStringFromAsciiz(&target, t);\
SYMLNK_TEST_CREATE_FAILURE(h,e)\
SYMLNK_TEST_OPEN_FAILURE(h,e)\
status = pNtCreateSymbolicLinkObject(h, SYMBOLIC_LINK_QUERY, &attr, &target);\
ok(status == e || status == e2, \
"NtCreateSymbolicLinkObject should have failed with %s or %s got(%08x)\n", #e, #e2, status);\
status = pNtOpenSymbolicLinkObject(h, SYMBOLIC_LINK_QUERY, &attr);\
ok(status == e || status == e2, \
"NtOpenSymbolicLinkObject should have failed with %s or %s got(%08x)\n", #e, #e2, status);\
pRtlFreeUnicodeString(&target);\
pRtlFreeUnicodeString(&str);
#define SYMLNK_TEST_CREATE_SUCCESS(h) \
status = pNtCreateSymbolicLinkObject(h, SYMBOLIC_LINK_QUERY, &attr, &target); \
ok(status == STATUS_SUCCESS, "Failed to create SymbolicLink(%08x)\n", status);
#define SYMLNK_TEST_OPEN_SUCCESS(h) \
status = pNtOpenSymbolicLinkObject(h, SYMBOLIC_LINK_QUERY, &attr); \
ok(status == STATUS_SUCCESS, "Failed to open SymbolicLink(%08x)\n", status);
#define SYMLNK_TEST_CREATE_OPEN_FAILURE(h,n,t,e) SYMLNK_TEST_CREATE_OPEN_FAILURE2(h,n,t,e,e)
static void test_symboliclink(void)
{
@ -475,7 +536,7 @@ static void test_symboliclink(void)
IO_STATUS_BLOCK iosb;
/* No name and/or no attributes */
SYMLNK_TEST_CREATE_OPEN_FAILURE(NULL, "", "", STATUS_ACCESS_VIOLATION)
SYMLNK_TEST_CREATE_OPEN_FAILURE2(NULL, "", "", STATUS_ACCESS_VIOLATION, STATUS_INVALID_PARAMETER)
status = pNtCreateSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, NULL, NULL);
ok(status == STATUS_ACCESS_VIOLATION,
@ -487,26 +548,38 @@ static void test_symboliclink(void)
/* No attributes */
pRtlCreateUnicodeStringFromAsciiz(&target, "\\DosDevices");
status = pNtCreateSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, NULL, &target);
ok(status == STATUS_SUCCESS, "NtCreateSymbolicLinkObject failed(%08x)\n", status);
ok(status == STATUS_SUCCESS || status == STATUS_ACCESS_VIOLATION, /* nt4 */
"NtCreateSymbolicLinkObject failed(%08x)\n", status);
pRtlFreeUnicodeString(&target);
pNtClose(h);
if (!status) pNtClose(h);
InitializeObjectAttributes(&attr, NULL, 0, 0, NULL);
SYMLNK_TEST_CREATE_FAILURE(&link, STATUS_INVALID_PARAMETER)
SYMLNK_TEST_OPEN_FAILURE(&h, STATUS_OBJECT_PATH_SYNTAX_BAD)
status = pNtCreateSymbolicLinkObject(&link, SYMBOLIC_LINK_QUERY, &attr, &target);
ok(status == STATUS_INVALID_PARAMETER ||
broken(status == STATUS_SUCCESS), /* nt4 */
"NtCreateSymbolicLinkObject should have failed with STATUS_INVALID_PARAMETER got(%08x)\n", status);
if (!status) pNtClose(h);
status = pNtOpenSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, &attr);
ok(status == STATUS_OBJECT_PATH_SYNTAX_BAD,
"NtOpenSymbolicLinkObject should have failed with STATUS_OBJECT_PATH_SYNTAX_BAD got(%08x)\n", status);
/* Bad name */
pRtlCreateUnicodeStringFromAsciiz(&target, "anywhere");
InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
pRtlCreateUnicodeStringFromAsciiz(&str, "");
SYMLNK_TEST_CREATE_SUCCESS(&link)
SYMLNK_TEST_OPEN_FAILURE(&h, STATUS_OBJECT_PATH_SYNTAX_BAD)
status = pNtCreateSymbolicLinkObject(&link, SYMBOLIC_LINK_QUERY, &attr, &target);
ok(status == STATUS_SUCCESS, "Failed to create SymbolicLink(%08x)\n", status);
status = pNtOpenSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, &attr);
ok(status == STATUS_OBJECT_PATH_SYNTAX_BAD,
"NtOpenSymbolicLinkObject should have failed with STATUS_OBJECT_PATH_SYNTAX_BAD got(%08x)\n", status);
pNtClose(link);
pRtlFreeUnicodeString(&str);
pRtlCreateUnicodeStringFromAsciiz(&str, "\\");
todo_wine {SYMLNK_TEST_CREATE_FAILURE(&h, STATUS_OBJECT_TYPE_MISMATCH)}
status = pNtCreateSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, &attr, &target);
todo_wine ok(status == STATUS_OBJECT_TYPE_MISMATCH,
"NtCreateSymbolicLinkObject should have failed with STATUS_OBJECT_TYPE_MISMATCH got(%08x)\n", status);
pRtlFreeUnicodeString(&str);
pRtlFreeUnicodeString(&target);
@ -514,24 +587,28 @@ static void test_symboliclink(void)
SYMLNK_TEST_CREATE_OPEN_FAILURE(&h, "\\BaseNamedObjects\\", "->Somewhere", STATUS_OBJECT_NAME_INVALID)
SYMLNK_TEST_CREATE_OPEN_FAILURE(&h, "\\\\BaseNamedObjects", "->Somewhere", STATUS_OBJECT_NAME_INVALID)
SYMLNK_TEST_CREATE_OPEN_FAILURE(&h, "\\BaseNamedObjects\\\\om.c-test", "->Somewhere", STATUS_OBJECT_NAME_INVALID)
SYMLNK_TEST_CREATE_OPEN_FAILURE(&h, "\\BaseNamedObjects\\om.c-test\\", "->Somewhere", STATUS_OBJECT_NAME_INVALID)
SYMLNK_TEST_CREATE_OPEN_FAILURE2(&h, "\\BaseNamedObjects\\om.c-test\\", "->Somewhere",
STATUS_OBJECT_NAME_INVALID, STATUS_OBJECT_PATH_NOT_FOUND)
/* Compaund test */
pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects");
DIR_TEST_OPEN_SUCCESS(&dir)
pRtlFreeUnicodeString(&str);
/* Compound test */
if (!(dir = get_base_dir()))
{
win_skip( "couldn't find the BaseNamedObjects dir\n" );
return;
}
InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
pRtlCreateUnicodeStringFromAsciiz(&str, "Local\\test-link");
pRtlCreateUnicodeStringFromAsciiz(&str, "test-link");
pRtlCreateUnicodeStringFromAsciiz(&target, "\\DosDevices");
SYMLNK_TEST_CREATE_SUCCESS(&link)
status = pNtCreateSymbolicLinkObject(&link, SYMBOLIC_LINK_QUERY, &attr, &target);
ok(status == STATUS_SUCCESS, "Failed to create SymbolicLink(%08x)\n", status);
pRtlFreeUnicodeString(&str);
pRtlFreeUnicodeString(&target);
pRtlCreateUnicodeStringFromAsciiz(&str, "Local\\test-link\\PIPE");
pRtlCreateUnicodeStringFromAsciiz(&str, "test-link\\NUL");
status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN);
todo_wine ok(status == STATUS_SUCCESS, "Failed to open NamedPipe(%08x)\n", status);
todo_wine ok(status == STATUS_SUCCESS, "Failed to open NUL device(%08x)\n", status);
pRtlFreeUnicodeString(&str);
pNtClose(h);

53
rostests/winetests/ntdll/path.c
View file

@ -91,6 +91,7 @@ static void test_RtlIsDosDeviceName(void)
const char *path;
WORD pos;
WORD len;
BOOL fails;
};
static const struct test tests[] =
@ -101,22 +102,26 @@ static void test_RtlIsDosDeviceName(void)
{ "", 0, 0 },
{ "\\\\foo\\nul", 0, 0 },
{ "c:\\nul:", 6, 6 },
{ "c:\\nul::", 6, 6 },
{ "c:\\nul::::::", 6, 6 },
{ "c:\\nul\\", 0, 0 },
{ "c:\\nul\\foo", 0, 0 },
{ "c:\\nul::", 6, 6, TRUE }, /* fails on nt4 */
{ "c:\\nul::::::", 6, 6, TRUE }, /* fails on nt4 */
{ "c:prn ", 4, 6 },
{ "c:prn.......", 4, 6 },
{ "c:prn... ...", 4, 6 },
{ "c:NUL .... ", 4, 6 },
{ "c:NUL .... ", 4, 6, TRUE }, /* fails on nt4 */
{ "c: . . .", 0, 0 },
{ "c:", 0, 0 },
{ " . . . :", 0, 0 },
{ ":", 0, 0 },
{ "c:nul. . . :", 4, 6 },
{ "c:nul . . :", 4, 6 },
{ "c:nul . . :", 4, 6, TRUE }, /* fails on nt4 */
{ "c:nul0", 0, 0 },
{ "c:prn:aaa", 4, 6, TRUE }, /* fails on win9x */
{ "c:PRN:.txt", 4, 6 },
{ "c:aux:.txt...", 4, 6 },
{ "c:prn:.txt:", 4, 6 },
{ "c:nul:aaa", 4, 6, TRUE }, /* fails on win9x */
{ "con:", 0, 6 },
{ "lpt1:", 0, 8 },
{ "c:com5:", 4, 8 },
@ -141,22 +146,11 @@ static void test_RtlIsDosDeviceName(void)
{
pRtlMultiByteToUnicodeN( buffer, sizeof(buffer), NULL, test->path, strlen(test->path)+1 );
ret = pRtlIsDosDeviceName_U( buffer );
ok( ret == MAKELONG( test->len, test->pos ),
ok( ret == MAKELONG( test->len, test->pos ) ||
(test->fails && broken( ret == 0 )),
"Wrong result (%d,%d)/(%d,%d) for %s\n",
HIWORD(ret), LOWORD(ret), test->pos, test->len, test->path );
}
pRtlMultiByteToUnicodeN( buffer, sizeof(buffer), NULL, "c:prn:aaa", strlen("c:prn:aaa")+1 );
ret = pRtlIsDosDeviceName_U( buffer );
ok( ret == MAKELONG( 6, 4 ) || /* NT */
ret == MAKELONG( 0, 0), /* win9x */
"Wrong result (%d,%d)/(4,6) or (0,0) for c:prn:aaa\n", HIWORD(ret), LOWORD(ret) );
pRtlMultiByteToUnicodeN( buffer, sizeof(buffer), NULL, "c:nul:aaa", strlen("c:nul:aaa")+1 );
ret = pRtlIsDosDeviceName_U( buffer );
ok( ret == MAKELONG( 6, 4 ) || /* NT */
ret == MAKELONG( 0, 0), /* win9x */
"Wrong result (%d,%d)/(4,6) or (0,0) for c:nul:aaa\n", HIWORD(ret), LOWORD(ret) );
}
static void test_RtlIsNameLegalDOS8Dot3(void)
@ -237,6 +231,8 @@ static void test_RtlGetFullPathName_U(void)
const char *path;
const char *rname;
const char *rfile;
const char *alt_rname;
const char *alt_rfile;
};
static const struct test tests[] =
@ -251,15 +247,17 @@ static void test_RtlGetFullPathName_U(void)
{ "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:\\test\\file\\", NULL,
"c:\\test\\file", "file"}, /* nt4 */
{ "c:///test\\..\\file\\..\\//", "c:\\", NULL},
{ "c:/test../file", "c:\\test.\\file", "file",
"c:\\test..\\file", "file"}, /* vista */
{ NULL, NULL, NULL}
};
@ -276,27 +274,36 @@ static void test_RtlGetFullPathName_U(void)
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 %d/%d for \"%s\"\n", ret, len, test->path );
ok( ret == len || (test->alt_rname && ret == strlen(test->alt_rname)*sizeof(WCHAR)),
"Wrong result %d/%d for \"%s\"\n", ret, len, test->path );
ok(pRtlUnicodeToMultiByteN(rbufferA,MAX_PATH,&reslen,rbufferW,(lstrlenW(rbufferW) + 1) * sizeof(WCHAR)) == STATUS_SUCCESS,
"RtlUnicodeToMultiByteN failed\n");
ok(lstrcmpiA(rbufferA,test->rname) == 0, "Got \"%s\" expected \"%s\"\n",rbufferA,test->rname);
ok(!lstrcmpiA(rbufferA,test->rname) || (test->alt_rname && !lstrcmpiA(rbufferA,test->alt_rname)),
"Got \"%s\" expected \"%s\"\n",rbufferA,test->rname);
if (file_part)
{
ok(pRtlUnicodeToMultiByteN(rfileA,MAX_PATH,&reslen,file_part,(lstrlenW(file_part) + 1) * sizeof(WCHAR)) == STATUS_SUCCESS,
"RtlUnicodeToMultiByteN failed\n");
ok(test->rfile && !lstrcmpiA(rfileA,test->rfile), "Got \"%s\" expected \"%s\"\n",rfileA,test->rfile);
ok((test->rfile && !lstrcmpiA(rfileA,test->rfile)) ||
(test->alt_rfile && !lstrcmpiA(rfileA,test->alt_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");
if (!mod)
{
win_skip("Not running on NT, skipping tests\n");
return;
}
pRtlMultiByteToUnicodeN = (void *)GetProcAddress(mod,"RtlMultiByteToUnicodeN");
pRtlUnicodeToMultiByteN = (void *)GetProcAddress(mod,"RtlUnicodeToMultiByteN");
pRtlDetermineDosPathNameType_U = (void *)GetProcAddress(mod,"RtlDetermineDosPathNameType_U");

43
rostests/winetests/ntdll/port.c
View file

@ -118,26 +118,28 @@ static BOOL init_function_ptrs(void)
{
hntdll = LoadLibraryA("ntdll.dll");
if (hntdll)
{
pNtCompleteConnectPort = (void *)GetProcAddress(hntdll, "NtCompleteConnectPort");
pNtAcceptConnectPort = (void *)GetProcAddress(hntdll, "NtAcceptConnectPort");
pNtReplyPort = (void *)GetProcAddress(hntdll, "NtReplyPort");
pNtReplyWaitReceivePort = (void *)GetProcAddress(hntdll, "NtReplyWaitReceivePort");
pNtCreatePort = (void *)GetProcAddress(hntdll, "NtCreatePort");
pNtRequestWaitReplyPort = (void *)GetProcAddress(hntdll, "NtRequestWaitReplyPort");
pNtRequestPort = (void *)GetProcAddress(hntdll, "NtRequestPort");
pNtRegisterThreadTerminatePort = (void *)GetProcAddress(hntdll, "NtRegisterThreadTerminatePort");
pNtConnectPort = (void *)GetProcAddress(hntdll, "NtConnectPort");
pRtlInitUnicodeString = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString");
pNtWaitForSingleObject = (void *)GetProcAddress(hntdll, "NtWaitForSingleObject");
}
if (!hntdll)
return FALSE;
pNtCompleteConnectPort = (void *)GetProcAddress(hntdll, "NtCompleteConnectPort");
pNtAcceptConnectPort = (void *)GetProcAddress(hntdll, "NtAcceptConnectPort");
pNtReplyPort = (void *)GetProcAddress(hntdll, "NtReplyPort");
pNtReplyWaitReceivePort = (void *)GetProcAddress(hntdll, "NtReplyWaitReceivePort");
pNtCreatePort = (void *)GetProcAddress(hntdll, "NtCreatePort");
pNtRequestWaitReplyPort = (void *)GetProcAddress(hntdll, "NtRequestWaitReplyPort");
pNtRequestPort = (void *)GetProcAddress(hntdll, "NtRequestPort");
pNtRegisterThreadTerminatePort = (void *)GetProcAddress(hntdll, "NtRegisterThreadTerminatePort");
pNtConnectPort = (void *)GetProcAddress(hntdll, "NtConnectPort");
pRtlInitUnicodeString = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString");
pNtWaitForSingleObject = (void *)GetProcAddress(hntdll, "NtWaitForSingleObject");
if (!pNtCompleteConnectPort || !pNtAcceptConnectPort ||
!pNtReplyWaitReceivePort || !pNtCreatePort || !pNtRequestWaitReplyPort ||
!pNtRequestPort || !pNtRegisterThreadTerminatePort ||
!pNtConnectPort || !pRtlInitUnicodeString)
{
win_skip("Needed port functions are not available\n");
FreeLibrary(hntdll);
return FALSE;
}
@ -224,6 +226,9 @@ static DWORD WINAPI test_ports_client(LPVOID arg)
ok(!lstrcmp((LPSTR)out->Data, REPLY), "Expected %s, got %s\n", REPLY, out->Data);
ok(out->MessageType == LPC_REPLY, "Expected LPC_REPLY, got %d\n", out->MessageType);
HeapFree(GetProcessHeap(), 0, out);
HeapFree(GetProcessHeap(), 0, LpcMessage);
return 0;
}
@ -244,6 +249,11 @@ static void test_ports_server(void)
obj.ObjectName = &port;
status = pNtCreatePort(&PortHandle, &obj, 100, 100, 0);
if (status == STATUS_ACCESS_DENIED)
{
skip("Not enough rights\n");
return;
}
todo_wine
{
ok(status == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %d\n", status);
@ -284,6 +294,7 @@ static void test_ports_server(void)
case LPC_CLIENT_DIED:
ok(done, "Expected LPC request to be completed!\n");
HeapFree(GetProcessHeap(), 0, LpcMessage);
return;
default:
@ -291,6 +302,8 @@ static void test_ports_server(void)
break;
}
}
HeapFree(GetProcessHeap(), 0, LpcMessage);
}
START_TEST(port)
@ -309,4 +322,6 @@ START_TEST(port)
test_ports_server();
CloseHandle(thread);
FreeLibrary(hntdll);
}

110
rostests/winetests/ntdll/reg.c
View file

@ -29,6 +29,11 @@
#include "winnls.h"
#include "stdlib.h"
/* A test string */
static const WCHAR stringW[] = {'s', 't', 'r', 'i', 'n', 'g', 'W', 0};
/* A size, in bytes, short enough to cause truncation of the above */
#define STR_TRUNC_SIZE (sizeof(stringW)-2*sizeof(*stringW))
#ifndef __WINE_WINTERNL_H
/* RtlQueryRegistryValues structs and defines */
@ -129,11 +134,11 @@ 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 LPVOID (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 LPVOID (WINAPI * pRtlAllocateHeap)(PVOID,ULONG,ULONG);
static NTSTATUS (WINAPI * pRtlZeroMemory)(PVOID, ULONG);
static NTSTATUS (WINAPI * pRtlpNtQueryValueKey)(HANDLE,ULONG*,PBYTE,DWORD*);
@ -156,32 +161,29 @@ static BOOL InitFunctionPtrs(void)
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(NtFlushKey)
NTDLL_GET_PROC(NtDeleteKey)
NTDLL_GET_PROC(NtQueryValueKey)
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)
NTDLL_GET_PROC(RtlpNtQueryValueKey)
}
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(NtFlushKey)
NTDLL_GET_PROC(NtDeleteKey)
NTDLL_GET_PROC(NtQueryValueKey)
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)
NTDLL_GET_PROC(RtlpNtQueryValueKey)
return TRUE;
}
#undef NTDLL_GET_PROC
@ -198,7 +200,7 @@ static NTSTATUS WINAPI QueryRoutine (IN PCWSTR ValueName, IN ULONG ValueType, IN
{
ValueNameLength = lstrlenW(ValueName);
ValName = (LPSTR)pRtlAllocateHeap(GetProcessHeap(), 0, ValueNameLength);
ValName = pRtlAllocateHeap(GetProcessHeap(), 0, ValueNameLength);
WideCharToMultiByte(0, 0, ValueName, ValueNameLength+1,ValName, ValueNameLength, 0, 0);
@ -211,12 +213,12 @@ static NTSTATUS WINAPI QueryRoutine (IN PCWSTR ValueName, IN ULONG ValueType, IN
{
case REG_NONE:
trace("ValueType: REG_NONE\n");
trace("ValueData: %d\n", (int)ValueData);
trace("ValueData: %p\n", ValueData);
break;
case REG_BINARY:
trace("ValueType: REG_BINARY\n");
trace("ValueData: %d\n", *(unsigned int *)ValueData);
trace("ValueData: %p\n", ValueData);
break;
case REG_SZ:
@ -236,7 +238,7 @@ static NTSTATUS WINAPI QueryRoutine (IN PCWSTR ValueName, IN ULONG ValueType, IN
case REG_DWORD:
trace("ValueType: REG_DWORD\n");
trace("ValueData: %d\n", *(unsigned int *)ValueData);
trace("ValueData: %p\n", ValueData);
break;
};
trace("ValueLength: %d\n", (int)ValueLength);
@ -293,7 +295,7 @@ static void test_RtlQueryRegistryValues(void)
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);
QueryTable = pRtlAllocateHeap(GetProcessHeap(), 0, sizeof(RTL_QUERY_REGISTRY_TABLE)*26);
pRtlZeroMemory( QueryTable, sizeof(RTL_QUERY_REGISTRY_TABLE) * 26);
@ -413,16 +415,20 @@ static void test_NtSetValueKey(void)
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%08x\n", status);
pRtlCreateUnicodeStringFromAsciiz(&ValName, "deletetest");
status = pNtSetValueKey(key, &ValName, 0, REG_DWORD, &data, sizeof(data));
ok(status == STATUS_SUCCESS, "NtSetValueKey Failed: 0x%08x\n", status);
pRtlFreeUnicodeString(&ValName);
pRtlCreateUnicodeStringFromAsciiz(&ValName, "stringtest");
status = pNtSetValueKey(key, &ValName, 0, REG_SZ, (VOID*)stringW, STR_TRUNC_SIZE);
ok(status == STATUS_SUCCESS, "NtSetValueKey Failed: 0x%08x\n", status);
pRtlFreeUnicodeString(&ValName);
pNtClose(key);
}
@ -486,7 +492,7 @@ static void test_NtQueryValueKey(void)
basic_info = HeapAlloc(GetProcessHeap(), 0, len);
status = pNtQueryValueKey(key, &ValName, KeyValueBasicInformation, basic_info, len, &len);
ok(status == STATUS_BUFFER_OVERFLOW, "NtQueryValueKey should have returned STATUS_BUFFER_OVERFLOW instead of 0x%08x\n", status);
ok(basic_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", basic_info->Type);
ok(basic_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", basic_info->TitleIndex);
ok(basic_info->Type == REG_DWORD, "NtQueryValueKey returned wrong Type %d\n", basic_info->Type);
ok(basic_info->NameLength == 20, "NtQueryValueKey returned wrong NameLength %d\n", basic_info->NameLength);
ok(len == FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name[basic_info->NameLength/sizeof(WCHAR)]), "NtQueryValueKey returned wrong len %d\n", len);
@ -494,7 +500,7 @@ static void test_NtQueryValueKey(void)
basic_info = HeapReAlloc(GetProcessHeap(), 0, basic_info, len);
status = pNtQueryValueKey(key, &ValName, KeyValueBasicInformation, basic_info, len, &len);
ok(status == STATUS_SUCCESS, "NtQueryValueKey should have returned STATUS_SUCCESS instead of 0x%08x\n", status);
ok(basic_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", basic_info->Type);
ok(basic_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", basic_info->TitleIndex);
ok(basic_info->Type == REG_DWORD, "NtQueryValueKey returned wrong Type %d\n", basic_info->Type);
ok(basic_info->NameLength == 20, "NtQueryValueKey returned wrong NameLength %d\n", basic_info->NameLength);
ok(len == FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name[basic_info->NameLength/sizeof(WCHAR)]), "NtQueryValueKey returned wrong len %d\n", len);
@ -505,7 +511,7 @@ static void test_NtQueryValueKey(void)
partial_info = HeapAlloc(GetProcessHeap(), 0, len);
status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, partial_info, len, &len);
ok(status == STATUS_BUFFER_OVERFLOW, "NtQueryValueKey should have returned STATUS_BUFFER_OVERFLOW instead of 0x%08x\n", status);
ok(partial_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", partial_info->Type);
ok(partial_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", partial_info->TitleIndex);
ok(partial_info->Type == REG_DWORD, "NtQueryValueKey returned wrong Type %d\n", partial_info->Type);
ok(partial_info->DataLength == 4, "NtQueryValueKey returned wrong DataLength %d\n", partial_info->DataLength);
ok(len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[partial_info->DataLength]), "NtQueryValueKey returned wrong len %d\n", len);
@ -513,7 +519,7 @@ static void test_NtQueryValueKey(void)
partial_info = HeapReAlloc(GetProcessHeap(), 0, partial_info, len);
status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, partial_info, len, &len);
ok(status == STATUS_SUCCESS, "NtQueryValueKey should have returned STATUS_SUCCESS instead of 0x%08x\n", status);
ok(partial_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", partial_info->Type);
ok(partial_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", partial_info->TitleIndex);
ok(partial_info->Type == REG_DWORD, "NtQueryValueKey returned wrong Type %d\n", partial_info->Type);
ok(partial_info->DataLength == 4, "NtQueryValueKey returned wrong DataLength %d\n", partial_info->DataLength);
ok(len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[partial_info->DataLength]), "NtQueryValueKey returned wrong len %d\n", len);
@ -524,7 +530,7 @@ static void test_NtQueryValueKey(void)
full_info = HeapAlloc(GetProcessHeap(), 0, len);
status = pNtQueryValueKey(key, &ValName, KeyValueFullInformation, full_info, len, &len);
ok(status == STATUS_BUFFER_OVERFLOW, "NtQueryValueKey should have returned STATUS_BUFFER_OVERFLOW instead of 0x%08x\n", status);
ok(full_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", full_info->Type);
ok(full_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", full_info->TitleIndex);
ok(full_info->Type == REG_DWORD, "NtQueryValueKey returned wrong Type %d\n", full_info->Type);
ok(full_info->DataLength == 4, "NtQueryValueKey returned wrong DataLength %d\n", full_info->DataLength);
ok(full_info->NameLength == 20, "NtQueryValueKey returned wrong NameLength %d\n", full_info->NameLength);
@ -535,7 +541,7 @@ static void test_NtQueryValueKey(void)
full_info = HeapReAlloc(GetProcessHeap(), 0, full_info, len);
status = pNtQueryValueKey(key, &ValName, KeyValueFullInformation, full_info, len, &len);
ok(status == STATUS_SUCCESS, "NtQueryValueKey should have returned STATUS_SUCCESS instead of 0x%08x\n", status);
ok(full_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", full_info->Type);
ok(full_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", full_info->TitleIndex);
ok(full_info->Type == REG_DWORD, "NtQueryValueKey returned wrong Type %d\n", full_info->Type);
ok(full_info->DataLength == 4, "NtQueryValueKey returned wrong DataLength %d\n", full_info->DataLength);
ok(full_info->NameLength == 20, "NtQueryValueKey returned wrong NameLength %d\n", full_info->NameLength);
@ -544,6 +550,22 @@ static void test_NtQueryValueKey(void)
*(DWORD *)((char *)full_info + full_info->DataOffset));
HeapFree(GetProcessHeap(), 0, full_info);
pRtlFreeUnicodeString(&ValName);
pRtlCreateUnicodeStringFromAsciiz(&ValName, "stringtest");
status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, NULL, 0, &len);
todo_wine ok(status == STATUS_BUFFER_TOO_SMALL, "NtQueryValueKey should have returned STATUS_BUFFER_TOO_SMALL instead of 0x%08x\n", status);
partial_info = HeapAlloc(GetProcessHeap(), 0, len+1);
memset((BYTE*)partial_info, 0xbd, len+1);
status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, partial_info, len, &len);
ok(status == STATUS_SUCCESS, "NtQueryValueKey should have returned STATUS_SUCCESS instead of 0x%08x\n", status);
ok(partial_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", partial_info->TitleIndex);
ok(partial_info->Type == REG_SZ, "NtQueryValueKey returned wrong Type %d\n", partial_info->Type);
ok(partial_info->DataLength == STR_TRUNC_SIZE, "NtQueryValueKey returned wrong DataLength %d\n", partial_info->DataLength);
ok(!memcmp(partial_info->Data, stringW, STR_TRUNC_SIZE), "incorrect Data returned\n");
ok(*(partial_info->Data+STR_TRUNC_SIZE) == 0xbd, "string overflowed %02x\n", *(partial_info->Data+STR_TRUNC_SIZE));
HeapFree(GetProcessHeap(), 0, partial_info);
pRtlFreeUnicodeString(&ValName);
pNtClose(key);
}
@ -575,11 +597,11 @@ static void test_RtlpNtQueryValueKey(void)
START_TEST(reg)
{
static const WCHAR winetest[] = {'\\','W','i','n','e','T','e','s','t','\\',0};
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.Buffer = pRtlReAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, winetestpath.Buffer,
winetestpath.MaximumLength + sizeof(winetest)*sizeof(WCHAR));
winetestpath.MaximumLength = winetestpath.MaximumLength + sizeof(winetest)*sizeof(WCHAR);

19
rostests/winetests/ntdll/rtl.c
View file

@ -49,6 +49,7 @@ typedef struct _RTL_HANDLE_TABLE
static HMODULE hntdll = 0;
static SIZE_T (WINAPI *pRtlCompareMemory)(LPCVOID,LPCVOID,SIZE_T);
static SIZE_T (WINAPI *pRtlCompareMemoryUlong)(PULONG, SIZE_T, ULONG);
static NTSTATUS (WINAPI *pRtlDeleteTimer)(HANDLE, HANDLE, HANDLE);
static VOID (WINAPI *pRtlMoveMemory)(LPVOID,LPCVOID,SIZE_T);
static VOID (WINAPI *pRtlFillMemory)(LPVOID,SIZE_T,BYTE);
static VOID (WINAPI *pRtlFillMemoryUlong)(LPVOID,SIZE_T,ULONG);
@ -80,6 +81,7 @@ static void InitFunctionPtrs(void)
if (hntdll) {
pRtlCompareMemory = (void *)GetProcAddress(hntdll, "RtlCompareMemory");
pRtlCompareMemoryUlong = (void *)GetProcAddress(hntdll, "RtlCompareMemoryUlong");
pRtlDeleteTimer = (void *)GetProcAddress(hntdll, "RtlDeleteTimer");
pRtlMoveMemory = (void *)GetProcAddress(hntdll, "RtlMoveMemory");
pRtlFillMemory = (void *)GetProcAddress(hntdll, "RtlFillMemory");
pRtlFillMemoryUlong = (void *)GetProcAddress(hntdll, "RtlFillMemoryUlong");
@ -264,6 +266,12 @@ static void test_RtlUlonglongByteSwap(void)
{
ULONGLONG result;
if ( pRtlUlonglongByteSwap( 0 ) != 0 )
{
win_skip("Broken RtlUlonglongByteSwap in win2k\n");
return;
}
result = pRtlUlonglongByteSwap( ((ULONGLONG)0x76543210 << 32) | 0x87654321 );
ok( (((ULONGLONG)0x21436587 << 32) | 0x10325476) == result,
"RtlUlonglongByteSwap(0x7654321087654321) returns 0x%x%08x, expected 0x2143658710325476\n",
@ -924,6 +932,15 @@ static void test_RtlAllocateAndInitializeSid(void)
ok(ret == STATUS_INVALID_SID, "wrong error %08x\n", ret);
}
static void test_RtlDeleteTimer(void)
{
NTSTATUS ret;
ret = pRtlDeleteTimer(NULL, NULL, NULL);
ok(ret == STATUS_INVALID_PARAMETER_1 ||
ret == STATUS_INVALID_PARAMETER, /* W2K */
"expected STATUS_INVALID_PARAMETER_1 or STATUS_INVALID_PARAMETER, got %x\n", ret);
}
START_TEST(rtl)
{
InitFunctionPtrs();
@ -956,4 +973,6 @@ START_TEST(rtl)
test_HandleTables();
if (pRtlAllocateAndInitializeSid)
test_RtlAllocateAndInitializeSid();
if (pRtlDeleteTimer)
test_RtlDeleteTimer();
}

172
rostests/winetests/ntdll/rtlstr.c
View file

@ -233,15 +233,18 @@ static void test_RtlInitUnicodeStringEx(void)
ok(result == STATUS_NAME_TOO_LONG,
"pRtlInitUnicodeStringEx(&uni, 0) returns %x, 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);
ok(uni.Length == 12345 ||
uni.Length == 0, /* win2k3 */
"pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected 12345 or 0\n",
uni.Length);
ok(uni.MaximumLength == 12345 ||
uni.MaximumLength == 0, /* win2k3 */
"pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected 12345 or 0\n",
uni.MaximumLength);
ok(uni.Buffer == (void *) 0xdeadbeef ||
uni.Buffer == teststring2, /* win2k3 */
"pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %x or %p\n",
uni.Buffer, 0xdeadbeef, teststring2);
uni.Length = 12345;
uni.MaximumLength = 12345;
@ -1215,7 +1218,7 @@ typedef struct {
int base;
const char *str;
int value;
NTSTATUS result;
NTSTATUS result, alternative;
} str2int_t;
static const str2int_t str2int[] = {
@ -1294,7 +1297,7 @@ static const str2int_t str2int[] = {
{ 0, "0xF", 0xf, STATUS_SUCCESS}, /* one digit hexadecimal */
{ 0, "0xG", 0, STATUS_SUCCESS}, /* empty hexadecimal */
{ 0, "0x", 0, STATUS_SUCCESS}, /* empty hexadecimal */
{ 0, "", 0, STATUS_SUCCESS}, /* empty string */
{ 0, "", 0, STATUS_SUCCESS, STATUS_INVALID_PARAMETER}, /* empty string */
{ 2, "1011101100", 748, STATUS_SUCCESS},
{ 2, "-1011101100", -748, STATUS_SUCCESS},
{ 2, "2", 0, STATUS_SUCCESS},
@ -1302,7 +1305,7 @@ static const str2int_t str2int[] = {
{ 2, "0o1011101100", 0, STATUS_SUCCESS},
{ 2, "0d1011101100", 0, STATUS_SUCCESS},
{ 2, "0x1011101100", 0, STATUS_SUCCESS},
{ 2, "", 0, STATUS_SUCCESS}, /* empty string */
{ 2, "", 0, STATUS_SUCCESS, STATUS_INVALID_PARAMETER}, /* empty string */
{ 8, "1011101100", 136610368, STATUS_SUCCESS},
{ 8, "-1011101100", -136610368, STATUS_SUCCESS},
{ 8, "8", 0, STATUS_SUCCESS},
@ -1310,7 +1313,7 @@ static const str2int_t str2int[] = {
{ 8, "0o1011101100", 0, STATUS_SUCCESS},
{ 8, "0d1011101100", 0, STATUS_SUCCESS},
{ 8, "0x1011101100", 0, STATUS_SUCCESS},
{ 8, "", 0, STATUS_SUCCESS}, /* empty string */
{ 8, "", 0, STATUS_SUCCESS, STATUS_INVALID_PARAMETER}, /* empty string */
{10, "1011101100", 1011101100, STATUS_SUCCESS},
{10, "-1011101100", -1011101100, STATUS_SUCCESS},
{10, "0b1011101100", 0, STATUS_SUCCESS},
@ -1318,7 +1321,7 @@ static const str2int_t str2int[] = {
{10, "0d1011101100", 0, STATUS_SUCCESS},
{10, "0x1011101100", 0, STATUS_SUCCESS},
{10, "o12345", 0, STATUS_SUCCESS}, /* Octal although base is 10 */
{10, "", 0, STATUS_SUCCESS}, /* empty string */
{10, "", 0, STATUS_SUCCESS, STATUS_INVALID_PARAMETER}, /* empty string */
{16, "1011101100", 286265600, STATUS_SUCCESS},
{16, "-1011101100", -286265600, STATUS_SUCCESS},
{16, "G", 0, STATUS_SUCCESS},
@ -1327,9 +1330,9 @@ static const str2int_t str2int[] = {
{16, "0o1011101100", 0, STATUS_SUCCESS},
{16, "0d1011101100", 286265600, STATUS_SUCCESS},
{16, "0x1011101100", 0, STATUS_SUCCESS},
{16, "", 0, STATUS_SUCCESS}, /* empty string */
{20, "0", 0xdeadbeef, STATUS_INVALID_PARAMETER}, /* illegal base */
{-8, "0", 0xdeadbeef, STATUS_INVALID_PARAMETER}, /* Negative base */
{16, "", 0, STATUS_SUCCESS, STATUS_INVALID_PARAMETER}, /* empty string */
{20, "0", 0, STATUS_INVALID_PARAMETER}, /* illegal base */
{-8, "0", 0, STATUS_INVALID_PARAMETER}, /* Negative base */
/* { 0, NULL, 0, STATUS_SUCCESS}, */ /* NULL as string */
};
#define NB_STR2INT (sizeof(str2int)/sizeof(*str2int))
@ -1348,12 +1351,19 @@ static void test_RtlUnicodeStringToInteger(void)
value = 0xdeadbeef;
pRtlInitUnicodeString(&uni, wstr);
result = pRtlUnicodeStringToInteger(&uni, str2int[test_num].base, &value);
ok(result == str2int[test_num].result,
"(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) has result %x, expected: %x\n",
test_num, str2int[test_num].str, str2int[test_num].base, result, str2int[test_num].result);
ok(value == str2int[test_num].value,
"(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d\n",
test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value);
ok(result == str2int[test_num].result ||
(str2int[test_num].alternative && result == str2int[test_num].alternative),
"(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) has result %x, expected: %x (%x)\n",
test_num, str2int[test_num].str, str2int[test_num].base, result,
str2int[test_num].result, str2int[test_num].alternative);
if (result == STATUS_SUCCESS)
ok(value == str2int[test_num].value,
"(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d\n",
test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value);
else
ok(value == 0xdeadbeef || value == 0 /* vista */,
"(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) assigns value %d, expected 0 or deadbeef\n",
test_num, str2int[test_num].str, str2int[test_num].base, value);
free(wstr);
}
@ -1364,7 +1374,7 @@ static void test_RtlUnicodeStringToInteger(void)
"call failed: RtlUnicodeStringToInteger(\"%s\", %d, NULL) has result %x\n",
str2int[1].str, str2int[1].base, result);
result = pRtlUnicodeStringToInteger(&uni, 20, NULL);
ok(result == STATUS_INVALID_PARAMETER,
ok(result == STATUS_INVALID_PARAMETER || result == STATUS_ACCESS_VIOLATION,
"call failed: RtlUnicodeStringToInteger(\"%s\", 20, NULL) has result %x\n",
str2int[1].str, result);
@ -1379,12 +1389,11 @@ static void test_RtlUnicodeStringToInteger(void)
uni.Length = 5; /* Use odd Length (2.5 WCHARS) */
result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value);
ok(result == STATUS_SUCCESS,
ok(result == STATUS_SUCCESS || result == STATUS_INVALID_PARAMETER /* vista */,
"call failed: RtlUnicodeStringToInteger(\"12\", %d, [out]) has result %x\n",
str2int[1].base, result);
ok(value == 12,
"didn't return expected value (test b): expected: %d, got: %d\n",
12, value);
if (result == STATUS_SUCCESS)
ok(value == 12, "didn't return expected value (test b): expected: %d, got: %d\n", 12, value);
uni.Length = 2;
result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value);
@ -1410,12 +1419,19 @@ static void test_RtlCharToInteger(void)
if (str2int[test_num].str[0] != '\0') {
value = 0xdeadbeef;
result = pRtlCharToInteger(str2int[test_num].str, str2int[test_num].base, &value);
ok(result == str2int[test_num].result,
"(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) has result %x, expected: %x\n",
test_num, str2int[test_num].str, str2int[test_num].base, result, str2int[test_num].result);
ok(value == str2int[test_num].value,
"(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d\n",
test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value);
ok(result == str2int[test_num].result ||
(str2int[test_num].alternative && result == str2int[test_num].alternative),
"(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) has result %x, expected: %x (%x)\n",
test_num, str2int[test_num].str, str2int[test_num].base, result,
str2int[test_num].result, str2int[test_num].alternative);
if (result == STATUS_SUCCESS)
ok(value == str2int[test_num].value,
"(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d\n",
test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value);
else
ok(value == 0 || value == 0xdeadbeef,
"(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) assigns value %d, expected 0 or deadbeef\n",
test_num, str2int[test_num].str, str2int[test_num].base, value);
}
}
@ -1477,8 +1493,8 @@ static const int2str_t int2str[] = {
{ 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, 32768, 16, 33, "1000000000000000\0------------------", STATUS_SUCCESS}, broken on windows */
/* { 2, 65535, 16, 33, "1111111111111111\0------------------", STATUS_SUCCESS}, broken on windows */
{ 2, 65536, 17, 33, "10000000000000000\0-----------------", STATUS_SUCCESS},
{ 2, 100000, 17, 33, "11000011010100000\0-----------------", STATUS_SUCCESS},
{ 2, 1000000, 20, 33, "11110100001001000000\0--------------", STATUS_SUCCESS},
@ -1532,8 +1548,8 @@ static const int2str_t int2str[] = {
{16, 4294967294U, 8, 9, "FFFFFFFE\0--------------------------", STATUS_SUCCESS},
{16, 4294967295U, 8, 9, "FFFFFFFF\0--------------------------", STATUS_SUCCESS}, /* max unsigned int */
{ 2, 32768, 16, 17, "1000000000000000\0------------------", STATUS_SUCCESS},
{ 2, 32768, 16, 16, "1000000000000000-------------------", STATUS_SUCCESS},
/* { 2, 32768, 16, 17, "1000000000000000\0------------------", STATUS_SUCCESS}, broken on windows */
/* { 2, 32768, 16, 16, "1000000000000000-------------------", STATUS_SUCCESS}, broken on windows */
{ 2, 65536, 17, 18, "10000000000000000\0-----------------", STATUS_SUCCESS},
{ 2, 65536, 17, 17, "10000000000000000------------------", STATUS_SUCCESS},
{ 2, 131072, 18, 19, "100000000000000000\0----------------", STATUS_SUCCESS},
@ -1675,18 +1691,26 @@ static void test_RtlIsTextUnicode(void)
{
char ascii[] = "A simple string";
WCHAR unicode[] = {'A',' ','U','n','i','c','o','d','e',' ','s','t','r','i','n','g',0};
WCHAR unicode_no_controls[] = {'A','U','n','i','c','o','d','e','s','t','r','i','n','g',0};
/* String with both byte-reversed and standard Unicode control characters. */
WCHAR mixed_controls[] = {'\t',0x9000,0x0d00,'\n',0};
WCHAR *be_unicode;
WCHAR *be_unicode_no_controls;
BOOLEAN res;
int flags;
int i;
ok(!pRtlIsTextUnicode(ascii, sizeof(ascii), NULL), "ASCII text detected as Unicode\n");
ok(pRtlIsTextUnicode(unicode, sizeof(unicode), NULL), "Text should be Unicode\n");
res = pRtlIsTextUnicode(unicode, sizeof(unicode), NULL);
ok(res ||
broken(res == FALSE), /* NT4 */
"Text should be Unicode\n");
ok(!pRtlIsTextUnicode(unicode, sizeof(unicode) - 1, NULL), "Text should be Unicode\n");
flags = IS_TEXT_UNICODE_UNICODE_MASK;
ok(pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Text should not pass a Unicode\n");
todo_wine
ok(flags == (IS_TEXT_UNICODE_STATISTICS | IS_TEXT_UNICODE_CONTROLS),
"Expected flags 0x6, obtained %x\n", flags);
@ -1705,7 +1729,7 @@ static void test_RtlIsTextUnicode(void)
be_unicode[i + 1] = (unicode[i] >> 8) | ((unicode[i] & 0xff) << 8);
}
ok(!pRtlIsTextUnicode(be_unicode, sizeof(unicode) + 2, NULL), "Reverse endian should not be Unicode\n");
todo_wine ok(!pRtlIsTextUnicode(&be_unicode[1], sizeof(unicode), NULL), "Reverse endian should not be Unicode\n");
ok(!pRtlIsTextUnicode(&be_unicode[1], sizeof(unicode), NULL), "Reverse endian should not be Unicode\n");
flags = IS_TEXT_UNICODE_REVERSE_MASK;
ok(!pRtlIsTextUnicode(&be_unicode[1], sizeof(unicode), &flags), "Reverse endian should be Unicode\n");
@ -1715,10 +1739,74 @@ static void test_RtlIsTextUnicode(void)
flags = IS_TEXT_UNICODE_REVERSE_MASK;
ok(!pRtlIsTextUnicode(be_unicode, sizeof(unicode) + 2, &flags), "Reverse endian should be Unicode\n");
todo_wine
ok(flags == (IS_TEXT_UNICODE_REVERSE_CONTROLS | IS_TEXT_UNICODE_REVERSE_SIGNATURE),
"Expected flags 0xc0, obtained %x\n", flags);
/* build byte reversed unicode string with no control chars */
be_unicode_no_controls = HeapAlloc(GetProcessHeap(), 0, sizeof(unicode) + sizeof(WCHAR));
ok(be_unicode_no_controls != NULL, "Expeced HeapAlloc to succeed.\n");
be_unicode_no_controls[0] = 0xfffe;
for (i = 0; i < sizeof(unicode_no_controls)/sizeof(unicode_no_controls[0]); i++)
be_unicode_no_controls[i + 1] = (unicode_no_controls[i] >> 8) | ((unicode_no_controls[i] & 0xff) << 8);
/* The following tests verify that the tests for */
/* IS_TEXT_UNICODE_CONTROLS and IS_TEXT_UNICODE_REVERSE_CONTROLS */
/* are not mutually exclusive. Regardless of whether the strings */
/* contain an indication of endianness, the tests are still */
/* run if the flag is passed to (Rtl)IsTextUnicode. */
/* Test IS_TEXT_UNICODE_CONTROLS flag */
flags = IS_TEXT_UNICODE_CONTROLS;
ok(!pRtlIsTextUnicode(unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on Unicode string lacking control characters.\n");
ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
flags = IS_TEXT_UNICODE_CONTROLS;
ok(!pRtlIsTextUnicode(be_unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on byte-reversed Unicode string lacking control characters.\n");
ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
flags = IS_TEXT_UNICODE_CONTROLS;
ok(pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Test should pass on Unicode string lacking control characters.\n");
ok(flags == IS_TEXT_UNICODE_CONTROLS, "Expected flags 0x04, obtained %x\n", flags);
flags = IS_TEXT_UNICODE_CONTROLS;
ok(!pRtlIsTextUnicode(be_unicode_no_controls, sizeof(unicode_no_controls) + 2, &flags),
"Test should not pass with standard Unicode string.\n");
ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
flags = IS_TEXT_UNICODE_CONTROLS;
ok(pRtlIsTextUnicode(mixed_controls, sizeof(mixed_controls), &flags), "Test should pass on a string containing control characters.\n");
ok(flags == IS_TEXT_UNICODE_CONTROLS, "Expected flags 0x04, obtained %x\n", flags);
/* Test IS_TEXT_UNICODE_REVERSE_CONTROLS flag */
flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
ok(!pRtlIsTextUnicode(be_unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on Unicode string lacking control characters.\n");
ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
ok(!pRtlIsTextUnicode(unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on Unicode string lacking control characters.\n");
ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
ok(!pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Test should not pass on Unicode string lacking control characters.\n");
ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
ok(!pRtlIsTextUnicode(be_unicode, sizeof(unicode) + 2, &flags),
"Test should pass with byte-reversed Unicode string containing control characters.\n");
ok(flags == IS_TEXT_UNICODE_REVERSE_CONTROLS, "Expected flags 0x40, obtained %x\n", flags);
flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
ok(!pRtlIsTextUnicode(mixed_controls, sizeof(mixed_controls), &flags), "Test should pass on a string containing byte-reversed control characters.\n");
ok(flags == IS_TEXT_UNICODE_REVERSE_CONTROLS, "Expected flags 0x40, obtained %x\n", flags);
/* Test with flags for both byte-reverse and standard Unicode characters */
flags = IS_TEXT_UNICODE_CONTROLS | IS_TEXT_UNICODE_REVERSE_CONTROLS;
ok(!pRtlIsTextUnicode(mixed_controls, sizeof(mixed_controls), &flags), "Test should pass on string containing both byte-reversed and standard control characters.\n");
ok(flags == (IS_TEXT_UNICODE_CONTROLS | IS_TEXT_UNICODE_REVERSE_CONTROLS), "Expected flags 0x44, obtained %x\n", flags);
HeapFree(GetProcessHeap(), 0, be_unicode);
HeapFree(GetProcessHeap(), 0, be_unicode_no_controls);
}
static const WCHAR szGuid[] = { '{','0','1','0','2','0','3','0','4','-',

82
rostests/winetests/ntdll/string.c
View file

@ -893,6 +893,31 @@ static void test_wtoi(void)
} /* for */
}
static void test_atoi(void)
{
int test_num;
int result;
for (test_num = 0; test_num < NB_STR2LONG; test_num++) {
result = patoi(str2long[test_num].str);
ok(result == str2long[test_num].value,
"(test %d): call failed: _atoi(\"%s\") has result %d, expected: %d\n",
test_num, str2long[test_num].str, result, str2long[test_num].value);
}
}
static void test_atol(void)
{
int test_num;
int result;
for (test_num = 0; test_num < NB_STR2LONG; test_num++) {
result = patol(str2long[test_num].str);
ok(result == str2long[test_num].value,
"(test %d): call failed: _atol(\"%s\") has result %d, expected: %d\n",
test_num, str2long[test_num].str, result, str2long[test_num].value);
}
}
static void test_wtol(void)
{
@ -914,6 +939,7 @@ static void test_wtol(void)
typedef struct {
const char *str;
LONGLONG value;
int overflow;
} str2longlong_t;
static const str2longlong_t str2longlong[] = {
@ -968,8 +994,8 @@ static const str2longlong_t str2longlong[] = {
{ "00x12345", 0 },
{ "0xx12345", 0 },
{ "1x34", 1 },
{ "-99999999999999999999", -ULL(0x6bc75e2d,0x630fffff) }, /* Big negative integer */
{ "-9223372036854775809", ULL(0x7fffffff,0xffffffff) }, /* Too small to fit in 64 bits */
{ "-99999999999999999999", -ULL(0x6bc75e2d,0x630fffff), -1 }, /* Big negative integer */
{ "-9223372036854775809", ULL(0x7fffffff,0xffffffff), -1 }, /* Too small to fit in 64 bits */
{ "-9223372036854775808", ULL(0x80000000,0x00000000) }, /* Smallest negative 64 bit integer */
{ "-9223372036854775807", -ULL(0x7fffffff,0xffffffff) },
{ "-9999999999", -ULL(0x00000002,0x540be3ff) },
@ -989,12 +1015,12 @@ static const str2longlong_t str2longlong[] = {
{ "9999999999", ULL(0x00000002,0x540be3ff) },
{ "9223372036854775806", ULL(0x7fffffff,0xfffffffe) },
{ "9223372036854775807", ULL(0x7fffffff,0xffffffff) }, /* Largest signed positive 64 bit integer */
{ "9223372036854775808", ULL(0x80000000,0x00000000) }, /* Pos int equal to smallest neg 64 bit int */
{ "9223372036854775809", ULL(0x80000000,0x00000001) },
{ "18446744073709551614", ULL(0xffffffff,0xfffffffe) },
{ "18446744073709551615", ULL(0xffffffff,0xffffffff) }, /* Largest unsigned 64 bit integer */
{ "18446744073709551616", 0 }, /* Too big to fit in 64 bits */
{ "99999999999999999999", ULL(0x6bc75e2d,0x630fffff) }, /* Big positive integer */
{ "9223372036854775808", ULL(0x80000000,0x00000000), 1 }, /* Pos int equal to smallest neg 64 bit int */
{ "9223372036854775809", ULL(0x80000000,0x00000001), 1 },
{ "18446744073709551614", ULL(0xffffffff,0xfffffffe), 1 },
{ "18446744073709551615", ULL(0xffffffff,0xffffffff), 1 }, /* Largest unsigned 64 bit integer */
{ "18446744073709551616", 0, 1 }, /* Too big to fit in 64 bits */
{ "99999999999999999999", ULL(0x6bc75e2d,0x630fffff), 1 }, /* Big positive integer */
{ "056789", 56789 }, /* Leading zero and still decimal */
{ "b1011101100", 0 }, /* Binary (b-notation) */
{ "-b1011101100", 0 }, /* Negative Binary (b-notation) */
@ -1041,11 +1067,19 @@ static void test_atoi64(void)
for (test_num = 0; test_num < NB_STR2LONGLONG; test_num++) {
result = p_atoi64(str2longlong[test_num].str);
ok(result == str2longlong[test_num].value,
"(test %d): call failed: _atoi64(\"%s\") has result 0x%x%08x, expected: 0x%x%08x\n",
test_num, str2longlong[test_num].str, (DWORD)(result >> 32), (DWORD)result,
(DWORD)(str2longlong[test_num].value >> 32), (DWORD)str2longlong[test_num].value);
} /* for */
if (str2longlong[test_num].overflow)
ok(result == str2longlong[test_num].value ||
(result == (str2longlong[test_num].overflow == -1) ?
ULL(0x80000000,0x00000000) : ULL(0x7fffffff,0xffffffff)),
"(test %d): call failed: _atoi64(\"%s\") has result 0x%x%08x, expected: 0x%x%08x\n",
test_num, str2longlong[test_num].str, (DWORD)(result >> 32), (DWORD)result,
(DWORD)(str2longlong[test_num].value >> 32), (DWORD)str2longlong[test_num].value);
else
ok(result == str2longlong[test_num].value,
"(test %d): call failed: _atoi64(\"%s\") has result 0x%x%08x, expected: 0x%x%08x\n",
test_num, str2longlong[test_num].str, (DWORD)(result >> 32), (DWORD)result,
(DWORD)(str2longlong[test_num].value >> 32), (DWORD)str2longlong[test_num].value);
}
}
@ -1058,12 +1092,20 @@ static void test_wtoi64(void)
for (test_num = 0; test_num < NB_STR2LONGLONG; test_num++) {
pRtlCreateUnicodeStringFromAsciiz(&uni, str2longlong[test_num].str);
result = p_wtoi64(uni.Buffer);
ok(result == str2longlong[test_num].value,
"(test %d): call failed: _wtoi64(\"%s\") has result 0x%x%08x, expected: 0x%x%08x\n",
test_num, str2longlong[test_num].str, (DWORD)(result >> 32), (DWORD)result,
(DWORD)(str2longlong[test_num].value >> 32), (DWORD)str2longlong[test_num].value);
if (str2longlong[test_num].overflow)
ok(result == str2longlong[test_num].value ||
(result == (str2longlong[test_num].overflow == -1) ?
ULL(0x80000000,0x00000000) : ULL(0x7fffffff,0xffffffff)),
"(test %d): call failed: _atoi64(\"%s\") has result 0x%x%08x, expected: 0x%x%08x\n",
test_num, str2longlong[test_num].str, (DWORD)(result >> 32), (DWORD)result,
(DWORD)(str2longlong[test_num].value >> 32), (DWORD)str2longlong[test_num].value);
else
ok(result == str2longlong[test_num].value,
"(test %d): call failed: _atoi64(\"%s\") has result 0x%x%08x, expected: 0x%x%08x\n",
test_num, str2longlong[test_num].str, (DWORD)(result >> 32), (DWORD)result,
(DWORD)(str2longlong[test_num].value >> 32), (DWORD)str2longlong[test_num].value);
pRtlFreeUnicodeString(&uni);
} /* for */
}
}
static void test_wcsfuncs(void)
@ -1095,4 +1137,8 @@ START_TEST(string)
test_wtoi64();
if (p_wcschr && p_wcsrchr)
test_wcsfuncs();
if (patoi)
test_atoi();
if (patol)
test_atol();
}