dlls/ntdll/tests/om.c

   1 /*
   2  * Unit test suite for object manager functions
   3  *
   4  * Copyright 2005 Robert Shearman
   5  * Copyright 2005 Vitaliy Margolen
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "ntdll_test.h"
  23 #include "winternl.h"
  24 #include "winuser.h"
  25 #include "ddk/wdm.h"
  26 #include "stdio.h"
  27 #include "winnt.h"
  28 #include "stdlib.h"
  29
  30 static VOID     (WINAPI *pRtlInitUnicodeString)( PUNICODE_STRING, LPCWSTR );
  31 static NTSTATUS (WINAPI *pNtCreateEvent) ( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES, EVENT_TYPE, BOOLEAN);
  32 static NTSTATUS (WINAPI *pNtOpenEvent)   ( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES);
  33 static NTSTATUS (WINAPI *pNtPulseEvent)  ( HANDLE, PLONG );
  34 static NTSTATUS (WINAPI *pNtQueryEvent)  ( HANDLE, EVENT_INFORMATION_CLASS, PVOID, ULONG, PULONG );
  35 static NTSTATUS (WINAPI *pNtResetEvent)  ( HANDLE, LONG* );
  36 static NTSTATUS (WINAPI *pNtSetEvent)    ( HANDLE, LONG* );
  37 static NTSTATUS (WINAPI *pNtCreateJobObject)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES );
  38 static NTSTATUS (WINAPI *pNtOpenJobObject)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES );
  39 static NTSTATUS (WINAPI *pNtCreateKey)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG,
  40                                         const UNICODE_STRING *, ULONG, PULONG );
  41 static NTSTATUS (WINAPI *pNtOpenKey)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES );
  42 static NTSTATUS (WINAPI *pNtDeleteKey)( HANDLE );
  43 static NTSTATUS (WINAPI *pNtCreateMailslotFile)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK,
  44                                                  ULONG, ULONG, ULONG, PLARGE_INTEGER );
  45 static NTSTATUS (WINAPI *pNtCreateMutant)( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES, BOOLEAN );
  46 static NTSTATUS (WINAPI *pNtOpenMutant)  ( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES );
  47 static NTSTATUS (WINAPI *pNtQueryMutant) ( HANDLE, MUTANT_INFORMATION_CLASS, PVOID, ULONG, PULONG );
  48 static NTSTATUS (WINAPI *pNtReleaseMutant)( HANDLE, PLONG );
  49 static NTSTATUS (WINAPI *pNtCreateSemaphore)( PHANDLE, ACCESS_MASK,const POBJECT_ATTRIBUTES,LONG,LONG );
  50 static NTSTATUS (WINAPI *pNtOpenSemaphore)( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES );
  51 static NTSTATUS (WINAPI *pNtQuerySemaphore)( PHANDLE, SEMAPHORE_INFORMATION_CLASS, PVOID, ULONG, PULONG );
  52 static NTSTATUS (WINAPI *pNtCreateTimer) ( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES, TIMER_TYPE );
  53 static NTSTATUS (WINAPI *pNtOpenTimer)( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES );
  54 static NTSTATUS (WINAPI *pNtCreateSection)( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES, const PLARGE_INTEGER,
  55                                             ULONG, ULONG, HANDLE );
  56 static NTSTATUS (WINAPI *pNtOpenSection)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES );
  57 static NTSTATUS (WINAPI *pNtOpenFile)    ( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK, ULONG, ULONG );
  58 static NTSTATUS (WINAPI *pNtClose)       ( HANDLE );
  59 static NTSTATUS (WINAPI *pNtCreateNamedPipeFile)( PHANDLE, ULONG, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK,
  60                                        ULONG, ULONG, ULONG, ULONG, ULONG, ULONG, ULONG, ULONG, ULONG, PLARGE_INTEGER );
  61 static NTSTATUS (WINAPI *pNtOpenDirectoryObject)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
  62 static NTSTATUS (WINAPI *pNtCreateDirectoryObject)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
  63 static NTSTATUS (WINAPI *pNtOpenSymbolicLinkObject)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
  64 static NTSTATUS (WINAPI *pNtCreateSymbolicLinkObject)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PUNICODE_STRING);
  65 static NTSTATUS (WINAPI *pNtQuerySymbolicLinkObject)(HANDLE,PUNICODE_STRING,PULONG);
  66 static NTSTATUS (WINAPI *pNtQueryObject)(HANDLE,OBJECT_INFORMATION_CLASS,PVOID,ULONG,PULONG);
  67 static NTSTATUS (WINAPI *pNtReleaseSemaphore)(HANDLE, ULONG, PULONG);
  68 static NTSTATUS (WINAPI *pNtCreateKeyedEvent)( HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES *, ULONG );
  69 static NTSTATUS (WINAPI *pNtOpenKeyedEvent)( HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES * );
  70 static NTSTATUS (WINAPI *pNtWaitForKeyedEvent)( HANDLE, const void *, BOOLEAN, const LARGE_INTEGER * );
  71 static NTSTATUS (WINAPI *pNtReleaseKeyedEvent)( HANDLE, const void *, BOOLEAN, const LARGE_INTEGER * );
  72 static NTSTATUS (WINAPI *pNtCreateIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG);
  73 static NTSTATUS (WINAPI *pNtOpenIoCompletion)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES );
  74 static NTSTATUS (WINAPI *pNtQueryInformationFile)(HANDLE, PIO_STATUS_BLOCK, void *, ULONG, FILE_INFORMATION_CLASS);
  75 static NTSTATUS (WINAPI *pNtQuerySystemTime)( LARGE_INTEGER * );
  76 static NTSTATUS (WINAPI *pRtlWaitOnAddress)( const void *, const void *, SIZE_T, const LARGE_INTEGER * );
  77 static void     (WINAPI *pRtlWakeAddressAll)( const void * );
  78 static void     (WINAPI *pRtlWakeAddressSingle)( const void * );
  79 static NTSTATUS (WINAPI *pNtOpenProcess)( HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES *, const CLIENT_ID * );
  80 static NTSTATUS (WINAPI *pNtCreateDebugObject)( HANDLE *, ACCESS_MASK, OBJECT_ATTRIBUTES *, ULONG );
  81
  82 #define KEYEDEVENT_WAIT       0x0001
  83 #define KEYEDEVENT_WAKE       0x0002
  84 #define KEYEDEVENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x0003)
  85 #define DESKTOP_ALL_ACCESS    0x01ff
  86
  87 static void test_case_sensitive (void)
  88 {
  89     NTSTATUS status;
  90     OBJECT_ATTRIBUTES attr;
  91     UNICODE_STRING str;
  92     HANDLE Event, Mutant, h;
  93
  94     pRtlInitUnicodeString(&str, L"\\BaseNamedObjects\\test");
  95     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
  96     status = pNtCreateMutant(&Mutant, GENERIC_ALL, &attr, FALSE);
  97     ok(status == STATUS_SUCCESS, "Failed to create Mutant(%08x)\n", status);
  98
  99     status = pNtCreateEvent(&Event, GENERIC_ALL, &attr, NotificationEvent, FALSE);
 100     ok(status == STATUS_OBJECT_NAME_COLLISION || status == STATUS_OBJECT_TYPE_MISMATCH /* Vista+ */, "got %#x\n", status);
 101
 102     pRtlInitUnicodeString(&str, L"\\BaseNamedObjects\\Test");
 103     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
 104     status = pNtCreateEvent(&Event, GENERIC_ALL, &attr, NotificationEvent, FALSE);
 105     ok(status == STATUS_SUCCESS, "Failed to create Event(%08x)\n", status);
 106
 107     pRtlInitUnicodeString(&str, L"\\BaseNamedObjects\\TEst");
 108     InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
 109     status = pNtOpenMutant(&h, GENERIC_ALL, &attr);
 110     ok(status == STATUS_OBJECT_TYPE_MISMATCH,
 111         "NtOpenMutant should have failed with STATUS_OBJECT_TYPE_MISMATCH got(%08x)\n", status);
 112
 113     pNtClose(Mutant);
 114
 115     pRtlInitUnicodeString(&str, L"\\BASENamedObjects\\test");
 116     InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
 117     status = pNtCreateMutant(&Mutant, GENERIC_ALL, &attr, FALSE);
 118     ok(status == STATUS_OBJECT_NAME_COLLISION || status == STATUS_OBJECT_TYPE_MISMATCH /* Vista+ */, "got %#x\n", status);
 119
 120     status = pNtCreateEvent(&h, GENERIC_ALL, &attr, NotificationEvent, FALSE);
 121     ok(status == STATUS_OBJECT_NAME_COLLISION,
 122         "NtCreateEvent should have failed with STATUS_OBJECT_NAME_COLLISION got(%08x)\n", status);
 123
 124     attr.Attributes = 0;
 125     status = pNtCreateMutant(&Mutant, GENERIC_ALL, &attr, FALSE);
 126     ok(status == STATUS_OBJECT_PATH_NOT_FOUND,
 127         "NtCreateMutant should have failed with STATUS_OBJECT_PATH_NOT_FOUND got(%08x)\n", status);
 128
 129     pNtClose(Event);
 130 }
 131
 132 static void test_namespace_pipe(void)
 133 {
 134     OBJECT_ATTRIBUTES attr;
 135     UNICODE_STRING str;
 136     IO_STATUS_BLOCK iosb;
 137     NTSTATUS status;
 138     LARGE_INTEGER timeout;
 139     HANDLE pipe, h;
 140
 141     timeout.QuadPart = -10000;
 142
 143     pRtlInitUnicodeString(&str, L"\\??\\PIPE\\test\\pipe");
 144     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
 145     status = pNtCreateNamedPipeFile(&pipe, GENERIC_READ|GENERIC_WRITE, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
 146                                     FILE_CREATE, FILE_PIPE_FULL_DUPLEX, FALSE, FALSE, FALSE, 1, 256, 256, &timeout);
 147     ok(status == STATUS_SUCCESS, "Failed to create NamedPipe(%08x)\n", status);
 148
 149     status = pNtCreateNamedPipeFile(&pipe, GENERIC_READ|GENERIC_WRITE, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
 150                                     FILE_CREATE, FILE_PIPE_FULL_DUPLEX, FALSE, FALSE, FALSE, 1, 256, 256, &timeout);
 151     ok(status == STATUS_INSTANCE_NOT_AVAILABLE,
 152         "NtCreateNamedPipeFile should have failed with STATUS_INSTANCE_NOT_AVAILABLE got(%08x)\n", status);
 153
 154     pRtlInitUnicodeString(&str, L"\\??\\PIPE\\TEST\\PIPE");
 155     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
 156     status = pNtCreateNamedPipeFile(&pipe, GENERIC_READ|GENERIC_WRITE, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
 157                                     FILE_CREATE, FILE_PIPE_FULL_DUPLEX, FALSE, FALSE, FALSE, 1, 256, 256, &timeout);
 158     ok(status == STATUS_INSTANCE_NOT_AVAILABLE,
 159         "NtCreateNamedPipeFile should have failed with STATUS_INSTANCE_NOT_AVAILABLE got(%08x)\n", status);
 160
 161     h = CreateFileA("\\\\.\\pipe\\test\\pipe", GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 162                     OPEN_EXISTING, 0, 0 );
 163     ok(h != INVALID_HANDLE_VALUE, "Failed to open NamedPipe (%u)\n", GetLastError());
 164     pNtClose(h);
 165
 166     pRtlInitUnicodeString(&str, L"\\??\\pipe\\test\\pipe");
 167     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
 168     status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0);
 169     ok(status == STATUS_OBJECT_PATH_NOT_FOUND ||
 170        status == STATUS_PIPE_NOT_AVAILABLE ||
 171        status == STATUS_OBJECT_NAME_INVALID || /* vista */
 172        status == STATUS_OBJECT_NAME_NOT_FOUND, /* win8 */
 173         "NtOpenFile should have failed with STATUS_OBJECT_PATH_NOT_FOUND got(%08x)\n", status);
 174
 175     pRtlInitUnicodeString(&str, L"\\??\\pipe\\test");
 176     InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
 177     status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0);
 178     ok(status == STATUS_OBJECT_NAME_NOT_FOUND ||
 179        status == STATUS_OBJECT_NAME_INVALID, /* vista */
 180         "NtOpenFile should have failed with STATUS_OBJECT_NAME_NOT_FOUND got(%08x)\n", status);
 181
 182     str.Length -= 4 * sizeof(WCHAR);
 183     status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0);
 184     ok(status == STATUS_SUCCESS, "NtOpenFile should have succeeded got %08x\n", status);
 185     pNtClose( h );
 186
 187     str.Length -= sizeof(WCHAR);
 188     status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0);
 189     ok(status == STATUS_SUCCESS, "NtOpenFile should have succeeded got %08x\n", status);
 190     pNtClose( h );
 191
 192     pNtClose(pipe);
 193 }
 194
 195 #define check_create_open_dir(parent, name, status) check_create_open_dir_(__LINE__, parent, name, status)
 196 static void check_create_open_dir_( int line, HANDLE parent, const WCHAR *name, NTSTATUS expect )
 197 {
 198     OBJECT_ATTRIBUTES attr;
 199     UNICODE_STRING str;
 200     NTSTATUS status;
 201     HANDLE h;
 202
 203     RtlInitUnicodeString( &str, name );
 204     InitializeObjectAttributes( &attr, &str, 0, parent, NULL );
 205     status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
 206     ok_(__FILE__, line)( status == expect, "NtCreateDirectoryObject(%s) got %08x\n", debugstr_w(name), status );
 207     if (!status) pNtClose( h );
 208
 209     status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
 210     ok_(__FILE__, line)( status == expect, "NtOpenDirectoryObject(%s) got %08x\n", debugstr_w(name), status );
 211     if (!status) pNtClose( h );
 212 }
 213
 214 static BOOL is_correct_dir( HANDLE dir, const WCHAR *name )
 215 {
 216     NTSTATUS status;
 217     UNICODE_STRING str;
 218     OBJECT_ATTRIBUTES attr;
 219     HANDLE h = 0;
 220
 221     RtlInitUnicodeString( &str, name );
 222     InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, dir, NULL);
 223     status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
 224     if (h) pNtClose( h );
 225     return (status == STATUS_OBJECT_NAME_EXISTS);
 226 }
 227
 228 /* return a handle to the BaseNamedObjects dir where kernel32 objects get created */
 229 static HANDLE get_base_dir(void)
 230 {
 231     static const WCHAR objname[] = L"om.c_get_base_dir_obj";
 232     NTSTATUS status;
 233     UNICODE_STRING str;
 234     OBJECT_ATTRIBUTES attr;
 235     HANDLE dir, h;
 236     WCHAR name[40];
 237
 238     h = CreateMutexW( NULL, FALSE, objname );
 239     ok(h != 0, "CreateMutexA failed got ret=%p (%d)\n", h, GetLastError());
 240     InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, 0, NULL);
 241
 242     swprintf( name, ARRAY_SIZE(name), L"\\BaseNamedObjects\\Session\\%u", NtCurrentTeb()->Peb->SessionId );
 243     RtlInitUnicodeString( &str, name );
 244     status = pNtOpenDirectoryObject(&dir, DIRECTORY_QUERY, &attr);
 245     ok(!status, "got %#x\n", status);
 246     ok(is_correct_dir( dir, objname ), "wrong dir\n");
 247
 248     pNtClose( h );
 249     return dir;
 250 }
 251
 252 static void test_name_collisions(void)
 253 {
 254     NTSTATUS status;
 255     UNICODE_STRING str;
 256     OBJECT_ATTRIBUTES attr;
 257     HANDLE dir, h, h1, h2;
 258     DWORD winerr;
 259     LARGE_INTEGER size;
 260
 261     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
 262     RtlInitUnicodeString(&str, L"\\");
 263     status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
 264     ok( status == STATUS_OBJECT_NAME_COLLISION, "NtCreateDirectoryObject got %08x\n", status );
 265     InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, 0, NULL);
 266
 267     status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
 268     ok( status == STATUS_OBJECT_NAME_EXISTS, "NtCreateDirectoryObject got %08x\n", status );
 269     pNtClose(h);
 270     status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
 271     ok(status == STATUS_OBJECT_TYPE_MISMATCH,
 272         "NtCreateMutant should have failed with STATUS_OBJECT_TYPE_MISMATCH got(%08x)\n", status);
 273
 274     RtlInitUnicodeString(&str, L"\\??\\PIPE\\om.c-mutant");
 275     status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
 276     todo_wine ok(status == STATUS_OBJECT_PATH_NOT_FOUND, "got %#x\n", status);
 277
 278     dir = get_base_dir();
 279     RtlInitUnicodeString(&str, L"om.c-test");
 280     InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, dir, NULL);
 281     h = CreateMutexA(NULL, FALSE, "om.c-test");
 282     ok(h != 0, "CreateMutexA failed got ret=%p (%d)\n", h, GetLastError());
 283     status = pNtCreateMutant(&h1, GENERIC_ALL, &attr, FALSE);
 284     ok(status == STATUS_OBJECT_NAME_EXISTS && h1 != NULL,
 285         "NtCreateMutant should have succeeded with STATUS_OBJECT_NAME_EXISTS got(%08x)\n", status);
 286     h2 = CreateMutexA(NULL, FALSE, "om.c-test");
 287     winerr = GetLastError();
 288     ok(h2 != 0 && winerr == ERROR_ALREADY_EXISTS,
 289         "CreateMutexA should have succeeded with ERROR_ALREADY_EXISTS got ret=%p (%d)\n", h2, winerr);
 290     pNtClose(h);
 291     pNtClose(h1);
 292     pNtClose(h2);
 293
 294     h = CreateEventA(NULL, FALSE, FALSE, "om.c-test");
 295     ok(h != 0, "CreateEventA failed got ret=%p (%d)\n", h, GetLastError());
 296     status = pNtCreateEvent(&h1, GENERIC_ALL, &attr, NotificationEvent, FALSE);
 297     ok(status == STATUS_OBJECT_NAME_EXISTS && h1 != NULL,
 298         "NtCreateEvent should have succeeded with STATUS_OBJECT_NAME_EXISTS got(%08x)\n", status);
 299     h2 = CreateEventA(NULL, FALSE, FALSE, "om.c-test");
 300     winerr = GetLastError();
 301     ok(h2 != 0 && winerr == ERROR_ALREADY_EXISTS,
 302         "CreateEventA should have succeeded with ERROR_ALREADY_EXISTS got ret=%p (%d)\n", h2, winerr);
 303     pNtClose(h);
 304     pNtClose(h1);
 305     pNtClose(h2);
 306
 307     h = CreateSemaphoreA(NULL, 1, 2, "om.c-test");
 308     ok(h != 0, "CreateSemaphoreA failed got ret=%p (%d)\n", h, GetLastError());
 309     status = pNtCreateSemaphore(&h1, GENERIC_ALL, &attr, 1, 2);
 310     ok(status == STATUS_OBJECT_NAME_EXISTS && h1 != NULL,
 311         "NtCreateSemaphore should have succeeded with STATUS_OBJECT_NAME_EXISTS got(%08x)\n", status);
 312     h2 = CreateSemaphoreA(NULL, 1, 2, "om.c-test");
 313     winerr = GetLastError();
 314     ok(h2 != 0 && winerr == ERROR_ALREADY_EXISTS,
 315         "CreateSemaphoreA should have succeeded with ERROR_ALREADY_EXISTS got ret=%p (%d)\n", h2, winerr);
 316     pNtClose(h);
 317     pNtClose(h1);
 318     pNtClose(h2);
 319
 320     h = CreateWaitableTimerA(NULL, TRUE, "om.c-test");
 321     ok(h != 0, "CreateWaitableTimerA failed got ret=%p (%d)\n", h, GetLastError());
 322     status = pNtCreateTimer(&h1, GENERIC_ALL, &attr, NotificationTimer);
 323     ok(status == STATUS_OBJECT_NAME_EXISTS && h1 != NULL,
 324         "NtCreateTimer should have succeeded with STATUS_OBJECT_NAME_EXISTS got(%08x)\n", status);
 325     h2 = CreateWaitableTimerA(NULL, TRUE, "om.c-test");
 326     winerr = GetLastError();
 327     ok(h2 != 0 && winerr == ERROR_ALREADY_EXISTS,
 328         "CreateWaitableTimerA should have succeeded with ERROR_ALREADY_EXISTS got ret=%p (%d)\n", h2, winerr);
 329     pNtClose(h);
 330     pNtClose(h1);
 331     pNtClose(h2);
 332
 333     h = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 256, "om.c-test");
 334     ok(h != 0, "CreateFileMappingA failed got ret=%p (%d)\n", h, GetLastError());
 335     size.u.LowPart = 256;
 336     size.u.HighPart = 0;
 337     status = pNtCreateSection(&h1, SECTION_MAP_WRITE, &attr, &size, PAGE_READWRITE, SEC_COMMIT, 0);
 338     ok(status == STATUS_OBJECT_NAME_EXISTS && h1 != NULL,
 339         "NtCreateSection should have succeeded with STATUS_OBJECT_NAME_EXISTS got(%08x)\n", status);
 340     h2 = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 256, "om.c-test");
 341     winerr = GetLastError();
 342     ok(h2 != 0 && winerr == ERROR_ALREADY_EXISTS,
 343         "CreateFileMappingA should have succeeded with ERROR_ALREADY_EXISTS got ret=%p (%d)\n", h2, winerr);
 344     pNtClose(h);
 345     pNtClose(h1);
 346     pNtClose(h2);
 347
 348     pNtClose(dir);
 349 }
 350
 351 static void test_all_kernel_objects( UINT line, OBJECT_ATTRIBUTES *attr,
 352                                      NTSTATUS create_expect, NTSTATUS open_expect )
 353 {
 354     UNICODE_STRING target;
 355     LARGE_INTEGER size;
 356     NTSTATUS status, status2;
 357     HANDLE ret, ret2;
 358
 359     RtlInitUnicodeString( &target, L"\\DosDevices" );
 360     size.QuadPart = 4096;
 361
 362     status = pNtCreateMutant( &ret, GENERIC_ALL, attr, FALSE );
 363     ok( status == create_expect, "%u: NtCreateMutant failed %x\n", line, status );
 364     status2 = pNtOpenMutant( &ret2, GENERIC_ALL, attr );
 365     ok( status2 == open_expect, "%u: NtOpenMutant failed %x\n", line, status2 );
 366     if (!status) pNtClose( ret );
 367     if (!status2) pNtClose( ret2 );
 368     status = pNtCreateSemaphore( &ret, GENERIC_ALL, attr, 1, 2 );
 369     ok( status == create_expect, "%u: NtCreateSemaphore failed %x\n", line, status );
 370     status2 = pNtOpenSemaphore( &ret2, GENERIC_ALL, attr );
 371     ok( status2 == open_expect, "%u: NtOpenSemaphore failed %x\n", line, status2 );
 372     if (!status) pNtClose( ret );
 373     if (!status2) pNtClose( ret2 );
 374     status = pNtCreateEvent( &ret, GENERIC_ALL, attr, SynchronizationEvent, 0 );
 375     ok( status == create_expect, "%u: NtCreateEvent failed %x\n", line, status );
 376     status2 = pNtOpenEvent( &ret2, GENERIC_ALL, attr );
 377     ok( status2 == open_expect, "%u: NtOpenEvent failed %x\n", line, status2 );
 378     if (!status) pNtClose( ret );
 379     if (!status2) pNtClose( ret2 );
 380     status = pNtCreateKeyedEvent( &ret, GENERIC_ALL, attr, 0 );
 381     ok( status == create_expect, "%u: NtCreateKeyedEvent failed %x\n", line, status );
 382     status2 = pNtOpenKeyedEvent( &ret2, GENERIC_ALL, attr );
 383     ok( status2 == open_expect, "%u: NtOpenKeyedEvent failed %x\n", line, status2 );
 384     if (!status) pNtClose( ret );
 385     if (!status2) pNtClose( ret2 );
 386     status = pNtCreateTimer( &ret, GENERIC_ALL, attr, NotificationTimer );
 387     ok( status == create_expect, "%u: NtCreateTimer failed %x\n", line, status );
 388     status2 = pNtOpenTimer( &ret2, GENERIC_ALL, attr );
 389     ok( status2 == open_expect, "%u: NtOpenTimer failed %x\n", line, status2 );
 390     if (!status) pNtClose( ret );
 391     if (!status2) pNtClose( ret2 );
 392     status = pNtCreateIoCompletion( &ret, GENERIC_ALL, attr, 0 );
 393     ok( status == create_expect, "%u: NtCreateCompletion failed %x\n", line, status );
 394     status2 = pNtOpenIoCompletion( &ret2, GENERIC_ALL, attr );
 395     ok( status2 == open_expect, "%u: NtOpenCompletion failed %x\n", line, status2 );
 396     if (!status) pNtClose( ret );
 397     if (!status2) pNtClose( ret2 );
 398     status = pNtCreateJobObject( &ret, GENERIC_ALL, attr );
 399     ok( status == create_expect, "%u: NtCreateJobObject failed %x\n", line, status );
 400     status2 = pNtOpenJobObject( &ret2, GENERIC_ALL, attr );
 401     ok( status2 == open_expect, "%u: NtOpenJobObject failed %x\n", line, status2 );
 402     if (!status) pNtClose( ret );
 403     if (!status2) pNtClose( ret2 );
 404     status = pNtCreateDirectoryObject( &ret, GENERIC_ALL, attr );
 405     ok( status == create_expect, "%u: NtCreateDirectoryObject failed %x\n", line, status );
 406     status2 = pNtOpenDirectoryObject( &ret2, GENERIC_ALL, attr );
 407     ok( status2 == open_expect, "%u: NtOpenDirectoryObject failed %x\n", line, status2 );
 408     if (!status) pNtClose( ret );
 409     if (!status2) pNtClose( ret2 );
 410     status = pNtCreateSymbolicLinkObject( &ret, GENERIC_ALL, attr, &target );
 411     ok( status == create_expect, "%u: NtCreateSymbolicLinkObject failed %x\n", line, status );
 412     status2 = pNtOpenSymbolicLinkObject( &ret2, GENERIC_ALL, attr );
 413     ok( status2 == open_expect, "%u: NtOpenSymbolicLinkObject failed %x\n", line, status2 );
 414     if (!status) pNtClose( ret );
 415     if (!status2) pNtClose( ret2 );
 416     status = pNtCreateSection( &ret, SECTION_MAP_WRITE, attr, &size, PAGE_READWRITE, SEC_COMMIT, 0 );
 417     ok( status == create_expect, "%u: NtCreateSection failed %x\n", line, status );
 418     status2 = pNtOpenSection( &ret2, SECTION_MAP_WRITE, attr );
 419     ok( status2 == open_expect, "%u: NtOpenSection failed %x\n", line, status2 );
 420     if (!status) pNtClose( ret );
 421     if (!status2) pNtClose( ret2 );
 422     status = pNtCreateDebugObject( &ret, DEBUG_ALL_ACCESS, attr, 0 );
 423     ok( status == create_expect, "%u: NtCreateDebugObject failed %x\n", line, status );
 424     if (!status) pNtClose( ret );
 425 }
 426
 427 static void test_name_limits(void)
 428 {
 429     static const WCHAR pipeW[]     = L"\\Device\\NamedPipe\\";
 430     static const WCHAR mailslotW[] = L"\\Device\\MailSlot\\";
 431     static const WCHAR registryW[] = L"\\REGISTRY\\Machine\\SOFTWARE\\Microsoft\\";
 432     OBJECT_ATTRIBUTES attr, attr2, attr3;
 433     IO_STATUS_BLOCK iosb;
 434     LARGE_INTEGER size, timeout;
 435     UNICODE_STRING str, str2, target;
 436     NTSTATUS status;
 437     HANDLE ret, ret2;
 438     DWORD i;
 439
 440     InitializeObjectAttributes( &attr, &str, 0, 0, NULL );
 441     InitializeObjectAttributes( &attr2, &str, 0, (HANDLE)0xdeadbeef, NULL );
 442     InitializeObjectAttributes( &attr3, &str, 0, 0, NULL );
 443     str.Buffer = HeapAlloc( GetProcessHeap(), 0, 65536 + sizeof(registryW));
 444     str.MaximumLength = 65534;
 445     for (i = 0; i < 65536 / sizeof(WCHAR); i++) str.Buffer[i] = 'a';
 446     size.QuadPart = 4096;
 447     RtlInitUnicodeString( &target, L"\\DosDevices" );
 448
 449     attr.RootDirectory = get_base_dir();
 450     str.Length = 0;
 451     status = pNtCreateMutant( &ret, GENERIC_ALL, &attr2, FALSE );
 452     ok( status == STATUS_SUCCESS, "%u: NtCreateMutant failed %x\n", str.Length, status );
 453     attr3.RootDirectory = ret;
 454     status = pNtOpenMutant( &ret2, GENERIC_ALL, &attr );
 455     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenMutant failed %x\n", str.Length, status );
 456     status = pNtOpenMutant( &ret2, GENERIC_ALL, &attr3 );
 457     ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE /* < 7 */,
 458         "%u: NtOpenMutant failed %x\n", str.Length, status );
 459     pNtClose( ret );
 460     status = pNtCreateSemaphore( &ret, GENERIC_ALL, &attr2, 1, 2 );
 461     ok( status == STATUS_SUCCESS, "%u: NtCreateSemaphore failed %x\n", str.Length, status );
 462     attr3.RootDirectory = ret;
 463     status = pNtOpenSemaphore( &ret2, GENERIC_ALL, &attr );
 464     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenSemaphore failed %x\n", str.Length, status );
 465     status = pNtOpenSemaphore( &ret2, GENERIC_ALL, &attr3 );
 466     ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE /* < 7 */,
 467         "%u: NtOpenSemaphore failed %x\n", str.Length, status );
 468     pNtClose( ret );
 469     status = pNtCreateEvent( &ret, GENERIC_ALL, &attr2, SynchronizationEvent, 0 );
 470     ok( status == STATUS_SUCCESS, "%u: NtCreateEvent failed %x\n", str.Length, status );
 471     attr3.RootDirectory = ret;
 472     status = pNtOpenEvent( &ret2, GENERIC_ALL, &attr );
 473     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenEvent failed %x\n", str.Length, status );
 474     status = pNtOpenEvent( &ret2, GENERIC_ALL, &attr3 );
 475     ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE /* < 7 */,
 476         "%u: NtOpenEvent failed %x\n", str.Length, status );
 477     pNtClose( ret );
 478     status = pNtCreateKeyedEvent( &ret, GENERIC_ALL, &attr2, 0 );
 479     ok( status == STATUS_SUCCESS, "%u: NtCreateKeyedEvent failed %x\n", str.Length, status );
 480     attr3.RootDirectory = ret;
 481     status = pNtOpenKeyedEvent( &ret2, GENERIC_ALL, &attr );
 482     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenKeyedEvent failed %x\n", str.Length, status );
 483     status = pNtOpenKeyedEvent( &ret2, GENERIC_ALL, &attr3 );
 484     ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE /* < 7 */,
 485         "%u: NtOpenKeyedEvent failed %x\n", str.Length, status );
 486     pNtClose( ret );
 487     status = pNtCreateTimer( &ret, GENERIC_ALL, &attr2, NotificationTimer );
 488     ok( status == STATUS_SUCCESS, "%u: NtCreateTimer failed %x\n", str.Length, status );
 489     attr3.RootDirectory = ret;
 490     status = pNtOpenTimer( &ret2, GENERIC_ALL, &attr );
 491     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenTimer failed %x\n", str.Length, status );
 492     status = pNtOpenTimer( &ret2, GENERIC_ALL, &attr3 );
 493     ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE /* < 7 */,
 494         "%u: NtOpenTimer failed %x\n", str.Length, status );
 495     pNtClose( ret );
 496     status = pNtCreateIoCompletion( &ret, GENERIC_ALL, &attr2, 0 );
 497     ok( status == STATUS_SUCCESS, "%u: NtCreateCompletion failed %x\n", str.Length, status );
 498     attr3.RootDirectory = ret;
 499     status = pNtOpenIoCompletion( &ret2, GENERIC_ALL, &attr );
 500     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenCompletion failed %x\n", str.Length, status );
 501     status = pNtOpenIoCompletion( &ret2, GENERIC_ALL, &attr3 );
 502     ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE /* < 7 */,
 503         "%u: NtOpenCompletion failed %x\n", str.Length, status );
 504     pNtClose( ret );
 505     status = pNtCreateJobObject( &ret, GENERIC_ALL, &attr2 );
 506     ok( status == STATUS_SUCCESS, "%u: NtCreateJobObject failed %x\n", str.Length, status );
 507     attr3.RootDirectory = ret;
 508     status = pNtOpenJobObject( &ret2, GENERIC_ALL, &attr );
 509     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenJobObject failed %x\n", str.Length, status );
 510     status = pNtOpenJobObject( &ret2, GENERIC_ALL, &attr3 );
 511     ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE /* < 7 */,
 512         "%u: NtOpenJobObject failed %x\n", str.Length, status );
 513     pNtClose( ret );
 514     status = pNtCreateDirectoryObject( &ret, GENERIC_ALL, &attr2 );
 515     ok( status == STATUS_SUCCESS, "%u: NtCreateDirectoryObject failed %x\n", str.Length, status );
 516     attr3.RootDirectory = ret;
 517     status = pNtOpenDirectoryObject( &ret2, GENERIC_ALL, &attr );
 518     ok( status == STATUS_SUCCESS || broken(status == STATUS_ACCESS_DENIED), /* winxp */
 519         "%u: NtOpenDirectoryObject failed %x\n", str.Length, status );
 520     if (!status) pNtClose( ret2 );
 521     status = pNtOpenDirectoryObject( &ret2, GENERIC_ALL, &attr3 );
 522     ok( status == STATUS_SUCCESS, "%u: NtOpenDirectoryObject failed %x\n", str.Length, status );
 523     pNtClose( ret2 );
 524     pNtClose( ret );
 525     status = pNtCreateSymbolicLinkObject( &ret, GENERIC_ALL, &attr2, &target );
 526     ok( status == STATUS_SUCCESS, "%u: NtCreateSymbolicLinkObject failed %x\n", str.Length, status );
 527     attr3.RootDirectory = ret;
 528     status = pNtOpenSymbolicLinkObject( &ret2, GENERIC_ALL, &attr );
 529     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenSymbolicLinkObject failed %x\n", str.Length, status );
 530     status = pNtOpenSymbolicLinkObject( &ret2, GENERIC_ALL, &attr3 );
 531     ok( status == STATUS_SUCCESS, "%u: NtOpenSymbolicLinkObject failed %x\n", str.Length, status );
 532     pNtClose( ret2 );
 533     pNtClose( ret );
 534     status = pNtCreateSection( &ret, SECTION_MAP_WRITE, &attr2, &size, PAGE_READWRITE, SEC_COMMIT, 0 );
 535     ok( status == STATUS_SUCCESS, "%u: NtCreateSection failed %x\n", str.Length, status );
 536     attr3.RootDirectory = ret;
 537     status = pNtOpenSection( &ret2, SECTION_MAP_WRITE, &attr );
 538     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenSection failed %x\n", str.Length, status );
 539     status = pNtOpenSection( &ret2, SECTION_MAP_WRITE, &attr3 );
 540     ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE /* < 7 */,
 541         "%u: NtOpenSection failed %x\n", str.Length, status );
 542     pNtClose( ret );
 543
 544     str.Length = 67;
 545     test_all_kernel_objects( __LINE__, &attr2, STATUS_OBJECT_NAME_INVALID, STATUS_OBJECT_NAME_INVALID );
 546
 547     str.Length = 65532;
 548     test_all_kernel_objects( __LINE__, &attr, STATUS_SUCCESS, STATUS_SUCCESS );
 549
 550     str.Length = 65534;
 551     test_all_kernel_objects( __LINE__, &attr, STATUS_OBJECT_NAME_INVALID, STATUS_OBJECT_NAME_INVALID );
 552
 553     str.Length = 128;
 554     for (attr.Length = 0; attr.Length <= 2 * sizeof(attr); attr.Length++)
 555     {
 556         if (attr.Length == sizeof(attr))
 557             test_all_kernel_objects( __LINE__, &attr, STATUS_SUCCESS, STATUS_SUCCESS );
 558         else
 559             test_all_kernel_objects( __LINE__, &attr, STATUS_INVALID_PARAMETER, STATUS_INVALID_PARAMETER );
 560     }
 561     attr.Length = sizeof(attr);
 562
 563     /* null attributes or ObjectName, with or without RootDirectory */
 564     attr3.RootDirectory = 0;
 565     attr2.ObjectName = attr3.ObjectName = NULL;
 566     test_all_kernel_objects( __LINE__, &attr2, STATUS_OBJECT_NAME_INVALID, STATUS_OBJECT_NAME_INVALID );
 567     test_all_kernel_objects( __LINE__, &attr3, STATUS_SUCCESS, STATUS_OBJECT_PATH_SYNTAX_BAD );
 568
 569     attr3.ObjectName = &str2;
 570     pRtlInitUnicodeString( &str2, L"\\BaseNamedObjects\\Local" );
 571     status = pNtOpenSymbolicLinkObject( &ret, SYMBOLIC_LINK_QUERY, &attr3 );
 572     ok( status == STATUS_SUCCESS, "can't open BaseNamedObjects\\Local %x\n", status );
 573     attr3.ObjectName = &str;
 574     attr3.RootDirectory = ret;
 575     test_all_kernel_objects( __LINE__, &attr3, STATUS_OBJECT_TYPE_MISMATCH, STATUS_OBJECT_TYPE_MISMATCH );
 576     pNtClose( attr3.RootDirectory );
 577
 578     status = pNtCreateMutant( &ret, GENERIC_ALL, NULL, FALSE );
 579     ok( status == STATUS_SUCCESS, "NULL: NtCreateMutant failed %x\n", status );
 580     pNtClose( ret );
 581     status = pNtOpenMutant( &ret, GENERIC_ALL, NULL );
 582     ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenMutant failed %x\n", status );
 583     status = pNtCreateSemaphore( &ret, GENERIC_ALL, NULL, 1, 2 );
 584     ok( status == STATUS_SUCCESS, "NULL: NtCreateSemaphore failed %x\n", status );
 585     pNtClose( ret );
 586     status = pNtOpenSemaphore( &ret, GENERIC_ALL, NULL );
 587     ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenSemaphore failed %x\n", status );
 588     status = pNtCreateEvent( &ret, GENERIC_ALL, NULL, SynchronizationEvent, 0 );
 589     ok( status == STATUS_SUCCESS, "NULL: NtCreateEvent failed %x\n", status );
 590     pNtClose( ret );
 591     status = pNtOpenEvent( &ret, GENERIC_ALL, NULL );
 592     ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenEvent failed %x\n", status );
 593     status = pNtCreateKeyedEvent( &ret, GENERIC_ALL, NULL, 0 );
 594     ok( status == STATUS_SUCCESS, "NULL: NtCreateKeyedEvent failed %x\n", status );
 595     pNtClose( ret );
 596     status = pNtOpenKeyedEvent( &ret, GENERIC_ALL, NULL );
 597     ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenKeyedEvent failed %x\n", status );
 598     status = pNtCreateTimer( &ret, GENERIC_ALL, NULL, NotificationTimer );
 599     ok( status == STATUS_SUCCESS, "NULL: NtCreateTimer failed %x\n", status );
 600     pNtClose( ret );
 601     status = pNtOpenTimer( &ret, GENERIC_ALL, NULL );
 602     ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenTimer failed %x\n", status );
 603     status = pNtCreateIoCompletion( &ret, GENERIC_ALL, NULL, 0 );
 604     ok( status == STATUS_SUCCESS, "NULL: NtCreateCompletion failed %x\n", status );
 605     pNtClose( ret );
 606     status = pNtOpenIoCompletion( &ret, GENERIC_ALL, NULL );
 607     ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenCompletion failed %x\n", status );
 608     status = pNtCreateJobObject( &ret, GENERIC_ALL, NULL );
 609     ok( status == STATUS_SUCCESS, "NULL: NtCreateJobObject failed %x\n", status );
 610     pNtClose( ret );
 611     status = pNtOpenJobObject( &ret, GENERIC_ALL, NULL );
 612     ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenJobObject failed %x\n", status );
 613     status = pNtCreateDirectoryObject( &ret, GENERIC_ALL, NULL );
 614     ok( status == STATUS_SUCCESS, "NULL: NtCreateDirectoryObject failed %x\n", status );
 615     pNtClose( ret );
 616     status = pNtOpenDirectoryObject( &ret, GENERIC_ALL, NULL );
 617     ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenDirectoryObject failed %x\n", status );
 618     status = pNtCreateSymbolicLinkObject( &ret, GENERIC_ALL, NULL, &target );
 619     ok( status == STATUS_ACCESS_VIOLATION || broken( status == STATUS_SUCCESS), /* winxp */
 620         "NULL: NtCreateSymbolicLinkObject failed %x\n", status );
 621     if (!status) pNtClose( ret );
 622     status = pNtOpenSymbolicLinkObject( &ret, GENERIC_ALL, NULL );
 623     ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenSymbolicLinkObject failed %x\n", status );
 624     status = pNtCreateSection( &ret, SECTION_MAP_WRITE, NULL, &size, PAGE_READWRITE, SEC_COMMIT, 0 );
 625     ok( status == STATUS_SUCCESS, "NULL: NtCreateSection failed %x\n", status );
 626     pNtClose( ret );
 627     status = pNtOpenSection( &ret, SECTION_MAP_WRITE, NULL );
 628     ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenSection failed %x\n", status );
 629     attr2.ObjectName = attr3.ObjectName = &str;
 630
 631     /* named pipes */
 632     wcscpy( str.Buffer, pipeW );
 633     for (i = 0; i < 65536 / sizeof(WCHAR); i++) str.Buffer[i + wcslen( pipeW )] = 'a';
 634     str.Length = 0;
 635     attr.RootDirectory = 0;
 636     attr.Attributes = OBJ_CASE_INSENSITIVE;
 637     timeout.QuadPart = -10000;
 638     status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
 639                                      FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
 640     ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
 641     status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr2, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
 642                                      FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
 643     ok( status == STATUS_INVALID_HANDLE, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
 644     str.Length = 67;
 645     status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr2, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
 646                                      FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
 647     ok( status == STATUS_OBJECT_NAME_INVALID, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
 648     str.Length = 128;
 649     for (attr.Length = 0; attr.Length <= 2 * sizeof(attr); attr.Length++)
 650     {
 651         status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
 652                                       FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
 653         if (attr.Length == sizeof(attr))
 654         {
 655             ok( status == STATUS_SUCCESS, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
 656             pNtClose( ret );
 657         }
 658         else ok( status == STATUS_INVALID_PARAMETER,
 659                  "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
 660     }
 661     attr.Length = sizeof(attr);
 662     str.Length = 65532;
 663     status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
 664                                      FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
 665     ok( status == STATUS_SUCCESS, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
 666     pNtClose( ret );
 667     str.Length = 65534;
 668     status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
 669                                      FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
 670     ok( status == STATUS_OBJECT_NAME_INVALID, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
 671     attr3.RootDirectory = 0;
 672     attr2.ObjectName = attr3.ObjectName = NULL;
 673     status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr2, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
 674                                      FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
 675     ok( status == STATUS_OBJECT_NAME_INVALID, "NULL: NtCreateNamedPipeFile failed %x\n", status );
 676     status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr3, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
 677                                      FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
 678     ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NULL: NtCreateNamedPipeFile failed %x\n", status );
 679     status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, NULL, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
 680                                      FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
 681     ok( status == STATUS_INVALID_PARAMETER, "NULL: NtCreateNamedPipeFile failed %x\n", status );
 682     attr2.ObjectName = attr3.ObjectName = &str;
 683
 684     /* mailslots */
 685     wcscpy( str.Buffer, mailslotW );
 686     for (i = 0; i < 65536 / sizeof(WCHAR); i++) str.Buffer[i + wcslen( mailslotW )] = 'a';
 687     str.Length = 0;
 688     status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr, &iosb, 0, 0, 0, NULL );
 689     ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
 690     status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr2, &iosb, 0, 0, 0, NULL );
 691     ok( status == STATUS_INVALID_HANDLE, "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
 692     str.Length = 67;
 693     status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr2, &iosb, 0, 0, 0, NULL );
 694     ok( status == STATUS_OBJECT_NAME_INVALID, "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
 695     str.Length = 128;
 696     for (attr.Length = 0; attr.Length <= 2 * sizeof(attr); attr.Length++)
 697     {
 698         status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr, &iosb, 0, 0, 0, NULL );
 699         if (attr.Length == sizeof(attr))
 700         {
 701             ok( status == STATUS_SUCCESS, "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
 702             pNtClose( ret );
 703         }
 704         else ok( status == STATUS_INVALID_PARAMETER,
 705                  "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
 706     }
 707     attr.Length = sizeof(attr);
 708     str.Length = 65532;
 709     status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr, &iosb, 0, 0, 0, NULL );
 710     ok( status == STATUS_SUCCESS, "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
 711     pNtClose( ret );
 712     str.Length = 65534;
 713     status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr, &iosb, 0, 0, 0, NULL );
 714     ok( status == STATUS_OBJECT_NAME_INVALID, "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
 715     attr3.RootDirectory = 0;
 716     attr2.ObjectName = attr3.ObjectName = NULL;
 717     status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr2, &iosb, 0, 0, 0, NULL );
 718     ok( status == STATUS_OBJECT_NAME_INVALID, "NULL: NtCreateMailslotFile failed %x\n", status );
 719     status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr3, &iosb, 0, 0, 0, NULL );
 720     ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NULL: NtCreateMailslotFile failed %x\n", status );
 721     status = pNtCreateMailslotFile( &ret, GENERIC_ALL, NULL, &iosb, 0, 0, 0, NULL );
 722     ok( status == STATUS_INVALID_PARAMETER, "NULL: NtCreateMailslotFile failed %x\n", status );
 723     attr2.ObjectName = attr3.ObjectName = &str;
 724
 725     /* registry keys */
 726     wcscpy( str.Buffer, registryW );
 727     for (i = 0; i < 65536 / sizeof(WCHAR); i++) str.Buffer[i + wcslen(registryW)] = 'a';
 728     str.Length = 0;
 729     status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
 730     todo_wine
 731     ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "%u: NtCreateKey failed %x\n", str.Length, status );
 732     status = pNtCreateKey( &ret, GENERIC_ALL, &attr2, 0, NULL, 0, NULL );
 733     ok( status == STATUS_INVALID_HANDLE, "%u: NtCreateKey failed %x\n", str.Length, status );
 734     status = pNtOpenKey( &ret, GENERIC_ALL, &attr2 );
 735     ok( status == STATUS_INVALID_HANDLE, "%u: NtOpenKey failed %x\n", str.Length, status );
 736     str.Length = (wcslen( registryW ) + 250) * sizeof(WCHAR) + 1;
 737     status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
 738     ok( status == STATUS_OBJECT_NAME_INVALID ||
 739         status == STATUS_INVALID_PARAMETER ||
 740         broken( status == STATUS_SUCCESS ), /* wow64 */
 741         "%u: NtCreateKey failed %x\n", str.Length, status );
 742     if (!status)
 743     {
 744         pNtDeleteKey( ret );
 745         pNtClose( ret );
 746     }
 747     str.Length = (wcslen( registryW ) + 256) * sizeof(WCHAR);
 748     status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
 749     ok( status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED,
 750         "%u: NtCreateKey failed %x\n", str.Length, status );
 751     if (!status)
 752     {
 753         status = pNtOpenKey( &ret2, KEY_READ, &attr );
 754         ok( status == STATUS_SUCCESS, "%u: NtOpenKey failed %x\n", str.Length, status );
 755         pNtClose( ret2 );
 756         attr3.RootDirectory = ret;
 757         str.Length = 0;
 758         status = pNtOpenKey( &ret2, KEY_READ, &attr3 );
 759         ok( status == STATUS_SUCCESS, "%u: NtOpenKey failed %x\n", str.Length, status );
 760         pNtClose( ret2 );
 761         pNtDeleteKey( ret );
 762         pNtClose( ret );
 763
 764         str.Length = (wcslen( registryW ) + 256) * sizeof(WCHAR);
 765         for (attr.Length = 0; attr.Length <= 2 * sizeof(attr); attr.Length++)
 766         {
 767             if (attr.Length == sizeof(attr))
 768             {
 769                 status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
 770                 ok( status == STATUS_SUCCESS, "%u: NtCreateKey failed %x\n", str.Length, status );
 771                 status = pNtOpenKey( &ret2, KEY_READ, &attr );
 772                 ok( status == STATUS_SUCCESS, "%u: NtOpenKey failed %x\n", str.Length, status );
 773                 pNtClose( ret2 );
 774                 pNtDeleteKey( ret );
 775                 pNtClose( ret );
 776             }
 777             else
 778             {
 779                 status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
 780                 ok( status == STATUS_INVALID_PARAMETER, "%u: NtCreateKey failed %x\n", str.Length, status );
 781                 status = pNtOpenKey( &ret2, KEY_READ, &attr );
 782                 ok( status == STATUS_INVALID_PARAMETER, "%u: NtOpenKey failed %x\n", str.Length, status );
 783             }
 784         }
 785         attr.Length = sizeof(attr);
 786     }
 787     str.Length = (wcslen( registryW ) + 256) * sizeof(WCHAR) + 1;
 788     status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
 789     ok( status == STATUS_OBJECT_NAME_INVALID ||
 790         status == STATUS_INVALID_PARAMETER ||
 791         broken( status == STATUS_SUCCESS ), /* win7 */
 792         "%u: NtCreateKey failed %x\n", str.Length, status );
 793     if (!status)
 794     {
 795         pNtDeleteKey( ret );
 796         pNtClose( ret );
 797     }
 798     status = pNtOpenKey( &ret, GENERIC_ALL, &attr );
 799     ok( status == STATUS_OBJECT_NAME_INVALID ||
 800         status == STATUS_INVALID_PARAMETER ||
 801         broken( status == STATUS_OBJECT_NAME_NOT_FOUND ), /* wow64 */
 802         "%u: NtOpenKey failed %x\n", str.Length, status );
 803     str.Length++;
 804     status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
 805     ok( status == STATUS_INVALID_PARAMETER, "%u: NtCreateKey failed %x\n", str.Length, status );
 806     status = pNtOpenKey( &ret, GENERIC_ALL, &attr );
 807     todo_wine
 808     ok( status == STATUS_INVALID_PARAMETER, "%u: NtOpenKey failed %x\n", str.Length, status );
 809     str.Length = 2000;
 810     status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
 811     ok( status == STATUS_INVALID_PARAMETER, "%u: NtCreateKey failed %x\n", str.Length, status );
 812     status = pNtOpenKey( &ret, GENERIC_ALL, &attr );
 813     todo_wine
 814     ok( status == STATUS_INVALID_PARAMETER, "%u: NtOpenKey failed %x\n", str.Length, status );
 815     /* some Windows versions change the error past 2050 chars, others past 4066 chars, some don't */
 816     str.Length = 5000;
 817     status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
 818     ok( status == STATUS_BUFFER_OVERFLOW ||
 819         status == STATUS_BUFFER_TOO_SMALL ||
 820         status == STATUS_INVALID_PARAMETER,
 821         "%u: NtCreateKey failed %x\n", str.Length, status );
 822     status = pNtOpenKey( &ret, GENERIC_ALL, &attr );
 823     todo_wine
 824     ok( status == STATUS_BUFFER_OVERFLOW ||
 825         status == STATUS_BUFFER_TOO_SMALL ||
 826         status == STATUS_INVALID_PARAMETER,
 827          "%u: NtOpenKey failed %x\n", str.Length, status );
 828     str.Length = 65534;
 829     status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
 830     ok( status == STATUS_OBJECT_NAME_INVALID ||
 831         status == STATUS_BUFFER_OVERFLOW ||
 832         status == STATUS_BUFFER_TOO_SMALL,
 833         "%u: NtCreateKey failed %x\n", str.Length, status );
 834     status = pNtOpenKey( &ret, GENERIC_ALL, &attr );
 835     todo_wine
 836     ok( status == STATUS_OBJECT_NAME_INVALID ||
 837         status == STATUS_BUFFER_OVERFLOW ||
 838         status == STATUS_BUFFER_TOO_SMALL,
 839          "%u: NtOpenKey failed %x\n", str.Length, status );
 840     attr3.RootDirectory = 0;
 841     attr2.ObjectName = attr3.ObjectName = NULL;
 842     status = pNtCreateKey( &ret, GENERIC_ALL, &attr2, 0, NULL, 0, NULL );
 843     todo_wine
 844     ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE /* vista wow64 */,
 845         "NULL: NtCreateKey failed %x\n", status );
 846     status = pNtCreateKey( &ret, GENERIC_ALL, &attr3, 0, NULL, 0, NULL );
 847     todo_wine
 848     ok( status == STATUS_ACCESS_VIOLATION, "NULL: NtCreateKey failed %x\n", status );
 849     status = pNtCreateKey( &ret, GENERIC_ALL, NULL, 0, NULL, 0, NULL );
 850     ok( status == STATUS_ACCESS_VIOLATION, "NULL: NtCreateKey failed %x\n", status );
 851     status = pNtOpenKey( &ret, GENERIC_ALL, &attr2 );
 852     ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE /* vista wow64 */,
 853         "NULL: NtOpenKey failed %x\n", status );
 854     status = pNtOpenKey( &ret, GENERIC_ALL, &attr3 );
 855     ok( status == STATUS_ACCESS_VIOLATION, "NULL: NtOpenKey failed %x\n", status );
 856     status = pNtOpenKey( &ret, GENERIC_ALL, NULL );
 857     ok( status == STATUS_ACCESS_VIOLATION, "NULL: NtOpenKey failed %x\n", status );
 858     attr2.ObjectName = attr3.ObjectName = &str;
 859
 860     HeapFree( GetProcessHeap(), 0, str.Buffer );
 861 }
 862
 863 static void test_directory(void)
 864 {
 865     NTSTATUS status;
 866     UNICODE_STRING str;
 867     OBJECT_ATTRIBUTES attr;
 868     HANDLE dir, dir1, h, h2;
 869     WCHAR buffer[256];
 870     ULONG len, full_len;
 871
 872     /* No name and/or no attributes */
 873     status = pNtCreateDirectoryObject(NULL, DIRECTORY_QUERY, &attr);
 874     ok(status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER /* wow64 */, "got %#x\n", status);
 875     status = pNtOpenDirectoryObject(NULL, DIRECTORY_QUERY, &attr);
 876     ok(status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER /* wow64 */, "got %#x\n", status);
 877
 878     status = pNtCreateDirectoryObject(&h, DIRECTORY_QUERY, NULL);
 879     ok(status == STATUS_SUCCESS, "Failed to create Directory without attributes(%08x)\n", status);
 880     pNtClose(h);
 881     status = pNtOpenDirectoryObject(&h, DIRECTORY_QUERY, NULL);
 882     ok(status == STATUS_INVALID_PARAMETER,
 883         "NtOpenDirectoryObject should have failed with STATUS_INVALID_PARAMETER got(%08x)\n", status);
 884
 885     InitializeObjectAttributes(&attr, NULL, 0, 0, NULL);
 886     status = pNtCreateDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
 887     ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
 888     status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
 889     ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenDirectoryObject got %08x\n", status );
 890
 891     /* Bad name */
 892     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
 893
 894     RtlInitUnicodeString(&str, L"");
 895     status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
 896     ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
 897     pNtClose(h);
 898     status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
 899     ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenDirectoryObject got %08x\n", status );
 900     pNtClose(dir);
 901
 902     check_create_open_dir( NULL, L"BaseNamedObjects", STATUS_OBJECT_PATH_SYNTAX_BAD );
 903     check_create_open_dir( NULL, L"\\BaseNamedObjects\\", STATUS_OBJECT_NAME_INVALID );
 904     check_create_open_dir( NULL, L"\\\\BaseNamedObjects", STATUS_OBJECT_NAME_INVALID );
 905     check_create_open_dir( NULL, L"\\BaseNamedObjects\\\\om.c-test", STATUS_OBJECT_NAME_INVALID );
 906     check_create_open_dir( NULL, L"\\BaseNamedObjects\\om.c-test\\", STATUS_OBJECT_PATH_NOT_FOUND );
 907
 908     RtlInitUnicodeString(&str, L"\\BaseNamedObjects\\om.c-test");
 909     status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
 910     ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
 911     status = pNtOpenDirectoryObject( &dir1, DIRECTORY_QUERY, &attr );
 912     ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status );
 913     pNtClose(h);
 914     pNtClose(dir1);
 915
 916
 917     /* Use of root directory */
 918
 919     /* Can't use symlinks as a directory */
 920     RtlInitUnicodeString(&str, L"\\BaseNamedObjects\\Local");
 921     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
 922     status = pNtOpenSymbolicLinkObject(&dir, SYMBOLIC_LINK_QUERY, &attr);
 923
 924     ok(status == STATUS_SUCCESS, "Failed to open SymbolicLink(%08x)\n", status);
 925     InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
 926     RtlInitUnicodeString(&str, L"one more level");
 927     status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
 928     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtCreateDirectoryObject got %08x\n", status );
 929
 930     RtlInitUnicodeString( &str, L"\\BaseNamedObjects\\Local\\om.c-test" );
 931     InitializeObjectAttributes( &attr, &str, 0, 0, NULL );
 932     status = pNtCreateDirectoryObject( &dir1, DIRECTORY_QUERY, &attr );
 933     ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
 934     RtlInitUnicodeString( &str, L"om.c-test" );
 935     InitializeObjectAttributes( &attr, &str, 0, dir, NULL );
 936     status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
 937     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "Failed to open directory %08x\n", status );
 938
 939     RtlInitUnicodeString( &str, L"om.c-event" );
 940     InitializeObjectAttributes( &attr, &str, 0, dir1, NULL );
 941     status = pNtCreateEvent( &h, GENERIC_ALL, &attr, SynchronizationEvent, 0 );
 942     ok( status == STATUS_SUCCESS, "NtCreateEvent failed %x\n", status );
 943     status = pNtOpenEvent( &h2, GENERIC_ALL, &attr );
 944     ok( status == STATUS_SUCCESS, "NtOpenEvent failed %x\n", status );
 945     pNtClose( h2 );
 946     RtlInitUnicodeString( &str, L"om.c-test\\om.c-event" );
 947     InitializeObjectAttributes( &attr, &str, 0, dir, NULL );
 948     status = pNtOpenEvent( &h2, GENERIC_ALL, &attr );
 949     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtOpenEvent failed %x\n", status );
 950     RtlInitUnicodeString( &str, L"\\BasedNamedObjects\\Local\\om.c-test\\om.c-event" );
 951     InitializeObjectAttributes( &attr, &str, 0, 0, NULL );
 952     status = pNtOpenEvent( &h2, GENERIC_ALL, &attr );
 953     ok( status == STATUS_OBJECT_PATH_NOT_FOUND, "NtOpenEvent failed %x\n", status );
 954     pNtClose( h );
 955     pNtClose( dir1 );
 956
 957     str.Buffer = buffer;
 958     str.MaximumLength = sizeof(buffer);
 959     len = 0xdeadbeef;
 960     memset( buffer, 0xaa, sizeof(buffer) );
 961     status = pNtQuerySymbolicLinkObject( dir, &str, &len );
 962     ok( status == STATUS_SUCCESS, "NtQuerySymbolicLinkObject failed %08x\n", status );
 963     full_len = str.Length + sizeof(WCHAR);
 964     ok( len == full_len, "bad length %u/%u\n", len, full_len );
 965     ok( buffer[len / sizeof(WCHAR) - 1] == 0, "no terminating null\n" );
 966
 967     str.MaximumLength = str.Length;
 968     len = 0xdeadbeef;
 969     status = pNtQuerySymbolicLinkObject( dir, &str, &len );
 970     ok( status == STATUS_BUFFER_TOO_SMALL, "NtQuerySymbolicLinkObject failed %08x\n", status );
 971     ok( len == full_len, "bad length %u/%u\n", len, full_len );
 972
 973     str.MaximumLength = 0;
 974     len = 0xdeadbeef;
 975     status = pNtQuerySymbolicLinkObject( dir, &str, &len );
 976     ok( status == STATUS_BUFFER_TOO_SMALL, "NtQuerySymbolicLinkObject failed %08x\n", status );
 977     ok( len == full_len, "bad length %u/%u\n", len, full_len );
 978
 979     str.MaximumLength = str.Length + sizeof(WCHAR);
 980     len = 0xdeadbeef;
 981     status = pNtQuerySymbolicLinkObject( dir, &str, &len );
 982     ok( status == STATUS_SUCCESS, "NtQuerySymbolicLinkObject failed %08x\n", status );
 983     ok( len == full_len, "bad length %u/%u\n", len, full_len );
 984
 985     pNtClose(dir);
 986
 987     RtlInitUnicodeString(&str, L"\\BaseNamedObjects");
 988     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
 989     status = pNtOpenDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
 990     ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status );
 991
 992     InitializeObjectAttributes(&attr, NULL, 0, dir, NULL);
 993     status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
 994     ok( status == STATUS_OBJECT_NAME_INVALID, "NtOpenDirectoryObject got %08x\n", status );
 995
 996     check_create_open_dir( dir, L"", STATUS_SUCCESS );
 997     check_create_open_dir( dir, L"\\", STATUS_OBJECT_PATH_SYNTAX_BAD );
 998     check_create_open_dir( dir, L"\\om.c-test", STATUS_OBJECT_PATH_SYNTAX_BAD );
 999     check_create_open_dir( dir, L"\\om.c-test\\", STATUS_OBJECT_PATH_SYNTAX_BAD );
