ok(!res, "Added atom (%x)\n", res);
- memset(abi->Name, 0xcc, 255 * sizeof(WCHAR));
+ memset( ptr, 0xcc, sizeof(ptr) );
res = pNtQueryInformationAtom( atom, AtomBasicInformation, (void*)ptr, ptr_size, NULL );
ok(!res, "atom lookup\n");
ok(!lstrcmpW(abi->Name, testAtom1), "ok strings\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));
+ memset( ptr, 0xcc, sizeof(ptr) );
ptr_size = sizeof(ATOM_BASIC_INFORMATION) + lstrlenW(testAtom1) * sizeof(WCHAR);
res = pNtQueryInformationAtom( atom, AtomBasicInformation, (void*)ptr, ptr_size, NULL );
ok(!res, "atom lookup %x\n", res);
ok(abi->Name[lstrlenW(testAtom1)] == 0, "buffer overwrite %x\n", abi->Name[lstrlenW(testAtom1)]);
ok(abi->Name[lstrlenW(testAtom1) + 1] == 0xcccc, "buffer overwrite %x\n", abi->Name[lstrlenW(testAtom1) + 1]);
+ memset( ptr, 0xcc, sizeof(ptr) );
ptr_size = sizeof(ATOM_BASIC_INFORMATION) + 4 * sizeof(WCHAR);
- abi->Name[0] = abi->Name[1] = abi->Name[2] = abi->Name[3] = '\0';
res = pNtQueryInformationAtom( atom, AtomBasicInformation, (void*)ptr, ptr_size, NULL );
ok(!res, "couldn't find atom\n");
ok(abi->NameLength == 8, "wrong string length %u\n", abi->NameLength);
* Unit tests for RtlNtStatusToDosError function
*
* Copyright (c) 2002 Andriy Palamarchuk
- * Copyright (c) 2010 André Hentschel
+ * Copyright (c) 2010 André Hentschel
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
/* CCHAR */
TEST_TYPE_SIZE (CCHAR, 1)
TEST_TYPE_ALIGN (CCHAR, 1)
- TEST_TYPE_SIGNED(CCHAR)
}
static void test_pack_CHAR(void)
/* CHAR */
TEST_TYPE_SIZE (CHAR, 1)
TEST_TYPE_ALIGN (CHAR, 1)
- TEST_TYPE_SIGNED(CHAR)
}
static void test_pack_DWORDLONG(void)
TEST_TYPE_UNSIGNED(EXECUTION_STATE)
}
-static void test_pack_FLOATING_SAVE_AREA(void)
-{
-#if 0 // this doesn't exist on amd64
- /* FLOATING_SAVE_AREA */
- TEST_TYPE_SIZE (FLOATING_SAVE_AREA, 112)
- TEST_TYPE_ALIGN (FLOATING_SAVE_AREA, 4)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, ControlWord, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, ControlWord, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, ControlWord, 0)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, StatusWord, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, StatusWord, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, StatusWord, 4)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, TagWord, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, TagWord, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, TagWord, 8)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, ErrorOffset, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, ErrorOffset, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, ErrorOffset, 12)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, ErrorSelector, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, ErrorSelector, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, ErrorSelector, 16)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, DataOffset, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, DataOffset, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, DataOffset, 20)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, DataSelector, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, DataSelector, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, DataSelector, 24)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, RegisterArea, 80)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, RegisterArea, 1)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, RegisterArea, 28)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, Cr0NpxState, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, Cr0NpxState, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, Cr0NpxState, 108)
-#endif
-}
-
static void test_pack_FPO_DATA(void)
{
/* FPO_DATA */
static void test_pack_IMAGE_LOAD_CONFIG_DIRECTORY(void)
{
/* IMAGE_LOAD_CONFIG_DIRECTORY */
-// TEST_TYPE_SIZE (IMAGE_LOAD_CONFIG_DIRECTORY, 88)
+#ifndef __REACTOS__
+ TEST_TYPE_SIZE (IMAGE_LOAD_CONFIG_DIRECTORY, 88)
+#endif
TEST_TYPE_ALIGN (IMAGE_LOAD_CONFIG_DIRECTORY, 8)
TEST_FIELD_SIZE (IMAGE_LOAD_CONFIG_DIRECTORY, Size, 4)
TEST_FIELD_ALIGN (IMAGE_LOAD_CONFIG_DIRECTORY, Size, 4)
TEST_FIELD_SIZE (IMAGE_LOAD_CONFIG_DIRECTORY, CriticalSectionDefaultTimeout, 4)
TEST_FIELD_ALIGN (IMAGE_LOAD_CONFIG_DIRECTORY, CriticalSectionDefaultTimeout, 4)
TEST_FIELD_OFFSET(IMAGE_LOAD_CONFIG_DIRECTORY, CriticalSectionDefaultTimeout, 20)
-#if 0 // wine headers are broken
+#ifndef __REACTOS__ // wine headers are broken
TEST_FIELD_SIZE (IMAGE_LOAD_CONFIG_DIRECTORY, DeCommitFreeBlockThreshold, 4)
TEST_FIELD_ALIGN (IMAGE_LOAD_CONFIG_DIRECTORY, DeCommitFreeBlockThreshold, 4)
TEST_FIELD_OFFSET(IMAGE_LOAD_CONFIG_DIRECTORY, DeCommitFreeBlockThreshold, 24)
TEST_TARGET_ALIGN(PEXCEPTION_RECORD, 8)
}
-static void test_pack_PFLOATING_SAVE_AREA(void)
-{
-#if 0
- /* PFLOATING_SAVE_AREA */
- TEST_TYPE_SIZE (PFLOATING_SAVE_AREA, 8)
- TEST_TYPE_ALIGN (PFLOATING_SAVE_AREA, 8)
- TEST_TARGET_SIZE (PFLOATING_SAVE_AREA, 112)
- TEST_TARGET_ALIGN(PFLOATING_SAVE_AREA, 4)
-#endif
-}
-
static void test_pack_PFPO_DATA(void)
{
/* PFPO_DATA */
/* PIMAGE_LOAD_CONFIG_DIRECTORY */
TEST_TYPE_SIZE (PIMAGE_LOAD_CONFIG_DIRECTORY, 8)
TEST_TYPE_ALIGN (PIMAGE_LOAD_CONFIG_DIRECTORY, 8)
-#if 0// wine headers are broken
+#ifndef __REACTOS__ // wine headers are broken
TEST_TARGET_SIZE (PIMAGE_LOAD_CONFIG_DIRECTORY, 88)
#endif
TEST_TARGET_ALIGN(PIMAGE_LOAD_CONFIG_DIRECTORY, 8)
/* CCHAR */
TEST_TYPE_SIZE (CCHAR, 1)
TEST_TYPE_ALIGN (CCHAR, 1)
- TEST_TYPE_SIGNED(CCHAR)
}
static void test_pack_CHAR(void)
/* CHAR */
TEST_TYPE_SIZE (CHAR, 1)
TEST_TYPE_ALIGN (CHAR, 1)
- TEST_TYPE_SIGNED(CHAR)
}
static void test_pack_DWORDLONG(void)
TEST_TYPE_UNSIGNED(EXECUTION_STATE)
}
-static void test_pack_FLOATING_SAVE_AREA(void)
-{
- /* FLOATING_SAVE_AREA */
- TEST_TYPE_SIZE (FLOATING_SAVE_AREA, 112)
- TEST_TYPE_ALIGN (FLOATING_SAVE_AREA, 4)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, ControlWord, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, ControlWord, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, ControlWord, 0)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, StatusWord, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, StatusWord, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, StatusWord, 4)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, TagWord, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, TagWord, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, TagWord, 8)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, ErrorOffset, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, ErrorOffset, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, ErrorOffset, 12)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, ErrorSelector, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, ErrorSelector, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, ErrorSelector, 16)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, DataOffset, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, DataOffset, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, DataOffset, 20)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, DataSelector, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, DataSelector, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, DataSelector, 24)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, RegisterArea, 80)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, RegisterArea, 1)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, RegisterArea, 28)
- TEST_FIELD_SIZE (FLOATING_SAVE_AREA, Cr0NpxState, 4)
- TEST_FIELD_ALIGN (FLOATING_SAVE_AREA, Cr0NpxState, 4)
- TEST_FIELD_OFFSET(FLOATING_SAVE_AREA, Cr0NpxState, 108)
-}
-
static void test_pack_FPO_DATA(void)
{
/* FPO_DATA */
TEST_TARGET_ALIGN(PEXCEPTION_RECORD, 4)
}
-static void test_pack_PFLOATING_SAVE_AREA(void)
-{
- /* PFLOATING_SAVE_AREA */
- TEST_TYPE_SIZE (PFLOATING_SAVE_AREA, 4)
- TEST_TYPE_ALIGN (PFLOATING_SAVE_AREA, 4)
- TEST_TARGET_SIZE (PFLOATING_SAVE_AREA, 112)
- TEST_TARGET_ALIGN(PFLOATING_SAVE_AREA, 4)
-}
-
static void test_pack_PFPO_DATA(void)
{
/* PFPO_DATA */
test_pack_EXECUTION_STATE();
test_pack_FARPROC();
test_pack_FLOAT();
- test_pack_FLOATING_SAVE_AREA();
test_pack_FPO_DATA();
test_pack_GENERIC_MAPPING();
test_pack_GLOBALHANDLE();
test_pack_PCWSTR();
test_pack_PEXCEPTION_POINTERS();
test_pack_PEXCEPTION_RECORD();
- test_pack_PFLOATING_SAVE_AREA();
test_pack_PFPO_DATA();
test_pack_PGENERIC_MAPPING();
test_pack_PHANDLE();
{
ok (mbi.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "mbi.AllocationProtect is 0x%x, expected 0x%x\n", mbi.AllocationProtect, PAGE_EXECUTE_WRITECOPY);
ok (mbi.State == MEM_COMMIT, "mbi.State is 0x%x, expected 0x%X\n", mbi.State, MEM_COMMIT);
- ok (mbi.Protect == PAGE_READWRITE, "mbi.Protect is 0x%x, expected 0x%X\n", mbi.Protect, PAGE_READWRITE);
+ ok (mbi.Protect == PAGE_READWRITE || mbi.Protect == PAGE_WRITECOPY,
+ "mbi.Protect is 0x%x\n", mbi.Protect);
}
else skip( "bss is outside of module\n" ); /* this can happen on Mac OS */
}
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\nul.txt", 1000, 6 },
+ // ReactOS r54114
{ "c:\\nul", 6, 6 },
{ NULL, 0 }
};
timeout.QuadPart = -100000000000ll;
+/* create a pipe with FILE_OVERWRITE */
+ res = pNtCreateNamedPipeFile(&handle, FILE_READ_ATTRIBUTES | SYNCHRONIZE, &attr, &iosb, FILE_SHARE_READ, 4 /*FILE_OVERWRITE*/,
+ 0, 1, 0, 0, 0xFFFFFFFF, 500, 500, &timeout);
+ todo_wine ok(res == STATUS_INVALID_PARAMETER, "NtCreateNamedPipeFile returned %x\n", res);
+ if (!res)
+ CloseHandle(handle);
+
+/* create a pipe with FILE_OVERWRITE_IF */
+ res = pNtCreateNamedPipeFile(&handle, FILE_READ_ATTRIBUTES | SYNCHRONIZE, &attr, &iosb, FILE_SHARE_READ, 5 /*FILE_OVERWRITE_IF*/,
+ 0, 1, 0, 0, 0xFFFFFFFF, 500, 500, &timeout);
+ todo_wine ok(res == STATUS_INVALID_PARAMETER, "NtCreateNamedPipeFile returned %x\n", res);
+ if (!res)
+ CloseHandle(handle);
+
/* create a pipe with sharing = 0 */
res = pNtCreateNamedPipeFile(&handle, FILE_READ_ATTRIBUTES | SYNCHRONIZE, &attr, &iosb, 0, 2 /*FILE_CREATE*/,
0, 1, 0, 0, 0xFFFFFFFF, 500, 500, &timeout);
- todo_wine ok(res == STATUS_INVALID_PARAMETER, "NtCreateNamedPipeFile returned %x\n", res);
+ ok(res == STATUS_INVALID_PARAMETER, "NtCreateNamedPipeFile returned %x\n", res);
if (!res)
CloseHandle(handle);
ok(!res, "NtCreateNamedPipeFile returned %x\n", res);
res = pNtQueryInformationFile(handle, &iosb, &info, sizeof(info), (FILE_INFORMATION_CLASS)24);
- todo_wine ok(res == STATUS_ACCESS_DENIED, "NtQueryInformationFile returned %x\n", res);
+ ok(res == STATUS_ACCESS_DENIED, "NtQueryInformationFile returned %x\n", res);
/* test FILE_CREATE creation disposition */
res = pNtCreateNamedPipeFile(&handle2, SYNCHRONIZE, &attr, &iosb, FILE_SHARE_READ | FILE_SHARE_WRITE, 2 /*FILE_CREATE*/,
CloseHandle(handle);
}
+static void test_create(void)
+{
+ HANDLE hserver;
+ NTSTATUS res;
+ int j, k;
+ FILE_PIPE_LOCAL_INFORMATION info;
+ IO_STATUS_BLOCK iosb;
+
+ static const DWORD access[] = { 0, GENERIC_READ, GENERIC_WRITE, GENERIC_READ | GENERIC_WRITE};
+ static const DWORD sharing[] = { FILE_SHARE_READ, FILE_SHARE_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE };
+ static const DWORD pipe_config[]= { 1, 0, 2 };
+
+ for (j = 0; j < sizeof(sharing) / sizeof(DWORD); j++) {
+ for (k = 0; k < sizeof(access) / sizeof(DWORD); k++) {
+ HANDLE hclient;
+ BOOL should_succeed = TRUE;
+
+ res = create_pipe(&hserver, sharing[j], FILE_SYNCHRONOUS_IO_NONALERT);
+ if (res) {
+ ok(0, "NtCreateNamedPipeFile returned %x, sharing: %x\n", res, sharing[j]);
+ continue;
+ }
+
+ res = pNtQueryInformationFile(hserver, &iosb, &info, sizeof(info), (FILE_INFORMATION_CLASS)24);
+ ok(!res, "NtQueryInformationFile for server returned %x, sharing: %x\n", res, sharing[j]);
+ ok(info.NamedPipeConfiguration == pipe_config[j], "wrong duplex status for pipe: %d, expected %d\n",
+ info.NamedPipeConfiguration, pipe_config[j]);
+
+ hclient = CreateFileW(testpipe, access[k], 0, 0, OPEN_EXISTING, 0, 0);
+ if (hclient != INVALID_HANDLE_VALUE) {
+ res = pNtQueryInformationFile(hclient, &iosb, &info, sizeof(info), (FILE_INFORMATION_CLASS)24);
+ ok(!res, "NtQueryInformationFile for client returned %x, access: %x, sharing: %x\n",
+ res, access[k], sharing[j]);
+ ok(info.NamedPipeConfiguration == pipe_config[j], "wrong duplex status for pipe: %d, expected %d\n",
+ info.NamedPipeConfiguration, pipe_config[j]);
+ CloseHandle(hclient);
+ }
+
+ if (access[k] & GENERIC_WRITE)
+ should_succeed &= !!(sharing[j] & FILE_SHARE_WRITE);
+ if (access[k] & GENERIC_READ)
+ should_succeed &= !!(sharing[j] & FILE_SHARE_READ);
+
+ if (should_succeed)
+ ok(hclient != INVALID_HANDLE_VALUE, "CreateFile failed for sharing %x, access: %x, GetLastError: %d\n",
+ sharing[j], access[k], GetLastError());
+ else
+ ok(hclient == INVALID_HANDLE_VALUE, "CreateFile succeeded for sharing %x, access: %x\n", sharing[j], access[k]);
+
+ CloseHandle(hserver);
+ }
+ }
+}
+
static BOOL ioapc_called;
static void CALLBACK ioapc(void *arg, PIO_STATUS_BLOCK io, ULONG reserved)
{
Sleep(400);
if (main_thread) {
+ DWORD ret;
userapc_called = FALSE;
- ok(pQueueUserAPC(&userapc, main_thread, 0), "can't queue user apc, GetLastError: %x\n", GetLastError());
+ ret = pQueueUserAPC(&userapc, main_thread, 0);
+ ok(ret, "can't queue user apc, GetLastError: %x\n", GetLastError());
CloseHandle(main_thread);
}
HANDLE hPipe;
NTSTATUS res;
HANDLE hThread;
+ DWORD ret;
memset(&iosb, 0x55, sizeof(iosb));
/* queue an user apc before calling listen */
userapc_called = FALSE;
- ok(pQueueUserAPC(&userapc, GetCurrentThread(), 0), "can't queue user apc, GetLastError: %x\n", GetLastError());
+ ret = pQueueUserAPC(&userapc, GetCurrentThread(), 0);
+ ok(ret, "can't queue user apc, GetLastError: %x\n", GetLastError());
res = listen_pipe(hPipe, hEvent, &iosb, TRUE);
todo_wine ok(res == STATUS_CANCELLED, "NtFsControlFile returned %x\n", res);
HANDLE hPipe;
NTSTATUS res;
HANDLE hThread;
+ DWORD ret;
memset(&iosb, 0x55, sizeof(iosb));
ok(hThread != INVALID_HANDLE_VALUE, "can't create thread, GetLastError: %x\n", GetLastError());
userapc_called = FALSE;
- ok(pQueueUserAPC(&userapc, GetCurrentThread(), 0), "can't queue user apc, GetLastError: %x\n", GetLastError());
+ ret = pQueueUserAPC(&userapc, GetCurrentThread(), 0);
+ ok(ret, "can't queue user apc, GetLastError: %x\n", GetLastError());
res = listen_pipe(hPipe, hEvent, &iosb, TRUE);
todo_wine ok(!res, "NtFsControlFile returned %x\n", res);
trace("starting invalid create tests\n");
test_create_invalid();
+ trace("starting create tests\n");
+ test_create();
+
trace("starting overlapped tests\n");
test_overlapped();
/* Only attributes */
status = pNtCreateKey(NULL, 0, &attr, 0, 0, 0, 0);
- ok(status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got: 0x%08x\n", status);
+ ok(status == STATUS_ACCESS_VIOLATION || status == STATUS_ACCESS_DENIED /* Win7 */,
+ "Expected STATUS_ACCESS_VIOLATION or STATUS_ACCESS_DENIED, got: 0x%08x\n", status);
/* Length > sizeof(OBJECT_ATTRIBUTES) */
attr.Length *= 2;
pNtClose( key64 );
}
+static void test_long_value_name(void)
+{
+ HANDLE key;
+ NTSTATUS status, expected;
+ OBJECT_ATTRIBUTES attr;
+ UNICODE_STRING ValName;
+ DWORD i;
+
+ InitializeObjectAttributes(&attr, &winetestpath, 0, 0, 0);
+ status = pNtOpenKey(&key, KEY_WRITE|KEY_READ, &attr);
+ ok(status == STATUS_SUCCESS, "NtOpenKey Failed: 0x%08x\n", status);
+
+ ValName.MaximumLength = 0xfffc;
+ ValName.Length = ValName.MaximumLength - sizeof(WCHAR);
+ ValName.Buffer = HeapAlloc(GetProcessHeap(), 0, ValName.MaximumLength);
+ for (i = 0; i < ValName.Length / sizeof(WCHAR); i++)
+ ValName.Buffer[i] = 'a';
+ ValName.Buffer[i] = 0;
+
+ status = pNtDeleteValueKey(key, &ValName);
+ ok(status == STATUS_OBJECT_NAME_NOT_FOUND, "NtDeleteValueKey with nonexistent long value name returned 0x%08x\n", status);
+ status = pNtSetValueKey(key, &ValName, 0, REG_DWORD, &i, sizeof(i));
+ ok(status == STATUS_INVALID_PARAMETER || broken(status == STATUS_SUCCESS) /* nt4 */,
+ "NtSetValueKey with long value name returned 0x%08x\n", status);
+ expected = (status == STATUS_SUCCESS) ? STATUS_SUCCESS : STATUS_OBJECT_NAME_NOT_FOUND;
+ status = pNtDeleteValueKey(key, &ValName);
+ ok(status == expected, "NtDeleteValueKey with long value name returned 0x%08x\n", status);
+
+ status = pNtQueryValueKey(key, &ValName, KeyValueBasicInformation, NULL, 0, &i);
+ ok(status == STATUS_OBJECT_NAME_NOT_FOUND, "NtQueryValueKey with nonexistent long value name returned 0x%08x\n", status);
+
+ pRtlFreeUnicodeString(&ValName);
+ pNtClose(key);
+}
+
START_TEST(reg)
{
static const WCHAR winetest[] = {'\\','W','i','n','e','T','e','s','t',0};
test_RtlpNtQueryValueKey();
test_NtFlushKey();
test_NtQueryValueKey();
+ test_long_value_name();
test_NtDeleteKey();
test_symlinks();
test_redirection();
CHAR buffer[20];
CHAR *res;
IN_ADDR ip;
- DWORD len;
+ DWORD_PTR len;
if (!pRtlIpv4AddressToStringA)
{
len = strlen(buffer);
ok(res == (buffer + len), "got %p with '%s' (expected %p)\n", res, buffer, buffer + len);
- if (0) {
- /* this crashes in windows */
- res = pRtlIpv4AddressToStringA(&ip, NULL);
- ok( (res == (char *)~0) ||
- broken(res == (char *)0 + len), /* XP and w2003 */
- "got %p (expected ~0)\n", res);
- }
+ res = pRtlIpv4AddressToStringA(&ip, NULL);
+ ok( (res == (char *)~0) ||
+ broken(res == (char *)len), /* XP and w2003 */
+ "got %p (expected ~0)\n", res);
if (0) {
/* this crashes in windows */
static void test_wcslwrupr(void)
{
static WCHAR teststringW[] = {'a','b','r','a','c','a','d','a','b','r','a',0};
- static WCHAR emptyW[1] = {0};
- static const WCHAR constemptyW[1] = {0};
+ static WCHAR emptyW[] = {0};
+ static const WCHAR constemptyW[] = {0};
if (0) /* crashes on native */
{
static void test_bsearch(void)
{
int arr[7] = { 1, 3, 4, 8, 16, 23, 42 };
- int *x, l, i,j ;
+ int *x, l, i, j;
- /* just try all all sizes */
+ /* just try all array sizes */
for (j=1;j<sizeof(arr)/sizeof(arr[0]);j++) {
for (i=0;i<j;i++) {
l = arr[i];
projects / reactos.git / commitdiff