1000     check_create_open_dir( dir, L"om.c-test\\", STATUS_OBJECT_PATH_NOT_FOUND );
1001
1002     InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1003     RtlInitUnicodeString(&str, L"om.c-test");
1004     status = pNtCreateDirectoryObject( &dir1, DIRECTORY_QUERY, &attr );
1005     ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1006     status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
1007     ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status );
1008
1009     pNtClose(h);
1010     pNtClose(dir1);
1011     pNtClose(dir);
1012
1013     /* Nested directories */
1014     RtlInitUnicodeString(&str, L"\\");
1015     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1016     status = pNtOpenDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
1017     ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status );
1018     InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1019     status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
1020     ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenDirectoryObject got %08x\n", status );
1021     pNtClose(dir);
1022
1023     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1024     RtlInitUnicodeString(&str, L"\\BaseNamedObjects\\om.c-test");
1025     status = pNtCreateDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
1026     ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1027     RtlInitUnicodeString(&str, L"\\BaseNamedObjects\\om.c-test\\one more level");
1028     status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
1029     ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1030     pNtClose(h);
1031     InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1032     RtlInitUnicodeString(&str, L"one more level");
1033     status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
1034     ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1035     pNtClose(h);
1036
1037     pNtClose(dir);
1038
1039     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1040     RtlInitUnicodeString(&str, L"\\BaseNamedObjects\\Global\\om.c-test");
1041     status = pNtCreateDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
1042     ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1043     RtlInitUnicodeString(&str, L"\\BaseNamedObjects\\Local\\om.c-test\\one more level");
1044     status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
1045     ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1046     pNtClose(h);
1047     InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1048     RtlInitUnicodeString(&str, L"one more level");
1049     status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
1050     ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1051     pNtClose(h);
1052     pNtClose(dir);
1053
1054     /* Create other objects using RootDirectory */
1055
1056     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1057     RtlInitUnicodeString(&str, L"\\BaseNamedObjects");
1058     status = pNtOpenDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
1059     ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status );
1060     InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1061
1062     /* Test invalid paths */
1063     RtlInitUnicodeString(&str, L"\\om.c-mutant");
1064     status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
1065     ok(status == STATUS_OBJECT_PATH_SYNTAX_BAD,
1066         "NtCreateMutant should have failed with STATUS_OBJECT_PATH_SYNTAX_BAD got(%08x)\n", status);
1067     RtlInitUnicodeString(&str, L"\\om.c-mutant\\");
1068     status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
1069     ok(status == STATUS_OBJECT_PATH_SYNTAX_BAD,
1070         "NtCreateMutant should have failed with STATUS_OBJECT_PATH_SYNTAX_BAD got(%08x)\n", status);
1071
1072     RtlInitUnicodeString(&str, L"om.c\\-mutant");
1073     status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
1074     ok(status == STATUS_OBJECT_PATH_NOT_FOUND,
1075         "NtCreateMutant should have failed with STATUS_OBJECT_PATH_NOT_FOUND got(%08x)\n", status);
1076
1077     RtlInitUnicodeString(&str, L"om.c-mutant");
1078     status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
1079     ok(status == STATUS_SUCCESS, "Failed to create Mutant(%08x)\n", status);
1080     pNtClose(h);
1081
1082     pNtClose(dir);
1083 }
1084
1085 static void test_symboliclink(void)
1086 {
1087     NTSTATUS status;
1088     UNICODE_STRING str, target;
1089     OBJECT_ATTRIBUTES attr;
1090     HANDLE dir, link, h, h2;
1091     IO_STATUS_BLOCK iosb;
1092
1093     /* No name and/or no attributes */
1094     InitializeObjectAttributes(&attr, NULL, 0, 0, NULL);
1095     RtlInitUnicodeString(&target, L"\\DosDevices");
1096     status = pNtCreateSymbolicLinkObject( NULL, SYMBOLIC_LINK_QUERY, &attr, &target );
1097     ok(status == STATUS_ACCESS_VIOLATION, "got %#x\n", status);
1098     status = pNtOpenSymbolicLinkObject( NULL, SYMBOLIC_LINK_QUERY, &attr );
1099     ok(status == STATUS_ACCESS_VIOLATION, "got %#x\n", status);
1100
1101     status = pNtCreateSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, NULL, NULL);
1102     ok(status == STATUS_ACCESS_VIOLATION,
1103         "NtCreateSymbolicLinkObject should have failed with STATUS_ACCESS_VIOLATION got(%08x)\n", status);
1104     status = pNtOpenSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, NULL);
1105     ok(status == STATUS_INVALID_PARAMETER,
1106         "NtOpenSymbolicLinkObject should have failed with STATUS_INVALID_PARAMETER got(%08x)\n", status);
1107
1108     /* No attributes */
1109     status = pNtCreateSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, NULL, &target);
1110     ok(status == STATUS_SUCCESS || status == STATUS_ACCESS_VIOLATION, /* nt4 */
1111        "NtCreateSymbolicLinkObject failed(%08x)\n", status);
1112
1113     InitializeObjectAttributes(&attr, NULL, 0, 0, NULL);
1114     memset(&target, 0, sizeof(target));
1115     status = pNtCreateSymbolicLinkObject(&link, SYMBOLIC_LINK_QUERY, &attr, &target);
1116     ok(status == STATUS_INVALID_PARAMETER, "got %#x\n", status);
1117     status = pNtOpenSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, &attr);
1118     ok(status == STATUS_OBJECT_PATH_SYNTAX_BAD,
1119        "NtOpenSymbolicLinkObject should have failed with STATUS_OBJECT_PATH_SYNTAX_BAD got(%08x)\n", status);
1120
1121     /* Bad name */
1122     RtlInitUnicodeString(&target, L"anywhere");
1123     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1124
1125     RtlInitUnicodeString(&str, L"");
1126     status = pNtCreateSymbolicLinkObject(&link, SYMBOLIC_LINK_QUERY, &attr, &target);
1127     ok(status == STATUS_SUCCESS, "Failed to create SymbolicLink(%08x)\n", status);
1128     status = pNtOpenSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, &attr);
1129     ok(status == STATUS_OBJECT_PATH_SYNTAX_BAD,
1130        "NtOpenSymbolicLinkObject should have failed with STATUS_OBJECT_PATH_SYNTAX_BAD got(%08x)\n", status);
1131     pNtClose(link);
1132
1133     RtlInitUnicodeString(&str, L"\\");
1134     status = pNtCreateSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, &attr, &target);
1135     todo_wine ok(status == STATUS_OBJECT_TYPE_MISMATCH,
1136                  "NtCreateSymbolicLinkObject should have failed with STATUS_OBJECT_TYPE_MISMATCH got(%08x)\n", status);
1137
1138     RtlInitUnicodeString( &target, L"->Somewhere");
1139
1140     RtlInitUnicodeString( &str, L"BaseNamedObjects" );
1141     status = pNtCreateSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr, &target );
1142     ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtCreateSymbolicLinkObject got %08x\n", status );
1143     status = pNtOpenSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr );
1144     ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenSymbolicLinkObject got %08x\n", status );
1145
1146     RtlInitUnicodeString( &str, L"\\BaseNamedObjects\\" );
1147     status = pNtCreateSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr, &target );
1148     ok( status == STATUS_OBJECT_NAME_INVALID, "NtCreateSymbolicLinkObject got %08x\n", status );
1149     status = pNtOpenSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr );
1150     ok( status == STATUS_OBJECT_NAME_INVALID, "NtOpenSymbolicLinkObject got %08x\n", status );
1151
1152     RtlInitUnicodeString( &str, L"\\\\BaseNamedObjects" );
1153     status = pNtCreateSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr, &target );
1154     ok( status == STATUS_OBJECT_NAME_INVALID, "NtCreateSymbolicLinkObject got %08x\n", status );
1155     status = pNtOpenSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr );
1156     ok( status == STATUS_OBJECT_NAME_INVALID, "NtOpenSymbolicLinkObject got %08x\n", status );
1157
1158     RtlInitUnicodeString( &str, L"\\BaseNamedObjects\\\\om.c-test" );
1159     status = pNtCreateSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr, &target );
1160     ok( status == STATUS_OBJECT_NAME_INVALID, "NtCreateSymbolicLinkObject got %08x\n", status );
1161     status = pNtOpenSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr );
1162     ok( status == STATUS_OBJECT_NAME_INVALID, "NtOpenSymbolicLinkObject got %08x\n", status );
1163
1164     RtlInitUnicodeString( &str, L"\\BaseNamedObjects\\om.c-test\\" );
1165     status = pNtCreateSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr, &target );
1166     ok( status == STATUS_OBJECT_PATH_NOT_FOUND, "got %#x\n", status );
1167     status = pNtOpenSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr );
1168     ok( status == STATUS_OBJECT_PATH_NOT_FOUND, "got %#x\n", status );
1169
1170     /* Compound test */
1171     dir = get_base_dir();
1172     InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1173     RtlInitUnicodeString(&str, L"test-link");
1174     RtlInitUnicodeString(&target, L"\\DosDevices");
1175     status = pNtCreateSymbolicLinkObject(&link, SYMBOLIC_LINK_QUERY, &attr, &target);
1176     ok(status == STATUS_SUCCESS, "Failed to create SymbolicLink(%08x)\n", status);
1177
1178     RtlInitUnicodeString(&str, L"test-link\\NUL");
1179     status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0);
1180     ok(status == STATUS_SUCCESS, "Failed to open NUL device(%08x)\n", status);
1181     status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE);
1182     ok(status == STATUS_SUCCESS, "Failed to open NUL device(%08x)\n", status);
1183
1184     pNtClose(h);
1185     pNtClose(link);
1186     pNtClose(dir);
1187
1188     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1189     RtlInitUnicodeString(&str, L"\\BaseNamedObjects\\om.c-test");
1190     status = pNtCreateDirectoryObject(&dir, DIRECTORY_QUERY, &attr);
1191     ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status);
1192
1193     RtlInitUnicodeString(&str, L"\\DosDevices\\test_link");
1194     RtlInitUnicodeString(&target, L"\\BaseNamedObjects");
1195     status = pNtCreateSymbolicLinkObject(&link, SYMBOLIC_LINK_QUERY, &attr, &target);
1196     ok(status == STATUS_SUCCESS && !!link, "Got unexpected status %#x.\n", status);
1197
1198     status = NtCreateFile(&h, GENERIC_READ | SYNCHRONIZE, &attr, &iosb, NULL, 0,
1199             FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, NULL, 0 );
1200     ok(status == STATUS_OBJECT_TYPE_MISMATCH, "Got unexpected status %#x.\n", status);
1201
1202     status = pNtOpenSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr );
1203     ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status);
1204     pNtClose(h);
1205
1206     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1207     RtlInitUnicodeString( &str, L"\\BaseNamedObjects\\om.c-test\\" );
1208     status = NtCreateFile(&h, GENERIC_READ | SYNCHRONIZE, &attr, &iosb, NULL, 0,
1209             FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, NULL, 0 );
1210     ok(status == STATUS_OBJECT_NAME_INVALID, "Got unexpected status %#x.\n", status);
1211
1212     InitializeObjectAttributes(&attr, &str, 0, link, NULL);
1213     RtlInitUnicodeString( &str, L"om.c-test\\test_object" );
1214     status = pNtCreateMutant( &h, GENERIC_ALL, &attr, FALSE );
1215     ok(status == STATUS_OBJECT_TYPE_MISMATCH, "Got unexpected status %#x.\n", status);
1216
1217     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1218     RtlInitUnicodeString( &str, L"\\DosDevices\\test_link\\om.c-test\\test_object" );
1219     status = pNtCreateMutant( &h, GENERIC_ALL, &attr, FALSE );
1220     ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status);
1221     status = pNtOpenMutant( &h2, GENERIC_ALL, &attr );
1222     ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status);
1223     pNtClose(h2);
1224     RtlInitUnicodeString( &str, L"\\BaseNamedObjects\\om.c-test\\test_object" );
1225     status = pNtCreateMutant( &h2, GENERIC_ALL, &attr, FALSE );
1226     ok(status == STATUS_OBJECT_NAME_COLLISION, "Got unexpected status %#x.\n", status);
1227
1228     InitializeObjectAttributes(&attr, &str, 0, link, NULL);
1229     RtlInitUnicodeString( &str, L"om.c-test\\test_object" );
1230     status = pNtOpenMutant( &h2, GENERIC_ALL, &attr );
1231     ok(status == STATUS_OBJECT_TYPE_MISMATCH, "Got unexpected status %#x.\n", status);
1232
1233     pNtClose(h);
1234
1235     status = pNtOpenMutant( &h, GENERIC_ALL, &attr );
1236     ok(status == STATUS_OBJECT_TYPE_MISMATCH, "Got unexpected status %#x.\n", status);
1237
1238     InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1239     RtlInitUnicodeString( &str, L"test_object" );
1240     status = pNtCreateMutant( &h, GENERIC_ALL, &attr, FALSE );
1241     ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status);
1242     status = pNtOpenMutant( &h2, GENERIC_ALL, &attr );
1243     ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status);
1244     pNtClose(h);
1245     pNtClose(h2);
1246
1247     pNtClose(link);
1248     pNtClose(dir);
1249 }
1250
1251 #define test_file_info(a) _test_file_info(__LINE__,a)
1252 static void _test_file_info(unsigned line, HANDLE handle)
1253 {
1254     IO_STATUS_BLOCK io;
1255     char buf[256];
1256     NTSTATUS status;
1257
1258     status = pNtQueryInformationFile(handle, &io, buf, sizeof(buf), 0xdeadbeef);
1259     ok_(__FILE__,line)(status == STATUS_INVALID_INFO_CLASS || status == STATUS_NOT_IMPLEMENTED /* Vista+ */,
1260                        "expected STATUS_NOT_IMPLEMENTED, got %x\n", status);
1261
1262     status = pNtQueryInformationFile(handle, &io, buf, sizeof(buf), FileAccessInformation);
1263     ok_(__FILE__,line)(status == STATUS_SUCCESS, "FileAccessInformation returned %x\n", status);
1264
1265     status = pNtQueryInformationFile(handle, &io, buf, sizeof(buf),
1266                                     FileIoCompletionNotificationInformation);
1267     ok_(__FILE__,line)(status == STATUS_SUCCESS || broken(status == STATUS_INVALID_INFO_CLASS) /* XP */,
1268                        "FileIoCompletionNotificationInformation returned %x\n", status);
1269 }
1270
1271 #define test_no_file_info(a) _test_no_file_info(__LINE__,a)
1272 static void _test_no_file_info(unsigned line, HANDLE handle)
1273 {
1274     IO_STATUS_BLOCK io;
1275     char buf[256];
1276     NTSTATUS status;
1277
1278     status = pNtQueryInformationFile(handle, &io, buf, sizeof(buf), 0xdeadbeef);
1279     ok_(__FILE__,line)(status == STATUS_INVALID_INFO_CLASS || status == STATUS_NOT_IMPLEMENTED /* Vista+ */,
1280                        "expected STATUS_NOT_IMPLEMENTED, got %x\n", status);
1281
1282     status = pNtQueryInformationFile(handle, &io, buf, sizeof(buf), FileAccessInformation);
1283     ok_(__FILE__,line)(status == STATUS_OBJECT_TYPE_MISMATCH,
1284                        "FileAccessInformation returned %x\n", status);
1285
1286     status = pNtQueryInformationFile(handle, &io, buf, sizeof(buf),
1287                                     FileIoCompletionNotificationInformation);
1288     ok_(__FILE__,line)(status == STATUS_OBJECT_TYPE_MISMATCH || broken(status == STATUS_INVALID_INFO_CLASS) /* XP */,
1289                        "FileIoCompletionNotificationInformation returned %x\n", status);
1290 }
1291
1292 static OBJECT_TYPE_INFORMATION all_types[256];
1293
1294 static void add_object_type( OBJECT_TYPE_INFORMATION *info )
1295 {
1296     unsigned int i;
1297
1298     for (i = 0; i < ARRAY_SIZE(all_types); i++)
1299     {
1300         if (!all_types[i].TypeName.Buffer) break;
1301         if (!RtlCompareUnicodeString( &all_types[i].TypeName, &info->TypeName, FALSE )) break;
1302     }
1303     ok( i < ARRAY_SIZE(all_types), "too many types\n" );
1304
1305     if (all_types[i].TypeName.Buffer)  /* existing type */
1306     {
1307         ok( !memcmp( &all_types[i].GenericMapping, &info->GenericMapping, sizeof(GENERIC_MAPPING) ),
1308             "%u: mismatched mappings %08x,%08x,%08x,%08x / %08x,%08x,%08x,%08x\n", i,
1309             all_types[i].GenericMapping.GenericRead, all_types[i].GenericMapping.GenericWrite,
1310             all_types[i].GenericMapping.GenericExecute, all_types[i].GenericMapping.GenericAll,
1311             info->GenericMapping.GenericRead, info->GenericMapping.GenericWrite,
1312             info->GenericMapping.GenericExecute, info->GenericMapping.GenericAll );
1313         ok( all_types[i].ValidAccessMask == info->ValidAccessMask,
1314             "%u: mismatched access mask %08x / %08x\n", i,
1315             all_types[i].ValidAccessMask, info->ValidAccessMask );
1316     }
1317     else  /* add it */
1318     {
1319         all_types[i] = *info;
1320         RtlDuplicateUnicodeString( 1, &info->TypeName, &all_types[i].TypeName );
1321     }
1322     ok( info->TotalNumberOfObjects <= info->HighWaterNumberOfObjects, "%s: wrong object counts %u/%u\n",
1323         debugstr_w( all_types[i].TypeName.Buffer ),
1324         info->TotalNumberOfObjects, info->HighWaterNumberOfObjects );
1325     ok( info->TotalNumberOfHandles <= info->HighWaterNumberOfHandles, "%s: wrong handle counts %u/%u\n",
1326         debugstr_w( all_types[i].TypeName.Buffer ),
1327         info->TotalNumberOfHandles, info->HighWaterNumberOfHandles );
1328 }
1329
1330 static BOOL compare_unicode_string( const UNICODE_STRING *string, const WCHAR *expect )
1331 {
1332     return string->Length == wcslen( expect ) * sizeof(WCHAR)
1333             && !wcsnicmp( string->Buffer, expect, string->Length / sizeof(WCHAR) );
1334 }
1335
1336 #define test_object_type(a,b) _test_object_type(__LINE__,a,b)
1337 static void _test_object_type( unsigned line, HANDLE handle, const WCHAR *expected_name )
1338 {
1339     char buffer[1024];
1340     OBJECT_TYPE_INFORMATION *type = (OBJECT_TYPE_INFORMATION *)buffer;
1341     UNICODE_STRING expect;
1342     ULONG len = 0;
1343     NTSTATUS status;
1344
1345     RtlInitUnicodeString( &expect, expected_name );
1346
1347     memset( buffer, 0, sizeof(buffer) );
1348     status = pNtQueryObject( handle, ObjectTypeInformation, buffer, sizeof(buffer), &len );
1349     ok_(__FILE__,line)( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1350     ok_(__FILE__,line)( len > sizeof(UNICODE_STRING), "unexpected len %u\n", len );
1351     ok_(__FILE__,line)( len >= sizeof(*type) + type->TypeName.Length, "unexpected len %u\n", len );
1352     ok_(__FILE__,line)(compare_unicode_string( &type->TypeName, expected_name ), "wrong name %s\n",
1353                        debugstr_w( type->TypeName.Buffer ));
1354     add_object_type( type );
1355 }
1356
1357 #define test_object_name(a,b,c) _test_object_name(__LINE__,a,b,c)
1358 static void _test_object_name( unsigned line, HANDLE handle, const WCHAR *expected_name, BOOL todo )
1359 {
1360     char buffer[1024];
1361     UNICODE_STRING *str = (UNICODE_STRING *)buffer, expect;
1362     ULONG len = 0;
1363     NTSTATUS status;
1364
1365     RtlInitUnicodeString( &expect, expected_name );
1366
1367     memset( buffer, 0, sizeof(buffer) );
1368     status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(buffer), &len );
1369     ok_(__FILE__,line)( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1370     ok_(__FILE__,line)( len >= sizeof(OBJECT_NAME_INFORMATION) + str->Length, "unexpected len %u\n", len );
1371     todo_wine_if (todo)
1372         ok_(__FILE__,line)(compare_unicode_string( str, expected_name ), "wrong name %s\n", debugstr_w( str->Buffer ));
1373 }
1374
1375 static void test_query_object(void)
1376 {
1377     static const WCHAR name[] = L"\\BaseNamedObjects\\test_event";
1378     HANDLE handle, client;
1379     char buffer[1024];
1380     NTSTATUS status;
1381     ULONG len, expected_len;
1382     OBJECT_ATTRIBUTES attr;
1383     UNICODE_STRING path, target, *str;
1384     char dir[MAX_PATH], tmp_path[MAX_PATH], file1[MAX_PATH + 16];
1385     WCHAR expect[100];
1386     LARGE_INTEGER size;
1387     BOOL ret;
1388
1389     InitializeObjectAttributes( &attr, &path, 0, 0, 0 );
1390
1391     handle = CreateEventA( NULL, FALSE, FALSE, "test_event" );
1392
1393     len = 0;
1394     status = pNtQueryObject( handle, ObjectNameInformation, buffer, 0, &len );
1395     ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
1396     ok( len >= sizeof(UNICODE_STRING) + sizeof(name), "unexpected len %u\n", len );
1397
1398     len = 0;
1399     status = pNtQueryObject( handle, ObjectTypeInformation, buffer, 0, &len );
1400     ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
1401     ok( len >= sizeof(OBJECT_TYPE_INFORMATION) + sizeof(L"Event"), "unexpected len %u\n", len );
1402
1403     len = 0;
1404     status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(UNICODE_STRING), &len );
1405     ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
1406     ok( len >= sizeof(UNICODE_STRING) + sizeof(name), "unexpected len %u\n", len );
1407
1408     len = 0;
1409     status = pNtQueryObject( handle, ObjectTypeInformation, buffer, sizeof(OBJECT_TYPE_INFORMATION), &len );
1410     ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
1411     ok( len >= sizeof(OBJECT_TYPE_INFORMATION) + sizeof(L"Event"), "unexpected len %u\n", len );
1412
1413     len = 0;
1414     status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(buffer), &len );
1415     ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1416     ok( len > sizeof(UNICODE_STRING), "unexpected len %u\n", len );
1417     str = (UNICODE_STRING *)buffer;
1418     ok( sizeof(UNICODE_STRING) + str->Length + sizeof(WCHAR) == len, "unexpected len %u\n", len );
1419     ok( str->Length >= sizeof(name) - sizeof(WCHAR), "unexpected len %u\n", str->Length );
1420     ok( len > sizeof(UNICODE_STRING) + sizeof("\\test_event") * sizeof(WCHAR),
1421         "name too short %s\n", wine_dbgstr_w(str->Buffer) );
1422     /* check for \\Sessions prefix in the name */
1423     swprintf( expect, ARRAY_SIZE(expect), L"\\Sessions\\%u%s", NtCurrentTeb()->Peb->SessionId, name );
1424     ok( (str->Length == wcslen( expect ) * sizeof(WCHAR) && !wcscmp( str->Buffer, expect )) ||
1425         broken( !wcscmp( str->Buffer, name )), /* winxp */
1426         "wrong name %s\n", wine_dbgstr_w(str->Buffer) );
1427     trace( "got %s len %u\n", wine_dbgstr_w(str->Buffer), len );
1428
1429     len -= sizeof(WCHAR);
1430     status = pNtQueryObject( handle, ObjectNameInformation, buffer, len, &len );
1431     ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
1432     ok( len >= sizeof(UNICODE_STRING) + sizeof(name), "unexpected len %u\n", len );
1433
1434     test_object_type( handle, L"Event" );
1435
1436     len -= sizeof(WCHAR);
1437     status = pNtQueryObject( handle, ObjectTypeInformation, buffer, len, &len );
1438     ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
1439     ok( len >= sizeof(OBJECT_TYPE_INFORMATION) + sizeof(L"Event"), "unexpected len %u\n", len );
1440
1441     test_no_file_info( handle );
1442     pNtClose( handle );
1443
1444     handle = CreateEventA( NULL, FALSE, FALSE, NULL );
1445     len = 0;
1446     status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(buffer), &len );
1447     ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1448     ok( len == sizeof(UNICODE_STRING), "unexpected len %u\n", len );
1449     str = (UNICODE_STRING *)buffer;
1450     ok( str->Length == 0, "unexpected len %u\n", len );
1451     ok( str->Buffer == NULL, "unexpected ptr %p\n", str->Buffer );
1452     test_no_file_info( handle );
1453     pNtClose( handle );
1454
1455     GetWindowsDirectoryA( dir, MAX_PATH );
1456     handle = CreateFileA( dir, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
1457                           FILE_FLAG_BACKUP_SEMANTICS, 0 );
1458     len = 0;
1459     status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(buffer), &len );
1460     ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1461     ok( len > sizeof(UNICODE_STRING), "unexpected len %u\n", len );
1462     str = (UNICODE_STRING *)buffer;
1463     expected_len = sizeof(UNICODE_STRING) + str->Length + sizeof(WCHAR);
1464     ok( len == expected_len, "unexpected len %u\n", len );
1465     trace( "got %s len %u\n", wine_dbgstr_w(str->Buffer), len );
1466
1467     len = 0;
1468     status = pNtQueryObject( handle, ObjectNameInformation, buffer, 0, &len );
1469     ok( status == STATUS_INFO_LENGTH_MISMATCH, "got %#x\n", status );
1470     ok( len == expected_len || broken(!len /* XP */ || len == sizeof(UNICODE_STRING) /* 2003 */),
1471         "unexpected len %u\n", len );
1472
1473     len = 0;
1474     status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(UNICODE_STRING), &len );
1475     ok( status == STATUS_BUFFER_OVERFLOW, "got %#x\n", status);
1476     ok( len == expected_len, "unexpected len %u\n", len );
1477
1478     test_object_type( handle, L"File" );
1479
1480     pNtClose( handle );
1481
1482     GetTempPathA(MAX_PATH, tmp_path);
1483     GetTempFileNameA(tmp_path, "foo", 0, file1);
1484     handle = CreateFileA(file1, GENERIC_WRITE | DELETE, 0, NULL, CREATE_ALWAYS, 0, 0);
1485     test_object_type(handle, L"File");
1486     DeleteFileA( file1 );
1487     test_file_info( handle );
1488     pNtClose( handle );
1489
1490     status = pNtCreateIoCompletion( &handle, IO_COMPLETION_ALL_ACCESS, NULL, 0 );
1491     ok( status == STATUS_SUCCESS, "NtCreateIoCompletion failed %x\n", status);
1492
1493     test_object_type( handle, L"IoCompletion" );
1494     test_no_file_info( handle );
1495
1496     pNtClose( handle );
1497
1498     RtlInitUnicodeString( &path, L"\\BaseNamedObjects\\test_debug" );
1499     status = pNtCreateDebugObject( &handle, DEBUG_ALL_ACCESS, &attr, 0 );
1500     ok(!status, "NtCreateDebugObject failed: %x\n", status);
1501     test_object_name( handle, L"\\BaseNamedObjects\\test_debug", FALSE );
1502     test_object_type( handle, L"DebugObject" );
1503     test_no_file_info( handle );
1504     pNtClose(handle);
1505
1506     RtlInitUnicodeString( &path, L"\\BaseNamedObjects\\test_mutant" );
1507     status = pNtCreateMutant( &handle, MUTANT_ALL_ACCESS, &attr, 0 );
1508     ok(!status, "NtCreateMutant failed: %x\n", status);
1509     test_object_name( handle, L"\\BaseNamedObjects\\test_mutant", FALSE );
1510     test_object_type( handle, L"Mutant" );
1511     test_no_file_info( handle );
1512     pNtClose(handle);
1513
1514     RtlInitUnicodeString( &path, L"\\BaseNamedObjects\\test_sem" );
1515     status = pNtCreateSemaphore( &handle, SEMAPHORE_ALL_ACCESS, &attr, 1, 2 );
1516     ok(!status, "NtCreateSemaphore failed: %x\n", status);
1517     test_object_name( handle, L"\\BaseNamedObjects\\test_sem", FALSE );
1518     test_object_type( handle, L"Semaphore" );
1519     test_no_file_info( handle );
1520     pNtClose(handle);
1521
1522     RtlInitUnicodeString( &path, L"\\BaseNamedObjects\\test_keyed" );
1523     status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_ALL_ACCESS, &attr, 0 );
1524     ok(!status, "NtCreateKeyedEvent failed: %x\n", status);
1525     test_object_name( handle, L"\\BaseNamedObjects\\test_keyed", FALSE );
1526     test_object_type( handle, L"KeyedEvent" );
1527     test_no_file_info( handle );
1528     pNtClose(handle);
1529
1530     RtlInitUnicodeString( &path, L"\\BaseNamedObjects\\test_compl" );
1531     status = pNtCreateIoCompletion( &handle, IO_COMPLETION_ALL_ACCESS, &attr, 0 );
1532     ok(!status, "NtCreateIoCompletion failed: %x\n", status);
1533     test_object_name( handle, L"\\BaseNamedObjects\\test_compl", FALSE );
1534     test_object_type( handle, L"IoCompletion" );
1535     test_no_file_info( handle );
1536     pNtClose(handle);
1537
1538     RtlInitUnicodeString( &path, L"\\BaseNamedObjects\\test_job" );
1539     status = pNtCreateJobObject( &handle, JOB_OBJECT_ALL_ACCESS, &attr );
1540     ok(!status, "NtCreateJobObject failed: %x\n", status);
1541     test_object_name( handle, L"\\BaseNamedObjects\\test_job", FALSE );
1542     test_object_type( handle, L"Job" );
1543     test_no_file_info( handle );
1544     pNtClose(handle);
1545
1546     RtlInitUnicodeString( &path, L"\\BaseNamedObjects\\test_timer" );
1547     status = pNtCreateTimer( &handle, TIMER_ALL_ACCESS, &attr, NotificationTimer );
1548     ok(!status, "NtCreateTimer failed: %x\n", status);
1549     test_object_type( handle, L"Timer" );
1550     test_no_file_info( handle );
1551     pNtClose(handle);
1552
1553     RtlInitUnicodeString( &path, L"\\DosDevices\\test_link" );
1554     RtlInitUnicodeString( &target, L"\\DosDevices" );
1555     status = pNtCreateSymbolicLinkObject( &handle, SYMBOLIC_LINK_ALL_ACCESS, &attr, &target );
1556     ok(!status, "NtCreateSymbolicLinkObject failed: %x\n", status);
1557     test_object_type( handle, L"SymbolicLink" );
1558     test_no_file_info( handle );
1559     pNtClose(handle);
1560
1561     handle = GetProcessWindowStation();
1562     swprintf( expect, ARRAY_SIZE(expect), L"\\Sessions\\%u\\Windows\\WindowStations\\WinSta0", NtCurrentTeb()->Peb->SessionId );
1563     test_object_name( handle, expect, FALSE );
1564     test_object_type( handle, L"WindowStation" );
1565     test_no_file_info( handle );
1566
1567     handle = GetThreadDesktop( GetCurrentThreadId() );
1568     test_object_name( handle, L"\\Default", FALSE );
1569     test_object_type( handle, L"Desktop" );
1570     test_no_file_info( handle );
1571
1572     status = pNtCreateDirectoryObject( &handle, DIRECTORY_QUERY, NULL );
1573     ok(status == STATUS_SUCCESS, "Failed to create Directory %08x\n", status);
1574
1575     test_object_type( handle, L"Directory" );
1576     test_no_file_info( handle );
1577
1578     pNtClose( handle );
1579
1580     size.u.LowPart = 256;
1581     size.u.HighPart = 0;
1582     status = pNtCreateSection( &handle, SECTION_MAP_WRITE, NULL, &size, PAGE_READWRITE, SEC_COMMIT, 0 );
1583     ok( status == STATUS_SUCCESS , "NtCreateSection returned %x\n", status );
1584
1585     test_object_type( handle, L"Section" );
1586     test_no_file_info( handle );
1587
1588     pNtClose( handle );
1589
1590     handle = CreateMailslotA( "\\\\.\\mailslot\\test_mailslot", 100, 1000, NULL );
1591     ok( handle != INVALID_HANDLE_VALUE, "CreateMailslot failed err %u\n", GetLastError() );
1592
1593     test_object_name( handle, L"\\Device\\Mailslot\\test_mailslot", FALSE );
1594     test_object_type( handle, L"File" );
1595     test_file_info( handle );
1596
1597     client = CreateFileA( "\\\\.\\mailslot\\test_mailslot", 0, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1598     ok( client != INVALID_HANDLE_VALUE, "CreateFile failed (%d)\n", GetLastError() );
1599
1600     len = 0;
1601     status = pNtQueryObject( client, ObjectNameInformation, buffer, sizeof(buffer), &len );
1602     ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1603     str = (UNICODE_STRING *)buffer;
1604     ok( len == sizeof(UNICODE_STRING) + str->MaximumLength, "unexpected len %u\n", len );
1605     todo_wine
1606         ok( compare_unicode_string( str, L"\\Device\\Mailslot" ) ||
1607             compare_unicode_string( str, L"\\Device\\Mailslot\\test_mailslot" ) /* win8+ */,
1608             "wrong name %s\n", debugstr_w( str->Buffer ));
1609
1610     test_object_type( client, L"File" );
1611     test_file_info( client );
1612
1613     pNtClose( client );
1614     pNtClose( handle );
1615
1616     handle = CreateFileA( "\\\\.\\mailslot", 0, 0, NULL, OPEN_EXISTING, 0, 0 );
1617     ok( handle != INVALID_HANDLE_VALUE, "CreateFile failed (%d)\n", GetLastError() );
1618
1619     test_object_name( handle, L"\\Device\\Mailslot", FALSE );
1620     test_object_type( handle, L"File" );
1621     test_file_info( handle );
1622
1623     pNtClose( handle );
1624
1625     handle = CreateNamedPipeA( "\\\\.\\pipe\\test_pipe", PIPE_ACCESS_DUPLEX, PIPE_READMODE_BYTE,
1626                                1, 1000, 1000, 1000, NULL );
1627     ok( handle != INVALID_HANDLE_VALUE, "CreateNamedPipe failed err %u\n", GetLastError() );
1628
1629     test_object_name( handle, L"\\Device\\NamedPipe\\test_pipe", FALSE );
1630     test_object_type( handle, L"File" );
1631     test_file_info( handle );
1632
1633     client = CreateFileA( "\\\\.\\pipe\\test_pipe", GENERIC_READ | GENERIC_WRITE,
1634                           0, NULL, OPEN_EXISTING, 0, 0 );
1635     ok( client != INVALID_HANDLE_VALUE, "CreateFile failed (%d)\n", GetLastError() );
1636
1637     test_object_type( client, L"File" );
1638     test_file_info( client );
1639
1640     pNtClose( client );
1641     pNtClose( handle );
1642
1643     handle = CreateFileA( "\\\\.\\pipe", 0, 0, NULL, OPEN_EXISTING, 0, 0 );
1644     ok( handle != INVALID_HANDLE_VALUE, "CreateFile failed (%d)\n", GetLastError() );
1645
1646     test_object_name( handle, L"\\Device\\NamedPipe", FALSE );
1647     test_object_type( handle, L"File" );
1648     test_file_info( handle );
1649
1650     pNtClose( handle );
1651
1652     RtlInitUnicodeString( &path, L"\\REGISTRY\\Machine" );
1653     status = pNtCreateKey( &handle, KEY_READ, &attr, 0, 0, 0, 0 );
1654     ok( status == STATUS_SUCCESS, "NtCreateKey failed status %x\n", status );
1655
1656     test_object_name( handle, L"\\REGISTRY\\MACHINE", FALSE );
1657     test_object_type( handle, L"Key" );
1658
1659     pNtClose( handle );
1660
1661     test_object_name( GetCurrentProcess(), L"", FALSE );
1662     test_object_type( GetCurrentProcess(), L"Process" );
1663     test_no_file_info( GetCurrentProcess() );
1664
1665     test_object_name( GetCurrentThread(), L"", FALSE );
1666     test_object_type( GetCurrentThread(), L"Thread" );
1667     test_no_file_info( GetCurrentThread() );
1668
1669     ret = OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &handle);
1670     ok(ret, "OpenProcessToken failed: %u\n", GetLastError());
1671
1672     test_object_name( handle, L"", FALSE );
1673     test_object_type( handle, L"Token" );
1674     test_no_file_info( handle );
1675
1676     pNtClose(handle);
1677
1678     handle = CreateFileA( "nul", GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
1679     ok( handle != INVALID_HANDLE_VALUE, "CreateFile failed (%d)\n", GetLastError() );
1680     test_object_name( handle, L"\\Device\\Null", TRUE );
1681     test_object_type( handle, L"File" );
1682     test_file_info( handle );
1683     pNtClose( handle );
1684 }
1685
1686 static void test_type_mismatch(void)
1687 {
1688     HANDLE h;
1689     NTSTATUS res;
1690     OBJECT_ATTRIBUTES attr;
1691
1692     attr.Length                   = sizeof(attr);
1693     attr.RootDirectory            = 0;
1694     attr.ObjectName               = NULL;
1695     attr.Attributes               = 0;
1696     attr.SecurityDescriptor       = NULL;
1697     attr.SecurityQualityOfService = NULL;
1698
1699     res = pNtCreateEvent( &h, 0, &attr, NotificationEvent, 0 );
1700     ok(!res, "can't create event: %x\n", res);
1701
1702     res = pNtReleaseSemaphore( h, 30, NULL );
1703     ok(res == STATUS_OBJECT_TYPE_MISMATCH, "expected 0xc0000024, got %x\n", res);
1704
1705     pNtClose( h );
1706 }
1707
1708 static void test_event(void)
1709 {
1710     HANDLE Event;
1711     HANDLE Event2;
1712     LONG prev_state = 0xdeadbeef;
1713     NTSTATUS status;
1714     UNICODE_STRING str;
1715     OBJECT_ATTRIBUTES attr;
1716     EVENT_BASIC_INFORMATION info;
1717
1718     pRtlInitUnicodeString( &str, L"\\BaseNamedObjects\\testEvent" );
1719     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1720
1721     status = pNtCreateEvent(&Event, GENERIC_ALL, &attr, 2, 0);
1722     ok( status == STATUS_INVALID_PARAMETER, "NtCreateEvent failed %08x\n", status );
1723
1724     status = pNtCreateEvent(&Event, GENERIC_ALL, &attr, NotificationEvent, 0);
1725     ok( status == STATUS_SUCCESS, "NtCreateEvent failed %08x\n", status );
1726     memset(&info, 0xcc, sizeof(info));
1727     status = pNtQueryEvent(Event, EventBasicInformation, &info, sizeof(info), NULL);
1728     ok( status == STATUS_SUCCESS, "NtQueryEvent failed %08x\n", status );
1729     ok( info.EventType == NotificationEvent && info.EventState == 0,
1730         "NtQueryEvent failed, expected 0 0, got %d %d\n", info.EventType, info.EventState );
1731     pNtClose(Event);
1732
1733     status = pNtCreateEvent(&Event, GENERIC_ALL, &attr, SynchronizationEvent, 0);
1734     ok( status == STATUS_SUCCESS, "NtCreateEvent failed %08x\n", status );
1735
1736     status = pNtPulseEvent(Event, &prev_state);
1737     ok( status == STATUS_SUCCESS, "NtPulseEvent failed %08x\n", status );
1738     ok( !prev_state, "prev_state = %x\n", prev_state );
1739
1740     memset(&info, 0xcc, sizeof(info));
1741     status = pNtQueryEvent(Event, EventBasicInformation, &info, sizeof(info), NULL);
1742     ok( status == STATUS_SUCCESS, "NtQueryEvent failed %08x\n", status );
1743     ok( info.EventType == SynchronizationEvent && info.EventState == 0,
1744         "NtQueryEvent failed, expected 1 0, got %d %d\n", info.EventType, info.EventState );
1745
1746     status = pNtOpenEvent(&Event2, GENERIC_ALL, &attr);
1747     ok( status == STATUS_SUCCESS, "NtOpenEvent failed %08x\n", status );
1748
1749     pNtClose(Event);
1750     Event = Event2;
1751
1752     memset(&info, 0xcc, sizeof(info));
1753     status = pNtQueryEvent(Event, EventBasicInformation, &info, sizeof(info), NULL);
1754     ok( status == STATUS_SUCCESS, "NtQueryEvent failed %08x\n", status );
1755     ok( info.EventType == SynchronizationEvent && info.EventState == 0,
1756         "NtQueryEvent failed, expected 1 0, got %d %d\n", info.EventType, info.EventState );
1757
1758     status = pNtSetEvent( Event, &prev_state );
1759     ok( status == STATUS_SUCCESS, "NtSetEvent failed: %08x\n", status );
1760     ok( !prev_state, "prev_state = %x\n", prev_state );
1761
1762     memset(&info, 0xcc, sizeof(info));
1763     status = pNtQueryEvent(Event, EventBasicInformation, &info, sizeof(info), NULL);
1764     ok( status == STATUS_SUCCESS, "NtQueryEvent failed %08x\n", status );
1765     ok( info.EventType == SynchronizationEvent && info.EventState == 1,
1766         "NtQueryEvent failed, expected 1 1, got %d %d\n", info.EventType, info.EventState );
1767
1768     status = pNtSetEvent( Event, &prev_state );
1769     ok( status == STATUS_SUCCESS, "NtSetEvent failed: %08x\n", status );
1770     ok( prev_state == 1, "prev_state = %x\n", prev_state );
1771
1772     status = pNtResetEvent( Event, &prev_state );
1773     ok( status == STATUS_SUCCESS, "NtSetEvent failed: %08x\n", status );
1774     ok( prev_state == 1, "prev_state = %x\n", prev_state );
1775
1776     status = pNtResetEvent( Event, &prev_state );
1777     ok( status == STATUS_SUCCESS, "NtSetEvent failed: %08x\n", status );
1778     ok( !prev_state, "prev_state = %x\n", prev_state );
1779
1780     status = pNtPulseEvent( Event, &prev_state );
1781     ok( status == STATUS_SUCCESS, "NtPulseEvent failed %08x\n", status );
1782     ok( !prev_state, "prev_state = %x\n", prev_state );
1783
1784     status = pNtSetEvent( Event, &prev_state );
1785     ok( status == STATUS_SUCCESS, "NtSetEvent failed: %08x\n", status );
1786     ok( !prev_state, "prev_state = %x\n", prev_state );
1787
1788     status = pNtPulseEvent( Event, &prev_state );
1789     ok( status == STATUS_SUCCESS, "NtPulseEvent failed %08x\n", status );
1790     ok( prev_state == 1, "prev_state = %x\n", prev_state );
1791
1792     pNtClose(Event);
1793 }
1794
1795 static const WCHAR keyed_nameW[] = L"\\BaseNamedObjects\\WineTestEvent";
1796
1797 static DWORD WINAPI keyed_event_thread( void *arg )
1798 {
1799     HANDLE handle;
1800     NTSTATUS status;
1801     LARGE_INTEGER timeout;
1802     OBJECT_ATTRIBUTES attr;
1803     UNICODE_STRING str;
1804     ULONG_PTR i;
1805
1806     attr.Length                   = sizeof(attr);
1807     attr.RootDirectory            = 0;
1808     attr.ObjectName               = &str;
1809     attr.Attributes               = 0;
1810     attr.SecurityDescriptor       = NULL;
1811     attr.SecurityQualityOfService = NULL;
1812     RtlInitUnicodeString( &str, keyed_nameW );
1813
1814     status = pNtOpenKeyedEvent( &handle, KEYEDEVENT_ALL_ACCESS, &attr );
1815     ok( !status, "NtOpenKeyedEvent failed %x\n", status );
1816
1817     for (i = 0; i < 20; i++)
1818     {
1819         if (i & 1)
1820             status = pNtWaitForKeyedEvent( handle, (void *)(i * 2), 0, NULL );
1821         else
1822             status = pNtReleaseKeyedEvent( handle, (void *)(i * 2), 0, NULL );
1823         ok( status == STATUS_SUCCESS, "%li: failed %x\n", i, status );
1824         Sleep( 20 - i );
1825     }
1826
1827     status = pNtReleaseKeyedEvent( handle, (void *)0x1234, 0, NULL );
1828     ok( status == STATUS_SUCCESS, "NtReleaseKeyedEvent %x\n", status );
1829
1830     timeout.QuadPart = -10000;
1831     status = pNtWaitForKeyedEvent( handle, (void *)0x5678, 0, &timeout );
1832     ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1833     status = pNtReleaseKeyedEvent( handle, (void *)0x9abc, 0, &timeout );
1834     ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1835
1836     NtClose( handle );
1837     return 0;
1838 }
1839
1840 static void test_keyed_events(void)
1841 {
1842     OBJECT_ATTRIBUTES attr;
1843     UNICODE_STRING str;
1844     HANDLE handle, event, thread;
1845     NTSTATUS status;
1846     LARGE_INTEGER timeout;
1847     ULONG_PTR i;
1848
1849     if (!pNtCreateKeyedEvent)
1850     {
1851         win_skip( "Keyed events not supported\n" );
1852         return;
1853     }
1854
1855     attr.Length                   = sizeof(attr);
1856     attr.RootDirectory            = 0;
1857     attr.ObjectName               = &str;
1858     attr.Attributes               = 0;
1859     attr.SecurityDescriptor       = NULL;
1860     attr.SecurityQualityOfService = NULL;
1861     RtlInitUnicodeString( &str, keyed_nameW );
1862
1863     status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_ALL_ACCESS | SYNCHRONIZE, &attr, 0 );
1864     ok( !status, "NtCreateKeyedEvent failed %x\n", status );
1865
1866     status = WaitForSingleObject( handle, 1000 );
1867     ok( status == 0, "WaitForSingleObject %x\n", status );
1868
1869     timeout.QuadPart = -100000;
1870     status = pNtWaitForKeyedEvent( handle, (void *)255, 0, &timeout );
1871     ok( status == STATUS_INVALID_PARAMETER_1, "NtWaitForKeyedEvent %x\n", status );
1872     status = pNtReleaseKeyedEvent( handle, (void *)255, 0, &timeout );
1873     ok( status == STATUS_INVALID_PARAMETER_1, "NtReleaseKeyedEvent %x\n", status );
1874
1875     status = pNtWaitForKeyedEvent( handle, (void *)254, 0, &timeout );
1876     ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1877     status = pNtReleaseKeyedEvent( handle, (void *)254, 0, &timeout );
1878     ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1879
1880     status = pNtWaitForKeyedEvent( handle, NULL, 0, &timeout );
1881     ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1882     status = pNtReleaseKeyedEvent( handle, NULL, 0, &timeout );
1883     ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1884
1885     status = pNtWaitForKeyedEvent( NULL, (void *)8, 0, &timeout );
1886     ok( status == STATUS_TIMEOUT || broken(status == STATUS_INVALID_HANDLE), /* XP/2003 */
1887         "NtWaitForKeyedEvent %x\n", status );
1888     status = pNtReleaseKeyedEvent( NULL, (void *)8, 0, &timeout );
1889     ok( status == STATUS_TIMEOUT || broken(status == STATUS_INVALID_HANDLE), /* XP/2003 */
1890         "NtReleaseKeyedEvent %x\n", status );
1891
1892     status = pNtWaitForKeyedEvent( (HANDLE)0xdeadbeef, (void *)9, 0, &timeout );
1893     ok( status == STATUS_INVALID_PARAMETER_1, "NtWaitForKeyedEvent %x\n", status );
1894     status = pNtReleaseKeyedEvent( (HANDLE)0xdeadbeef, (void *)9, 0, &timeout );
1895     ok( status == STATUS_INVALID_PARAMETER_1, "NtReleaseKeyedEvent %x\n", status );
1896
1897     status = pNtWaitForKeyedEvent( (HANDLE)0xdeadbeef, (void *)8, 0, &timeout );
1898     ok( status == STATUS_INVALID_HANDLE, "NtWaitForKeyedEvent %x\n", status );
1899     status = pNtReleaseKeyedEvent( (HANDLE)0xdeadbeef, (void *)8, 0, &timeout );
1900     ok( status == STATUS_INVALID_HANDLE, "NtReleaseKeyedEvent %x\n", status );
1901
1902     thread = CreateThread( NULL, 0, keyed_event_thread, 0, 0, NULL );
1903     for (i = 0; i < 20; i++)
1904     {
1905         if (i & 1)
1906             status = pNtReleaseKeyedEvent( handle, (void *)(i * 2), 0, NULL );
1907         else
1908             status = pNtWaitForKeyedEvent( handle, (void *)(i * 2), 0, NULL );
1909         ok( status == STATUS_SUCCESS, "%li: failed %x\n", i, status );
1910         Sleep( i );
1911     }
1912     status = pNtWaitForKeyedEvent( handle, (void *)0x1234, 0, &timeout );
1913     ok( status == STATUS_SUCCESS, "NtWaitForKeyedEvent %x\n", status );
1914     status = pNtWaitForKeyedEvent( handle, (void *)0x5678, 0, &timeout );
1915     ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1916     status = pNtReleaseKeyedEvent( handle, (void *)0x9abc, 0, &timeout );
1917     ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1918
1919     ok( WaitForSingleObject( thread, 30000 ) == 0, "wait failed\n" );
1920
1921     NtClose( handle );
1922
1923     /* test access rights */
1924
1925     status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_WAIT, &attr, 0 );
1926     ok( !status, "NtCreateKeyedEvent failed %x\n", status );
1927     status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );
1928     ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1929     status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );
1930     ok( status == STATUS_ACCESS_DENIED, "NtReleaseKeyedEvent %x\n", status );
1931     NtClose( handle );
1932
1933     status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_WAKE, &attr, 0 );
1934     ok( !status, "NtCreateKeyedEvent failed %x\n", status );
1935     status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );
1936     ok( status == STATUS_ACCESS_DENIED, "NtWaitForKeyedEvent %x\n", status );
1937     status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );
1938     ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1939     NtClose( handle );
1940
1941     status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_ALL_ACCESS, &attr, 0 );
1942     ok( !status, "NtCreateKeyedEvent failed %x\n", status );
1943     status = WaitForSingleObject( handle, 1000 );
1944     ok( status == WAIT_FAILED && GetLastError() == ERROR_ACCESS_DENIED,
1945         "WaitForSingleObject %x err %u\n", status, GetLastError() );
1946     status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );
1947     ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1948     status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );
1949     ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1950     NtClose( handle );
1951
1952     /* GENERIC_READ gives wait access */
1953     status = pNtCreateKeyedEvent( &handle, GENERIC_READ, &attr, 0 );
1954     ok( !status, "NtCreateKeyedEvent failed %x\n", status );
1955     status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );
1956     ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1957     status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );
1958     ok( status == STATUS_ACCESS_DENIED, "NtReleaseKeyedEvent %x\n", status );
1959     NtClose( handle );
1960
1961     /* GENERIC_WRITE gives wake access */
1962     status = pNtCreateKeyedEvent( &handle, GENERIC_WRITE, &attr, 0 );
1963     ok( !status, "NtCreateKeyedEvent failed %x\n", status );
1964     status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );
1965     ok( status == STATUS_ACCESS_DENIED, "NtWaitForKeyedEvent %x\n", status );
1966     status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );
1967     ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1968
1969     /* it's not an event */
1970     status = pNtPulseEvent( handle, NULL );
1971     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtPulseEvent %x\n", status );
1972
1973     status = pNtCreateEvent( &event, GENERIC_ALL, &attr, NotificationEvent, FALSE );
1974     ok( status == STATUS_OBJECT_NAME_COLLISION || status == STATUS_OBJECT_TYPE_MISMATCH /* 7+ */,
1975         "CreateEvent %x\n", status );
1976
1977     NtClose( handle );
1978
1979     status = pNtCreateEvent( &event, GENERIC_ALL, &attr, NotificationEvent, FALSE );
1980     ok( status == 0, "CreateEvent %x\n", status );
1981     status = pNtWaitForKeyedEvent( event, (void *)8, 0, &timeout );
1982     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtWaitForKeyedEvent %x\n", status );
1983     status = pNtReleaseKeyedEvent( event, (void *)8, 0, &timeout );
1984     ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtReleaseKeyedEvent %x\n", status );
1985     NtClose( event );
1986 }
1987
1988 static void test_null_device(void)
1989 {
1990     OBJECT_ATTRIBUTES attr;
1991     IO_STATUS_BLOCK iosb;
1992     UNICODE_STRING str;
1993     NTSTATUS status;
1994     DWORD num_bytes;
1995     OVERLAPPED ov;
1996     char buf[64];
1997     HANDLE null;
1998     BOOL ret;
1999
2000     memset(buf, 0xAA, sizeof(buf));
2001     memset(&ov, 0, sizeof(ov));
2002     ov.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
2003
2004     RtlInitUnicodeString(&str, L"\\Device\\Null");
2005     InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
2006     status = pNtOpenSymbolicLinkObject(&null, SYMBOLIC_LINK_QUERY, &attr);
2007     ok(status == STATUS_OBJECT_TYPE_MISMATCH,
2008        "expected STATUS_OBJECT_TYPE_MISMATCH, got %08x\n", status);
2009
2010     status = pNtOpenFile(&null, GENERIC_READ | GENERIC_WRITE, &attr, &iosb,
2011                          FILE_SHARE_READ | FILE_SHARE_WRITE, 0);
2012     ok(status == STATUS_SUCCESS,
2013        "expected STATUS_SUCCESS, got %08x\n", status);
2014
2015     test_object_type(null, L"File");
2016
2017     SetLastError(0xdeadbeef);
2018     ret = WriteFile(null, buf, sizeof(buf), &num_bytes, NULL);
2019     ok(!ret, "WriteFile unexpectedly succeeded\n");
2020     ok(GetLastError() == ERROR_INVALID_PARAMETER,
2021        "expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
2022
2023     SetLastError(0xdeadbeef);
2024     ret = ReadFile(null, buf, sizeof(buf), &num_bytes, NULL);
2025     ok(!ret, "ReadFile unexpectedly succeeded\n");
2026     ok(GetLastError() == ERROR_INVALID_PARAMETER,
2027        "expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
2028
2029     num_bytes = 0xdeadbeef;
2030     SetLastError(0xdeadbeef);
2031     ret = WriteFile(null, buf, sizeof(buf), &num_bytes, &ov);
2032     ok(ret, "got error %u\n", GetLastError());
2033     ok(num_bytes == sizeof(buf), "expected num_bytes = %u, got %u\n",
2034        (DWORD)sizeof(buf), num_bytes);
2035
2036     num_bytes = 0xdeadbeef;
2037     SetLastError(0xdeadbeef);
2038     ret = ReadFile(null, buf, sizeof(buf), &num_bytes, &ov);
2039     ok(!ret, "expected failure\n");
2040     ok(GetLastError() == ERROR_HANDLE_EOF, "got error %u\n", GetLastError());
2041
2042     pNtClose(null);
2043
2044     null = CreateFileA("\\\\.\\Null", GENERIC_READ | GENERIC_WRITE,
2045                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
2046                        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
2047     ok(null == INVALID_HANDLE_VALUE, "CreateFileA unexpectedly succeeded\n");
2048     ok(GetLastError() == ERROR_FILE_NOT_FOUND,
2049        "expected ERROR_FILE_NOT_FOUND, got %u\n", GetLastError());
2050
2051     null = CreateFileA("\\\\.\\Device\\Null", GENERIC_READ | GENERIC_WRITE,
2052                        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
2053                        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
2054     ok(null == INVALID_HANDLE_VALUE, "CreateFileA unexpectedly succeeded\n");
2055     ok(GetLastError() == ERROR_PATH_NOT_FOUND,
2056        "expected ERROR_PATH_NOT_FOUND, got %u\n", GetLastError());
2057
2058     CloseHandle(ov.hEvent);
2059 }
2060
2061 static DWORD WINAPI mutant_thread( void *arg )
2062 {
2063     MUTANT_BASIC_INFORMATION info;
2064     NTSTATUS status;
2065     HANDLE mutant;
2066     DWORD ret;
2067
2068     mutant = arg;
2069     ret = WaitForSingleObject( mutant, 1000 );
2070     ok( ret == WAIT_OBJECT_0, "WaitForSingleObject failed %08x\n", ret );
2071
2072     memset(&info, 0xcc, sizeof(info));
2073     status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);
2074     ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08x\n", status );
2075     ok( info.CurrentCount == 0, "expected 0, got %d\n", info.CurrentCount );
2076     ok( info.OwnedByCaller == TRUE, "expected TRUE, got %d\n", info.OwnedByCaller );
2077     ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );
2078     /* abandon mutant */
2079
2080     return 0;
2081 }
2082
2083 static void test_mutant(void)
2084 {
2085     MUTANT_BASIC_INFORMATION info;
2086     OBJECT_ATTRIBUTES attr;
2087     UNICODE_STRING str;
2088     NTSTATUS status;
2089     HANDLE mutant;
2090     HANDLE thread;
2091     DWORD ret;
2092     ULONG len;
2093     LONG prev;
2094
2095     pRtlInitUnicodeString(&str, L"\\BaseNamedObjects\\test_mutant");
2096     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
2097     status = pNtCreateMutant(&mutant, GENERIC_ALL, &attr, TRUE);
2098     ok( status == STATUS_SUCCESS, "Failed to create Mutant(%08x)\n", status );
2099
2100     /* bogus */
2101     status = pNtQueryMutant(mutant, MutantBasicInformation, &info, 0, NULL);
2102     ok( status == STATUS_INFO_LENGTH_MISMATCH,
2103         "Failed to NtQueryMutant, expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status );
2104     status = pNtQueryMutant(mutant, 0x42, &info, sizeof(info), NULL);
2105     ok( status == STATUS_INVALID_INFO_CLASS || broken(status == STATUS_NOT_IMPLEMENTED), /* 32-bit on Vista/2k8 */
2106         "Failed to NtQueryMutant, expected STATUS_INVALID_INFO_CLASS, got %08x\n", status );
2107     status = pNtQueryMutant((HANDLE)0xdeadbeef, MutantBasicInformation, &info, sizeof(info), NULL);
2108     ok( status == STATUS_INVALID_HANDLE,
2109         "Failed to NtQueryMutant, expected STATUS_INVALID_HANDLE, got %08x\n", status );
2110
2111     /* new */
2112     len = -1;
2113     memset(&info, 0xcc, sizeof(info));
2114     status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), &len);
2115     ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08x\n", status );
2116     ok( info.CurrentCount == 0, "expected 0, got %d\n", info.CurrentCount );
2117     ok( info.OwnedByCaller == TRUE, "expected TRUE, got %d\n", info.OwnedByCaller );
2118     ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );
2119     ok( len == sizeof(info), "got %u\n", len );
2120
2121     ret = WaitForSingleObject( mutant, 1000 );
2122     ok( ret == WAIT_OBJECT_0, "WaitForSingleObject failed %08x\n", ret );
2123
2124     memset(&info, 0xcc, sizeof(info));
2125     status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);
2126     ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08x\n", status );
2127     ok( info.CurrentCount == -1, "expected -1, got %d\n", info.CurrentCount );
2128     ok( info.OwnedByCaller == TRUE, "expected TRUE, got %d\n", info.OwnedByCaller );
2129     ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );
2130
2131     prev = 0xdeadbeef;
2132     status = pNtReleaseMutant(mutant, &prev);
2133     ok( status == STATUS_SUCCESS, "NtReleaseMutant failed %08x\n", status );
2134     ok( prev == -1, "NtReleaseMutant failed, expected -1, got %d\n", prev );
2135
2136     prev = 0xdeadbeef;
2137     status = pNtReleaseMutant(mutant, &prev);
2138     ok( status == STATUS_SUCCESS, "NtReleaseMutant failed %08x\n", status );
2139     ok( prev == 0, "NtReleaseMutant failed, expected 0, got %d\n", prev );
2140
2141     memset(&info, 0xcc, sizeof(info));
2142     status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);
2143     ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08x\n", status );
2144     ok( info.CurrentCount == 1, "expected 1, got %d\n", info.CurrentCount );
2145     ok( info.OwnedByCaller == FALSE, "expected FALSE, got %d\n", info.OwnedByCaller );
2146     ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );
2147
2148     /* abandoned */
2149     thread = CreateThread( NULL, 0, mutant_thread, mutant, 0, NULL );
2150     ret = WaitForSingleObject( thread, 1000 );
2151     ok( ret == WAIT_OBJECT_0, "WaitForSingleObject failed %08x\n", ret );
2152     CloseHandle( thread );
2153
2154     memset(&info, 0xcc, sizeof(info));
2155     status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);
2156     ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08x\n", status );
2157     ok( info.CurrentCount == 1, "expected 0, got %d\n", info.CurrentCount );
2158     ok( info.OwnedByCaller == FALSE, "expected FALSE, got %d\n", info.OwnedByCaller );
2159     ok( info.AbandonedState == TRUE, "expected TRUE, got %d\n", info.AbandonedState );
2160
2161     ret = WaitForSingleObject( mutant, 1000 );
2162     ok( ret == WAIT_ABANDONED_0, "WaitForSingleObject failed %08x\n", ret );
2163
2164     memset(&info, 0xcc, sizeof(info));
2165     status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);
2166     ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08x\n", status );
2167     ok( info.CurrentCount == 0, "expected 0, got %d\n", info.CurrentCount );
2168     ok( info.OwnedByCaller == TRUE, "expected TRUE, got %d\n", info.OwnedByCaller );
2169     ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );
2170
2171     NtClose( mutant );
2172 }
2173
2174 static void test_semaphore(void)
2175 {
2176     SEMAPHORE_BASIC_INFORMATION info;
2177     OBJECT_ATTRIBUTES attr;
2178     UNICODE_STRING str;
2179     NTSTATUS status;
2180     HANDLE semaphore;
2181     ULONG prev;
2182     ULONG len;
2183     DWORD ret;
2184
2185     pRtlInitUnicodeString(&str, L"\\BaseNamedObjects\\test_semaphore");
2186     InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
2187
2188     status = pNtCreateSemaphore(&semaphore, GENERIC_ALL, &attr, 2, 1);
2189     ok( status == STATUS_INVALID_PARAMETER, "Failed to create Semaphore(%08x)\n", status );
2190     status = pNtCreateSemaphore(&semaphore, GENERIC_ALL, &attr, 1, 2);
2191     ok( status == STATUS_SUCCESS, "Failed to create Semaphore(%08x)\n", status );
2192
2193     /* bogus */
2194     status = pNtQuerySemaphore(semaphore, SemaphoreBasicInformation, &info, 0, NULL);
2195     ok( status == STATUS_INFO_LENGTH_MISMATCH,
2196         "Failed to NtQuerySemaphore, expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status );
2197     status = pNtQuerySemaphore(semaphore, 0x42, &info, sizeof(info), NULL);
2198     ok( status == STATUS_INVALID_INFO_CLASS,
2199         "Failed to NtQuerySemaphore, expected STATUS_INVALID_INFO_CLASS, got %08x\n", status );
2200     status = pNtQuerySemaphore((HANDLE)0xdeadbeef, SemaphoreBasicInformation, &info, sizeof(info), NULL);
2201     ok( status == STATUS_INVALID_HANDLE,
2202         "Failed to NtQuerySemaphore, expected STATUS_INVALID_HANDLE, got %08x\n", status );
2203
2204     len = -1;
2205     memset(&info, 0xcc, sizeof(info));
2206     status = pNtQuerySemaphore(semaphore, SemaphoreBasicInformation, &info, sizeof(info), &len);
2207     ok( status == STATUS_SUCCESS, "NtQuerySemaphore failed %08x\n", status );
2208     ok( info.CurrentCount == 1, "expected 1, got %d\n", info.CurrentCount );
2209     ok( info.MaximumCount == 2, "expected 2, got %d\n", info.MaximumCount );
2210     ok( len == sizeof(info), "got %u\n", len );
2211
2212     ret = WaitForSingleObject( semaphore, 1000 );
2213     ok( ret == WAIT_OBJECT_0, "WaitForSingleObject failed %08x\n", ret );
2214
2215     memset(&info, 0xcc, sizeof(info));
2216     status = pNtQuerySemaphore(semaphore, SemaphoreBasicInformation, &info, sizeof(info), NULL);
2217     ok( status == STATUS_SUCCESS, "NtQuerySemaphore failed %08x\n", status );
2218     ok( info.CurrentCount == 0, "expected 0, got %d\n", info.CurrentCount );
2219     ok( info.MaximumCount == 2, "expected 2, got %d\n", info.MaximumCount );
2220
2221     prev = 0xdeadbeef;
2222     status = pNtReleaseSemaphore(semaphore, 3, &prev);
2223     ok( status == STATUS_SEMAPHORE_LIMIT_EXCEEDED, "NtReleaseSemaphore failed %08x\n", status );
2224     ok( prev == 0xdeadbeef, "NtReleaseSemaphore failed, expected 0xdeadbeef, got %d\n", prev );
2225
2226     prev = 0xdeadbeef;
2227     status = pNtReleaseSemaphore(semaphore, 1, &prev);
2228     ok( status == STATUS_SUCCESS, "NtReleaseSemaphore failed %08x\n", status );
2229     ok( prev == 0, "NtReleaseSemaphore failed, expected 0, got %d\n", prev );
2230
2231     prev = 0xdeadbeef;
2232     status = pNtReleaseSemaphore(semaphore, 1, &prev);
2233     ok( status == STATUS_SUCCESS, "NtReleaseSemaphore failed %08x\n", status );
2234     ok( prev == 1, "NtReleaseSemaphore failed, expected 1, got %d\n", prev );
2235
2236     prev = 0xdeadbeef;
2237     status = pNtReleaseSemaphore(semaphore, 1, &prev);
2238     ok( status == STATUS_SEMAPHORE_LIMIT_EXCEEDED, "NtReleaseSemaphore failed %08x\n", status );
2239     ok( prev == 0xdeadbeef, "NtReleaseSemaphore failed, expected 0xdeadbeef, got %d\n", prev );
2240
2241     memset(&info, 0xcc, sizeof(info));
2242     status = pNtQuerySemaphore(semaphore, SemaphoreBasicInformation, &info, sizeof(info), NULL);
2243     ok( status == STATUS_SUCCESS, "NtQuerySemaphore failed %08x\n", status );
2244     ok( info.CurrentCount == 2, "expected 2, got %d\n", info.CurrentCount );
2245     ok( info.MaximumCount == 2, "expected 2, got %d\n", info.MaximumCount );
2246
2247     NtClose( semaphore );
2248 }
2249
2250 static void test_wait_on_address(void)
2251 {
2252     DWORD ticks;
2253     SIZE_T size;
2254     NTSTATUS status;
2255     LARGE_INTEGER timeout;
2256     LONG64 address, compare;
2257
2258     if (!pRtlWaitOnAddress)
2259     {
2260         win_skip("RtlWaitOnAddress not supported, skipping test\n");
2261         return;
2262     }
2263
2264     if (0) /* crash on Windows */
2265     {
2266         pRtlWaitOnAddress(&address, NULL, 8, NULL);
2267         pRtlWaitOnAddress(NULL, &compare, 8, NULL);
2268         pRtlWaitOnAddress(NULL, NULL, 8, NULL);
2269     }
2270
2271     /* don't crash */
2272     pRtlWakeAddressSingle(NULL);
2273     pRtlWakeAddressAll(NULL);
2274
2275     /* invalid values */
2276     address = 0;
2277     compare = 0;
2278     status = pRtlWaitOnAddress(&address, &compare, 5, NULL);
2279     ok(status == STATUS_INVALID_PARAMETER, "got %x\n", status);
2280
2281     /* values match */
2282     address = 0;
2283     compare = 0;
2284     pNtQuerySystemTime(&timeout);
2285     timeout.QuadPart += 100*10000;
2286     ticks = GetTickCount();
2287     status = pRtlWaitOnAddress(&address, &compare, 8, &timeout);
2288     ticks = GetTickCount() - ticks;
2289     ok(status == STATUS_TIMEOUT, "got 0x%08x\n", status);
2290     ok(ticks >= 90 && ticks <= 1000, "got %u\n", ticks);
2291     ok(address == 0, "got %s\n", wine_dbgstr_longlong(address));
2292     ok(compare == 0, "got %s\n", wine_dbgstr_longlong(compare));
2293
2294     /* different address size */
2295     for (size = 1; size <= 4; size <<= 1)
2296     {
2297         compare = ~0;
2298         compare <<= size * 8;
2299
2300         timeout.QuadPart = -100 * 10000;
2301         ticks = GetTickCount();
2302         status = pRtlWaitOnAddress(&address, &compare, size, &timeout);
2303         ticks = GetTickCount() - ticks;
2304         ok(status == STATUS_TIMEOUT, "got 0x%08x\n", status);
2305         ok(ticks >= 90 && ticks <= 1000, "got %u\n", ticks);
2306
2307         status = pRtlWaitOnAddress(&address, &compare, size << 1, &timeout);
2308         ok(!status, "got 0x%08x\n", status);
2309     }
2310     address = 0;
2311     compare = 1;
2312     status = pRtlWaitOnAddress(&address, &compare, 8, NULL);
2313     ok(!status, "got 0x%08x\n", status);
2314
2315     /* no waiters */
2316     address = 0;
2317     pRtlWakeAddressSingle(&address);
2318     ok(address == 0, "got %s\n", wine_dbgstr_longlong(address));
2319     pRtlWakeAddressAll(&address);
2320     ok(address == 0, "got %s\n", wine_dbgstr_longlong(address));
2321 }
2322
2323 static void test_process(void)
2324 {
2325     OBJECT_ATTRIBUTES attr;
2326     CLIENT_ID cid;
2327     NTSTATUS status;
2328     HANDLE process;
2329
2330     if (!pNtOpenProcess)
2331     {
2332         win_skip( "NtOpenProcess not supported, skipping test\n" );
2333         return;
2334     }
2335
2336     InitializeObjectAttributes( &attr, NULL, 0, 0, NULL );
2337
2338     cid.UniqueProcess = 0;
2339     cid.UniqueThread = 0;
2340     status = pNtOpenProcess( &process, PROCESS_QUERY_LIMITED_INFORMATION, NULL, &cid );
2341     todo_wine ok( status == STATUS_ACCESS_VIOLATION, "NtOpenProcess returned %x\n", status );
2342     status = pNtOpenProcess( &process, PROCESS_QUERY_LIMITED_INFORMATION, &attr, NULL );
2343     todo_wine ok( status == STATUS_INVALID_PARAMETER_MIX, "NtOpenProcess returned %x\n", status );
2344
2345     cid.UniqueProcess = 0;
2346     cid.UniqueThread = 0;
2347     status = pNtOpenProcess( &process, PROCESS_QUERY_LIMITED_INFORMATION, &attr, &cid );
2348     ok( status == STATUS_INVALID_CID, "NtOpenProcess returned %x\n", status );
2349
2350     cid.UniqueProcess = ULongToHandle( 0xdeadbeef );
2351     cid.UniqueThread = ULongToHandle( 0xdeadbeef );
2352     status = pNtOpenProcess( &process, PROCESS_QUERY_LIMITED_INFORMATION, &attr, &cid );
2353     ok( status == STATUS_INVALID_CID, "NtOpenProcess returned %x\n", status );
2354
2355     cid.UniqueProcess = ULongToHandle( GetCurrentThreadId() );
2356     cid.UniqueThread = 0;
2357     status = pNtOpenProcess( &process, PROCESS_QUERY_LIMITED_INFORMATION, &attr, &cid );
2358     ok( status == STATUS_INVALID_CID, "NtOpenProcess returned %x\n", status );
2359
2360     cid.UniqueProcess = ULongToHandle( GetCurrentProcessId() );
2361     cid.UniqueThread = 0;
2362     status = pNtOpenProcess( &process, PROCESS_QUERY_LIMITED_INFORMATION, &attr, &cid );
2363     ok( !status, "NtOpenProcess returned %x\n", status );
2364     pNtClose( process );
2365
2366     cid.UniqueProcess = ULongToHandle( GetCurrentProcessId() );
2367     cid.UniqueThread = ULongToHandle( GetCurrentThreadId() );
2368     status = pNtOpenProcess( &process, PROCESS_QUERY_LIMITED_INFORMATION, &attr, &cid );
2369     ok( !status, "NtOpenProcess returned %x\n", status );
2370     pNtClose( process );
2371 }
2372
2373 #define DEBUG_GENERIC_EXECUTE         (STANDARD_RIGHTS_EXECUTE|SYNCHRONIZE)
2374 #define DEBUG_GENERIC_READ            (STANDARD_RIGHTS_READ|DEBUG_READ_EVENT)
2375 #define DEBUG_GENERIC_WRITE           (STANDARD_RIGHTS_WRITE|DEBUG_PROCESS_ASSIGN)
2376 #define DESKTOP_GENERIC_EXECUTE       (STANDARD_RIGHTS_EXECUTE|DESKTOP_SWITCHDESKTOP)
2377 #define DESKTOP_GENERIC_READ          (STANDARD_RIGHTS_READ|DESKTOP_ENUMERATE|DESKTOP_READOBJECTS)
2378 #define DESKTOP_GENERIC_WRITE         (STANDARD_RIGHTS_WRITE|DESKTOP_WRITEOBJECTS|DESKTOP_JOURNALPLAYBACK|\
2379                                        DESKTOP_JOURNALRECORD|DESKTOP_HOOKCONTROL|DESKTOP_CREATEMENU| \
2380                                        DESKTOP_CREATEWINDOW)
2381 #define DIRECTORY_GENERIC_EXECUTE     (STANDARD_RIGHTS_EXECUTE|DIRECTORY_TRAVERSE|DIRECTORY_QUERY)
2382 #define DIRECTORY_GENERIC_READ        (STANDARD_RIGHTS_READ|DIRECTORY_TRAVERSE|DIRECTORY_QUERY)
2383 #define DIRECTORY_GENERIC_WRITE       (STANDARD_RIGHTS_WRITE|DIRECTORY_CREATE_SUBDIRECTORY|\
2384                                        DIRECTORY_CREATE_OBJECT)
2385 #define EVENT_GENERIC_EXECUTE         (STANDARD_RIGHTS_EXECUTE|SYNCHRONIZE)
2386 #define EVENT_GENERIC_READ            (STANDARD_RIGHTS_READ|EVENT_QUERY_STATE)
2387 #define EVENT_GENERIC_WRITE           (STANDARD_RIGHTS_WRITE|EVENT_MODIFY_STATE)
2388 #define IO_COMPLETION_GENERIC_EXECUTE (STANDARD_RIGHTS_EXECUTE|SYNCHRONIZE)
2389 #define IO_COMPLETION_GENERIC_READ    (STANDARD_RIGHTS_READ|IO_COMPLETION_QUERY_STATE)
2390 #define IO_COMPLETION_GENERIC_WRITE   (STANDARD_RIGHTS_WRITE|IO_COMPLETION_MODIFY_STATE)
2391 #define JOB_OBJECT_GENERIC_EXECUTE    (STANDARD_RIGHTS_EXECUTE|SYNCHRONIZE)
2392 #define JOB_OBJECT_GENERIC_READ       (STANDARD_RIGHTS_READ|JOB_OBJECT_QUERY)
2393 #define JOB_OBJECT_GENERIC_WRITE      (STANDARD_RIGHTS_WRITE|JOB_OBJECT_TERMINATE|\
2394                                        JOB_OBJECT_SET_ATTRIBUTES|JOB_OBJECT_ASSIGN_PROCESS)
2395 #define KEY_GENERIC_EXECUTE           (STANDARD_RIGHTS_EXECUTE|KEY_CREATE_LINK|KEY_NOTIFY|\
2396                                        KEY_ENUMERATE_SUB_KEYS|KEY_QUERY_VALUE)
2397 #define KEY_GENERIC_READ              (STANDARD_RIGHTS_READ|KEY_NOTIFY|KEY_ENUMERATE_SUB_KEYS|\
2398                                        KEY_QUERY_VALUE)
2399 #define KEY_GENERIC_WRITE             (STANDARD_RIGHTS_WRITE|KEY_CREATE_SUB_KEY|KEY_SET_VALUE)
2400 #define KEYEDEVENT_GENERIC_EXECUTE    (STANDARD_RIGHTS_EXECUTE)
2401 #define KEYEDEVENT_GENERIC_READ       (STANDARD_RIGHTS_READ|KEYEDEVENT_WAIT)
2402 #define KEYEDEVENT_GENERIC_WRITE      (STANDARD_RIGHTS_WRITE|KEYEDEVENT_WAKE)
2403 #define MUTANT_GENERIC_EXECUTE        (STANDARD_RIGHTS_EXECUTE|SYNCHRONIZE)
2404 #define MUTANT_GENERIC_READ           (STANDARD_RIGHTS_READ|MUTANT_QUERY_STATE)
2405 #define MUTANT_GENERIC_WRITE          (STANDARD_RIGHTS_WRITE)
2406 #define PROCESS_GENERIC_EXECUTE       (STANDARD_RIGHTS_EXECUTE|SYNCHRONIZE|\
2407                                        PROCESS_QUERY_LIMITED_INFORMATION|PROCESS_TERMINATE)
2408 #define PROCESS_GENERIC_READ          (STANDARD_RIGHTS_READ|PROCESS_VM_READ|PROCESS_QUERY_INFORMATION)
2409 #define PROCESS_GENERIC_WRITE         (STANDARD_RIGHTS_WRITE|PROCESS_SUSPEND_RESUME|\
2410                                        PROCESS_SET_INFORMATION|PROCESS_SET_QUOTA|PROCESS_CREATE_PROCESS|\
2411                                        PROCESS_DUP_HANDLE|PROCESS_VM_WRITE|PROCESS_VM_OPERATION|\
2412                                        PROCESS_CREATE_THREAD)
2413 #define SECTION_GENERIC_EXECUTE       (STANDARD_RIGHTS_EXECUTE|SECTION_MAP_EXECUTE)
2414 #define SECTION_GENERIC_READ          (STANDARD_RIGHTS_READ|SECTION_QUERY|SECTION_MAP_READ)
2415 #define SECTION_GENERIC_WRITE         (STANDARD_RIGHTS_WRITE|SECTION_MAP_WRITE)
2416 #define SEMAPHORE_GENERIC_EXECUTE     (STANDARD_RIGHTS_EXECUTE|SYNCHRONIZE)
2417 #define SEMAPHORE_GENERIC_READ        (STANDARD_RIGHTS_READ|SEMAPHORE_QUERY_STATE)
2418 #define SEMAPHORE_GENERIC_WRITE       (STANDARD_RIGHTS_WRITE|SEMAPHORE_MODIFY_STATE)
2419 #define SYMBOLIC_LINK_GENERIC_EXECUTE (STANDARD_RIGHTS_EXECUTE|SYMBOLIC_LINK_QUERY)
2420 #define SYMBOLIC_LINK_GENERIC_READ    (STANDARD_RIGHTS_READ|SYMBOLIC_LINK_QUERY)
2421 #define SYMBOLIC_LINK_GENERIC_WRITE   (STANDARD_RIGHTS_WRITE)
2422 #define THREAD_GENERIC_EXECUTE        (STANDARD_RIGHTS_EXECUTE|SYNCHRONIZE|THREAD_RESUME|\
2423                                        THREAD_QUERY_LIMITED_INFORMATION)
2424 #define THREAD_GENERIC_READ           (STANDARD_RIGHTS_READ|THREAD_QUERY_INFORMATION|THREAD_GET_CONTEXT)
2425 #define THREAD_GENERIC_WRITE          (STANDARD_RIGHTS_WRITE|THREAD_SET_LIMITED_INFORMATION|\
2426                                        THREAD_SET_INFORMATION|THREAD_SET_CONTEXT|THREAD_SUSPEND_RESUME|\
2427                                        THREAD_TERMINATE|0x04)
2428 #define TIMER_GENERIC_EXECUTE         (STANDARD_RIGHTS_EXECUTE|SYNCHRONIZE)
2429 #define TIMER_GENERIC_READ            (STANDARD_RIGHTS_READ|TIMER_QUERY_STATE)
2430 #define TIMER_GENERIC_WRITE           (STANDARD_RIGHTS_WRITE|TIMER_MODIFY_STATE)
2431 #define TOKEN_GENERIC_EXECUTE         (STANDARD_RIGHTS_EXECUTE|TOKEN_IMPERSONATE|TOKEN_ASSIGN_PRIMARY)
2432 #define TOKEN_GENERIC_READ            (STANDARD_RIGHTS_READ|TOKEN_QUERY_SOURCE|TOKEN_QUERY|TOKEN_DUPLICATE)
2433 #define TOKEN_GENERIC_WRITE           (STANDARD_RIGHTS_WRITE|TOKEN_ADJUST_SESSIONID|TOKEN_ADJUST_DEFAULT|\
2434                                        TOKEN_ADJUST_GROUPS|TOKEN_ADJUST_PRIVILEGES)
2435 #define TYPE_GENERIC_EXECUTE          (STANDARD_RIGHTS_EXECUTE)
2436 #define TYPE_GENERIC_READ             (STANDARD_RIGHTS_READ)
2437 #define TYPE_GENERIC_WRITE            (STANDARD_RIGHTS_WRITE)
2438 #define WINSTA_GENERIC_EXECUTE        (STANDARD_RIGHTS_EXECUTE|WINSTA_EXITWINDOWS|WINSTA_ACCESSGLOBALATOMS)
2439 #define WINSTA_GENERIC_READ           (STANDARD_RIGHTS_READ|WINSTA_READSCREEN|WINSTA_ENUMERATE|\
2440                                        WINSTA_READATTRIBUTES|WINSTA_ENUMDESKTOPS)
2441 #define WINSTA_GENERIC_WRITE          (STANDARD_RIGHTS_WRITE|WINSTA_WRITEATTRIBUTES|WINSTA_CREATEDESKTOP|\
2442                                        WINSTA_ACCESSCLIPBOARD)
2443
2444 #undef WINSTA_ALL_ACCESS
2445 #undef DESKTOP_ALL_ACCESS
2446 #define WINSTA_ALL_ACCESS  (STANDARD_RIGHTS_REQUIRED|0x37f)
2447 #define DESKTOP_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|0x1ff)
2448 #define DEVICE_ALL_ACCESS  (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x1ff)
2449 #define TYPE_ALL_ACCESS    (STANDARD_RIGHTS_REQUIRED|0x1)
2450
2451 static void *align_ptr( void *ptr )
2452 {
2453     ULONG align = sizeof(DWORD_PTR) - 1;
2454     return (void *)(((DWORD_PTR)ptr + align) & ~align);
2455 }
2456
2457 static void test_object_types(void)
2458 {
2459     static const struct { const WCHAR *name; GENERIC_MAPPING mapping; ULONG mask, broken; } tests[] =
2460     {
2461 #define TYPE(name,gen,extra,broken) { name, { gen ## _GENERIC_READ, gen ## _GENERIC_WRITE, \
2462                 gen ## _GENERIC_EXECUTE, gen ## _ALL_ACCESS }, gen ## _ALL_ACCESS | extra, broken }
2463         TYPE( L"DebugObject",   DEBUG, 0, 0 ),
2464         TYPE( L"Desktop",       DESKTOP, 0, 0 ),
2465         TYPE( L"Device",        FILE, 0, 0 ),
2466         TYPE( L"Directory",     DIRECTORY, 0, 0 ),
2467         TYPE( L"Event",         EVENT, 0, 0 ),
2468         TYPE( L"File",          FILE, 0, 0 ),
2469         TYPE( L"IoCompletion",  IO_COMPLETION, 0, 0 ),
2470         TYPE( L"Job",           JOB_OBJECT, 0, JOB_OBJECT_IMPERSONATE ),
2471         TYPE( L"Key",           KEY, SYNCHRONIZE, 0 ),
2472         TYPE( L"KeyedEvent",    KEYEDEVENT, SYNCHRONIZE, 0 ),
2473         TYPE( L"Mutant",        MUTANT, 0, 0 ),
2474         TYPE( L"Process",       PROCESS, 0, 0 ),
2475         TYPE( L"Section",       SECTION, SYNCHRONIZE, 0 ),
2476         TYPE( L"Semaphore",     SEMAPHORE, 0, 0 ),
2477         TYPE( L"SymbolicLink",  SYMBOLIC_LINK, 0, 0xfffe ),
2478         TYPE( L"Thread",        THREAD, 0, THREAD_RESUME ),
2479         TYPE( L"Timer",         TIMER, 0, 0 ),
2480         TYPE( L"Token",         TOKEN, SYNCHRONIZE, 0 ),
2481         TYPE( L"Type",          TYPE, SYNCHRONIZE, 0 ),
2482         TYPE( L"WindowStation", WINSTA, 0, 0 ),
2483 #undef TYPE
2484     };
2485     unsigned int i, j;
2486     BOOLEAN tested[ARRAY_SIZE(all_types)] = { 0 };
2487     char buffer[256];
2488     OBJECT_TYPES_INFORMATION *info = (OBJECT_TYPES_INFORMATION *)buffer;
2489     GENERIC_MAPPING map;
2490     NTSTATUS status;
2491     ULONG len, retlen;
2492
2493     memset( buffer, 0xcc, sizeof(buffer) );
2494     status = pNtQueryObject( NULL, ObjectTypesInformation, info, sizeof(buffer), &len );
2495     ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
2496     ok( info->NumberOfTypes < 100 || info->NumberOfTypes == 0xcccccccc, /* wow64 */
2497         "wrong number of types %u\n", info->NumberOfTypes );
2498
2499     info = malloc( len + 16 );  /* Windows gets the length wrong on WoW64 and overflows the buffer */
2500     memset( info, 0xcc, sizeof(*info) );
2501     status = pNtQueryObject( NULL, ObjectTypesInformation, info, len, &retlen );
2502     ok( retlen <= len + 16, "wrong len %x/%x\n", len, retlen );
2503     ok( len == retlen || broken( retlen == len + 16 || retlen == len - 16 ),  /* wow64 */
2504         "wrong len %x/%x\n", len, retlen );
2505     ok( !status, "NtQueryObject failed %x\n", status );
2506     if (!status)
2507     {
2508         OBJECT_TYPE_INFORMATION *type = align_ptr( info + 1 );
2509         for (i = 0; i < info->NumberOfTypes; i++)
2510         {
2511             add_object_type( type );
2512             type = align_ptr( (char *)type->TypeName.Buffer + type->TypeName.MaximumLength );
2513         }
2514     }
2515     free( info );
2516
2517     for (i = 0; i < ARRAY_SIZE(tests); i++)
2518     {
2519         for (j = 0; j < ARRAY_SIZE(all_types); j++)
2520         {
2521             if (!all_types[j].TypeName.Buffer) continue;
2522             if (wcscmp( tests[i].name, all_types[j].TypeName.Buffer )) continue;
2523             map = all_types[j].GenericMapping;
2524             ok( !memcmp( &map, &tests[i].mapping, sizeof(GENERIC_MAPPING) ) ||
2525                 broken( !((map.GenericRead ^ tests[i].mapping.GenericRead) & ~tests[i].broken) &&
2526                         !((map.GenericWrite ^ tests[i].mapping.GenericWrite) & ~tests[i].broken) &&
2527                         !((map.GenericExecute ^ tests[i].mapping.GenericExecute) & ~tests[i].broken) &&
2528                         !((map.GenericAll ^ tests[i].mapping.GenericAll) & ~tests[i].broken) ),
2529                 "%s: mismatched mappings %08x,%08x,%08x,%08x / %08x,%08x,%08x,%08x\n",
2530                 debugstr_w( tests[i].name ),
2531                 all_types[j].GenericMapping.GenericRead, all_types[j].GenericMapping.GenericWrite,
2532                 all_types[j].GenericMapping.GenericExecute, all_types[j].GenericMapping.GenericAll,
2533                 tests[i].mapping.GenericRead, tests[i].mapping.GenericWrite,
2534                 tests[i].mapping.GenericExecute, tests[i].mapping.GenericAll );
2535             ok( all_types[j].ValidAccessMask == tests[i].mask ||
2536                 broken( !((all_types[j].ValidAccessMask ^ tests[i].mask) & ~tests[i].broken) ),
2537                 "%s: mismatched access mask %08x / %08x\n", debugstr_w( tests[i].name ),
2538                 all_types[j].ValidAccessMask, tests[i].mask );
2539             tested[j] = TRUE;
2540             break;
2541         }
2542         ok( j < ARRAY_SIZE(all_types), "type %s not found\n", debugstr_w(tests[i].name) );
2543     }
2544     for (j = 0; j < ARRAY_SIZE(all_types); j++)
2545     {
2546         if (!all_types[j].TypeName.Buffer) continue;
2547         if (tested[j]) continue;
2548         trace( "not tested: %s\n", debugstr_w(all_types[j].TypeName.Buffer ));
2549     }
2550 }
2551
2552 START_TEST(om)
2553 {
2554     HMODULE hntdll = GetModuleHandleA("ntdll.dll");
2555
2556     pNtCreateEvent          = (void *)GetProcAddress(hntdll, "NtCreateEvent");
2557     pNtCreateJobObject      = (void *)GetProcAddress(hntdll, "NtCreateJobObject");
2558     pNtOpenJobObject        = (void *)GetProcAddress(hntdll, "NtOpenJobObject");
2559     pNtCreateKey            = (void *)GetProcAddress(hntdll, "NtCreateKey");
2560     pNtOpenKey              = (void *)GetProcAddress(hntdll, "NtOpenKey");
2561     pNtDeleteKey            = (void *)GetProcAddress(hntdll, "NtDeleteKey");
2562     pNtCreateMailslotFile   = (void *)GetProcAddress(hntdll, "NtCreateMailslotFile");
2563     pNtCreateMutant         = (void *)GetProcAddress(hntdll, "NtCreateMutant");
2564     pNtOpenEvent            = (void *)GetProcAddress(hntdll, "NtOpenEvent");
2565     pNtQueryEvent           = (void *)GetProcAddress(hntdll, "NtQueryEvent");
2566     pNtPulseEvent           = (void *)GetProcAddress(hntdll, "NtPulseEvent");
2567     pNtResetEvent           = (void *)GetProcAddress(hntdll, "NtResetEvent");
2568     pNtSetEvent             = (void *)GetProcAddress(hntdll, "NtSetEvent");
2569     pNtOpenMutant           = (void *)GetProcAddress(hntdll, "NtOpenMutant");
2570     pNtQueryMutant          = (void *)GetProcAddress(hntdll, "NtQueryMutant");
2571     pNtReleaseMutant        = (void *)GetProcAddress(hntdll, "NtReleaseMutant");
2572     pNtOpenFile             = (void *)GetProcAddress(hntdll, "NtOpenFile");
2573     pNtClose                = (void *)GetProcAddress(hntdll, "NtClose");
2574     pRtlInitUnicodeString   = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString");
2575     pNtCreateNamedPipeFile  = (void *)GetProcAddress(hntdll, "NtCreateNamedPipeFile");
2576     pNtOpenDirectoryObject  = (void *)GetProcAddress(hntdll, "NtOpenDirectoryObject");
2577     pNtCreateDirectoryObject= (void *)GetProcAddress(hntdll, "NtCreateDirectoryObject");
2578     pNtOpenSymbolicLinkObject = (void *)GetProcAddress(hntdll, "NtOpenSymbolicLinkObject");
2579     pNtCreateSymbolicLinkObject = (void *)GetProcAddress(hntdll, "NtCreateSymbolicLinkObject");
2580     pNtQuerySymbolicLinkObject  = (void *)GetProcAddress(hntdll, "NtQuerySymbolicLinkObject");
2581     pNtCreateSemaphore      =  (void *)GetProcAddress(hntdll, "NtCreateSemaphore");
2582     pNtOpenSemaphore        =  (void *)GetProcAddress(hntdll, "NtOpenSemaphore");
2583     pNtQuerySemaphore       =  (void *)GetProcAddress(hntdll, "NtQuerySemaphore");
2584     pNtCreateTimer          =  (void *)GetProcAddress(hntdll, "NtCreateTimer");
2585     pNtOpenTimer            =  (void *)GetProcAddress(hntdll, "NtOpenTimer");
2586     pNtCreateSection        =  (void *)GetProcAddress(hntdll, "NtCreateSection");
2587     pNtOpenSection          =  (void *)GetProcAddress(hntdll, "NtOpenSection");
2588     pNtQueryObject          =  (void *)GetProcAddress(hntdll, "NtQueryObject");
2589     pNtReleaseSemaphore     =  (void *)GetProcAddress(hntdll, "NtReleaseSemaphore");
2590     pNtCreateKeyedEvent     =  (void *)GetProcAddress(hntdll, "NtCreateKeyedEvent");
2591     pNtOpenKeyedEvent       =  (void *)GetProcAddress(hntdll, "NtOpenKeyedEvent");
2592     pNtWaitForKeyedEvent    =  (void *)GetProcAddress(hntdll, "NtWaitForKeyedEvent");
2593     pNtReleaseKeyedEvent    =  (void *)GetProcAddress(hntdll, "NtReleaseKeyedEvent");
2594     pNtCreateIoCompletion   =  (void *)GetProcAddress(hntdll, "NtCreateIoCompletion");
2595     pNtOpenIoCompletion     =  (void *)GetProcAddress(hntdll, "NtOpenIoCompletion");
2596     pNtQueryInformationFile =  (void *)GetProcAddress(hntdll, "NtQueryInformationFile");
2597     pNtQuerySystemTime      =  (void *)GetProcAddress(hntdll, "NtQuerySystemTime");
2598     pRtlWaitOnAddress       =  (void *)GetProcAddress(hntdll, "RtlWaitOnAddress");
2599     pRtlWakeAddressAll      =  (void *)GetProcAddress(hntdll, "RtlWakeAddressAll");
2600     pRtlWakeAddressSingle   =  (void *)GetProcAddress(hntdll, "RtlWakeAddressSingle");
2601     pNtOpenProcess          =  (void *)GetProcAddress(hntdll, "NtOpenProcess");
2602     pNtCreateDebugObject    =  (void *)GetProcAddress(hntdll, "NtCreateDebugObject");
2603
2604     test_case_sensitive();
2605     test_namespace_pipe();
2606     test_name_collisions();
2607     test_name_limits();
2608     test_directory();
2609     test_symboliclink();
2610     test_query_object();
2611     test_type_mismatch();
2612     test_event();
2613     test_mutant();
2614     test_semaphore();
2615     test_keyed_events();
2616     test_null_device();
2617     test_wait_on_address();
2618     test_process();
2619     test_object_types();
2620 }