d8/dea/modules_2rostests_2winetests_2ntdll_2sync_8c_source.html

/*

 * Unit tests for NT synchronization objects

 *

 * Copyright 2020 Zebediah Figura

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA

 */


#include <stdarg.h>


#include "ntstatus.h"

#define WIN32_NO_STATUS

#include "windef.h"

#include "winternl.h"

#include "wine/test.h"


#if defined (__REACTOS__) && (DLL_EXPORT_VERSION < 0x601)

static

NTSTATUS

WINAPI

NtRemoveIoCompletionEx_(

    _In_ HANDLE IoCompletionHandle,

    _Out_writes_to_(Count, *NumEntriesRemoved) PFILE_IO_COMPLETION_INFORMATION IoCompletionInformation,

    _In_ ULONG Count,

    _Out_ PULONG NumEntriesRemoved,

    _In_opt_ PLARGE_INTEGER Timeout,

    _In_ BOOLEAN Alertable)

{

    // HACK!

    *NumEntriesRemoved = Count;

    return NtRemoveIoCompletion(IoCompletionHandle,

                                &IoCompletionInformation[0].CompletionKey,

                                &IoCompletionInformation[0].CompletionValue,

                                &IoCompletionInformation[0].IoStatusBlock,

                                Timeout);

}

#define NtRemoveIoCompletionEx NtRemoveIoCompletionEx_

#endif


static NTSTATUS (WINAPI *pNtAlertThreadByThreadId)( HANDLE );

static NTSTATUS (WINAPI *pNtClose)( HANDLE );

static NTSTATUS (WINAPI *pNtCreateEvent) ( PHANDLE, ACCESS_MASK, const OBJECT_ATTRIBUTES *, EVENT_TYPE, BOOLEAN);

static NTSTATUS (WINAPI *pNtCreateKeyedEvent)( HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES *, ULONG );

static NTSTATUS (WINAPI *pNtCreateMutant)( HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES *, BOOLEAN );

static NTSTATUS (WINAPI *pNtCreateSemaphore)( HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES *, LONG, LONG );

static NTSTATUS (WINAPI *pNtOpenEvent)( HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES * );

static NTSTATUS (WINAPI *pNtOpenKeyedEvent)( HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES * );

static NTSTATUS (WINAPI *pNtPulseEvent)( HANDLE, LONG * );

static NTSTATUS (WINAPI *pNtQueryEvent)( HANDLE, EVENT_INFORMATION_CLASS, void *, ULONG, ULONG * );

static NTSTATUS (WINAPI *pNtQueryMutant)( HANDLE, MUTANT_INFORMATION_CLASS, void *, ULONG, ULONG * );

static NTSTATUS (WINAPI *pNtQuerySemaphore)( HANDLE, SEMAPHORE_INFORMATION_CLASS, void *, ULONG, ULONG * );

static NTSTATUS (WINAPI *pNtQuerySystemTime)( LARGE_INTEGER * );

static NTSTATUS (WINAPI *pNtReleaseKeyedEvent)( HANDLE, const void *, BOOLEAN, const LARGE_INTEGER * );

static NTSTATUS (WINAPI *pNtReleaseMutant)( HANDLE, LONG * );

static NTSTATUS (WINAPI *pNtReleaseSemaphore)( HANDLE, ULONG, ULONG * );

static NTSTATUS (WINAPI *pNtResetEvent)( HANDLE, LONG * );

static NTSTATUS (WINAPI *pNtSetEvent)( HANDLE, LONG * );

static NTSTATUS (WINAPI *pNtWaitForAlertByThreadId)( void *, const LARGE_INTEGER * );

static NTSTATUS (WINAPI *pNtWaitForKeyedEvent)( HANDLE, const void *, BOOLEAN, const LARGE_INTEGER * );

static BOOLEAN  (WINAPI *pRtlAcquireResourceExclusive)( RTL_RWLOCK *, BOOLEAN );

static BOOLEAN  (WINAPI *pRtlAcquireResourceShared)( RTL_RWLOCK *, BOOLEAN );

static void     (WINAPI *pRtlDeleteResource)( RTL_RWLOCK * );

static void     (WINAPI *pRtlInitializeResource)( RTL_RWLOCK * );

static void     (WINAPI *pRtlInitUnicodeString)( UNICODE_STRING *, const WCHAR * );

static void     (WINAPI *pRtlReleaseResource)( RTL_RWLOCK * );

static NTSTATUS (WINAPI *pRtlWaitOnAddress)( const void *, const void *, SIZE_T, const LARGE_INTEGER * );

static void     (WINAPI *pRtlWakeAddressAll)( const void * );

static void     (WINAPI *pRtlWakeAddressSingle)( const void * );


#define KEYEDEVENT_WAIT       0x0001

#define KEYEDEVENT_WAKE       0x0002

#define KEYEDEVENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x0003)


static void test_event(void)

{

    HANDLE event;

    HANDLE event2;

    LONG prev_state = 0xdeadbeef;

    NTSTATUS status;

    UNICODE_STRING str;

    OBJECT_ATTRIBUTES attr;

    EVENT_BASIC_INFORMATION info;


    pRtlInitUnicodeString( &str, L"\\BaseNamedObjects\\testEvent" );

    InitializeObjectAttributes(&attr, &str, 0, 0, NULL);


    status = pNtCreateEvent(&event, GENERIC_ALL, &attr, 2, 0);

    ok( status == STATUS_INVALID_PARAMETER, "NtCreateEvent failed %08lx\n", status );


    status = pNtCreateEvent(&event, GENERIC_ALL, &attr, NotificationEvent, 0);

    ok( status == STATUS_SUCCESS, "NtCreateEvent failed %08lx\n", status );

    memset(&info, 0xcc, sizeof(info));

    status = pNtQueryEvent(event, EventBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_SUCCESS, "NtQueryEvent failed %08lx\n", status );

    ok( info.EventType == NotificationEvent && info.EventState == 0,

        "NtQueryEvent failed, expected 0 0, got %d %ld\n", info.EventType, info.EventState );

    pNtClose(event);


    status = pNtCreateEvent(&event, GENERIC_ALL, &attr, SynchronizationEvent, 0);

    ok( status == STATUS_SUCCESS, "NtCreateEvent failed %08lx\n", status );


    status = pNtPulseEvent(event, &prev_state);

    ok( status == STATUS_SUCCESS, "NtPulseEvent failed %08lx\n", status );

    ok( !prev_state, "prev_state = %lx\n", prev_state );


    memset(&info, 0xcc, sizeof(info));

    status = pNtQueryEvent(event, EventBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_SUCCESS, "NtQueryEvent failed %08lx\n", status );

    ok( info.EventType == SynchronizationEvent && info.EventState == 0,

        "NtQueryEvent failed, expected 1 0, got %d %ld\n", info.EventType, info.EventState );


    status = pNtOpenEvent(&event2, GENERIC_ALL, &attr);

    ok( status == STATUS_SUCCESS, "NtOpenEvent failed %08lx\n", status );


    pNtClose(event);

    event = event2;


    memset(&info, 0xcc, sizeof(info));

    status = pNtQueryEvent(event, EventBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_SUCCESS, "NtQueryEvent failed %08lx\n", status );

    ok( info.EventType == SynchronizationEvent && info.EventState == 0,

        "NtQueryEvent failed, expected 1 0, got %d %ld\n", info.EventType, info.EventState );


    status = pNtSetEvent( event, &prev_state );

    ok( status == STATUS_SUCCESS, "NtSetEvent failed: %08lx\n", status );

    ok( !prev_state, "prev_state = %lx\n", prev_state );


    memset(&info, 0xcc, sizeof(info));

    status = pNtQueryEvent(event, EventBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_SUCCESS, "NtQueryEvent failed %08lx\n", status );

    ok( info.EventType == SynchronizationEvent && info.EventState == 1,

        "NtQueryEvent failed, expected 1 1, got %d %ld\n", info.EventType, info.EventState );


    status = pNtSetEvent( event, &prev_state );

    ok( status == STATUS_SUCCESS, "NtSetEvent failed: %08lx\n", status );

    ok( prev_state == 1, "prev_state = %lx\n", prev_state );


    status = pNtResetEvent( event, &prev_state );

    ok( status == STATUS_SUCCESS, "NtSetEvent failed: %08lx\n", status );

    ok( prev_state == 1, "prev_state = %lx\n", prev_state );


    status = pNtResetEvent( event, &prev_state );

    ok( status == STATUS_SUCCESS, "NtSetEvent failed: %08lx\n", status );

    ok( !prev_state, "prev_state = %lx\n", prev_state );


    status = pNtPulseEvent( event, &prev_state );

    ok( status == STATUS_SUCCESS, "NtPulseEvent failed %08lx\n", status );

    ok( !prev_state, "prev_state = %lx\n", prev_state );


    status = pNtSetEvent( event, &prev_state );

    ok( status == STATUS_SUCCESS, "NtSetEvent failed: %08lx\n", status );

    ok( !prev_state, "prev_state = %lx\n", prev_state );


    status = pNtPulseEvent( event, &prev_state );

    ok( status == STATUS_SUCCESS, "NtPulseEvent failed %08lx\n", status );

    ok( prev_state == 1, "prev_state = %lx\n", prev_state );


    pNtClose(event);

}


static const WCHAR keyed_nameW[] = L"\\BaseNamedObjects\\WineTestEvent";


static DWORD WINAPI keyed_event_thread( void *arg )

{

    HANDLE handle;

    NTSTATUS status;

    LARGE_INTEGER timeout;

    OBJECT_ATTRIBUTES attr;

    UNICODE_STRING str;

    ULONG_PTR i;


    attr.Length                   = sizeof(attr);

    attr.RootDirectory            = 0;

    attr.ObjectName               = &str;

    attr.Attributes               = 0;

    attr.SecurityDescriptor       = NULL;

    attr.SecurityQualityOfService = NULL;

    RtlInitUnicodeString( &str, keyed_nameW );


    status = pNtOpenKeyedEvent( &handle, KEYEDEVENT_ALL_ACCESS, &attr );

    ok( !status, "NtOpenKeyedEvent failed %lx\n", status );


    for (i = 0; i < 20; i++)

    {

        if (i & 1)

            status = pNtWaitForKeyedEvent( handle, (void *)(i * 2), 0, NULL );

        else

            status = pNtReleaseKeyedEvent( handle, (void *)(i * 2), 0, NULL );

        ok( status == STATUS_SUCCESS, "%Ii: failed %lx\n", i, status );

        Sleep( 20 - i );

    }


    status = pNtReleaseKeyedEvent( handle, (void *)0x1234, 0, NULL );

    ok( status == STATUS_SUCCESS, "NtReleaseKeyedEvent %lx\n", status );


    timeout.QuadPart = -10000;

    status = pNtWaitForKeyedEvent( handle, (void *)0x5678, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( handle, (void *)0x9abc, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %lx\n", status );


    NtClose( handle );

    return 0;

}


static void test_keyed_events(void)

{

    OBJECT_ATTRIBUTES attr;

    UNICODE_STRING str;

    HANDLE handle, event, thread;

    NTSTATUS status;

    LARGE_INTEGER timeout;

    ULONG_PTR i;


    if (!pNtCreateKeyedEvent)

    {

        win_skip( "Keyed events not supported\n" );

        return;

    }


    attr.Length                   = sizeof(attr);

    attr.RootDirectory            = 0;

    attr.ObjectName               = &str;

    attr.Attributes               = 0;

    attr.SecurityDescriptor       = NULL;

    attr.SecurityQualityOfService = NULL;

    RtlInitUnicodeString( &str, keyed_nameW );


    status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_ALL_ACCESS | SYNCHRONIZE, &attr, 0 );

    ok( !status, "NtCreateKeyedEvent failed %lx\n", status );


    status = WaitForSingleObject( handle, 1000 );

    ok( status == 0, "WaitForSingleObject %lx\n", status );


    timeout.QuadPart = -100000;

    status = pNtWaitForKeyedEvent( handle, (void *)255, 0, &timeout );

    ok( status == STATUS_INVALID_PARAMETER_1, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( handle, (void *)255, 0, &timeout );

    ok( status == STATUS_INVALID_PARAMETER_1, "NtReleaseKeyedEvent %lx\n", status );


    status = pNtWaitForKeyedEvent( handle, (void *)254, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( handle, (void *)254, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %lx\n", status );


    status = pNtWaitForKeyedEvent( handle, NULL, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( handle, NULL, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %lx\n", status );


    status = pNtWaitForKeyedEvent( NULL, (void *)8, 0, &timeout );

    ok( status == STATUS_TIMEOUT || broken(status == STATUS_INVALID_HANDLE), /* XP/2003 */

        "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( NULL, (void *)8, 0, &timeout );

    ok( status == STATUS_TIMEOUT || broken(status == STATUS_INVALID_HANDLE), /* XP/2003 */

        "NtReleaseKeyedEvent %lx\n", status );


    status = pNtWaitForKeyedEvent( (HANDLE)0xdeadbeef, (void *)9, 0, &timeout );

    ok( status == STATUS_INVALID_PARAMETER_1, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( (HANDLE)0xdeadbeef, (void *)9, 0, &timeout );

    ok( status == STATUS_INVALID_PARAMETER_1, "NtReleaseKeyedEvent %lx\n", status );


    status = pNtWaitForKeyedEvent( (HANDLE)0xdeadbeef, (void *)8, 0, &timeout );

    ok( status == STATUS_INVALID_HANDLE, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( (HANDLE)0xdeadbeef, (void *)8, 0, &timeout );

    ok( status == STATUS_INVALID_HANDLE, "NtReleaseKeyedEvent %lx\n", status );


    thread = CreateThread( NULL, 0, keyed_event_thread, 0, 0, NULL );

    for (i = 0; i < 20; i++)

    {

        if (i & 1)

            status = pNtReleaseKeyedEvent( handle, (void *)(i * 2), 0, NULL );

        else

            status = pNtWaitForKeyedEvent( handle, (void *)(i * 2), 0, NULL );

        ok( status == STATUS_SUCCESS, "%Ii: failed %lx\n", i, status );

        Sleep( i );

    }

    status = pNtWaitForKeyedEvent( handle, (void *)0x1234, 0, &timeout );

    ok( status == STATUS_SUCCESS, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtWaitForKeyedEvent( handle, (void *)0x5678, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( handle, (void *)0x9abc, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %lx\n", status );


    ok( WaitForSingleObject( thread, 30000 ) == 0, "wait failed\n" );


    NtClose( handle );


    /* test access rights */


    status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_WAIT, &attr, 0 );

    ok( !status, "NtCreateKeyedEvent failed %lx\n", status );

    status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );

    ok( status == STATUS_ACCESS_DENIED, "NtReleaseKeyedEvent %lx\n", status );

    NtClose( handle );


    status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_WAKE, &attr, 0 );

    ok( !status, "NtCreateKeyedEvent failed %lx\n", status );

    status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );

    ok( status == STATUS_ACCESS_DENIED, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %lx\n", status );

    NtClose( handle );


    status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_ALL_ACCESS, &attr, 0 );

    ok( !status, "NtCreateKeyedEvent failed %lx\n", status );

    status = WaitForSingleObject( handle, 1000 );

    ok( status == WAIT_FAILED && GetLastError() == ERROR_ACCESS_DENIED,

        "WaitForSingleObject %lx err %lu\n", status, GetLastError() );

    status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %lx\n", status );

    NtClose( handle );


    /* GENERIC_READ gives wait access */

    status = pNtCreateKeyedEvent( &handle, GENERIC_READ, &attr, 0 );

    ok( !status, "NtCreateKeyedEvent failed %lx\n", status );

    status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );

    ok( status == STATUS_ACCESS_DENIED, "NtReleaseKeyedEvent %lx\n", status );

    NtClose( handle );


    /* GENERIC_WRITE gives wake access */

    status = pNtCreateKeyedEvent( &handle, GENERIC_WRITE, &attr, 0 );

    ok( !status, "NtCreateKeyedEvent failed %lx\n", status );

    status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );

    ok( status == STATUS_ACCESS_DENIED, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );

    ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %lx\n", status );


    /* it's not an event */

    status = pNtPulseEvent( handle, NULL );

    ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtPulseEvent %lx\n", status );


    status = pNtCreateEvent( &event, GENERIC_ALL, &attr, NotificationEvent, FALSE );

    ok( status == STATUS_OBJECT_NAME_COLLISION || status == STATUS_OBJECT_TYPE_MISMATCH /* 7+ */,

        "CreateEvent %lx\n", status );


    NtClose( handle );


    status = pNtCreateEvent( &event, GENERIC_ALL, &attr, NotificationEvent, FALSE );

    ok( status == 0, "CreateEvent %lx\n", status );

    status = pNtWaitForKeyedEvent( event, (void *)8, 0, &timeout );

    ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtWaitForKeyedEvent %lx\n", status );

    status = pNtReleaseKeyedEvent( event, (void *)8, 0, &timeout );

    ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtReleaseKeyedEvent %lx\n", status );

    NtClose( event );

}


static DWORD WINAPI mutant_thread( void *arg )

{

    MUTANT_BASIC_INFORMATION info;

    NTSTATUS status;

    HANDLE mutant;

    DWORD ret;


    mutant = arg;

    ret = WaitForSingleObject( mutant, 1000 );

    ok( ret == WAIT_OBJECT_0, "WaitForSingleObject failed %08lx\n", ret );


    memset(&info, 0xcc, sizeof(info));

    status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08lx\n", status );

    ok( info.CurrentCount == 0, "expected 0, got %ld\n", info.CurrentCount );

    ok( info.OwnedByCaller == TRUE, "expected TRUE, got %d\n", info.OwnedByCaller );

    ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );

    /* abandon mutant */


    return 0;

}


static void test_mutant(void)

{

    MUTANT_BASIC_INFORMATION info;

    OBJECT_ATTRIBUTES attr;

    UNICODE_STRING str;

    NTSTATUS status;

    HANDLE mutant;

    HANDLE thread;

    DWORD ret;

    ULONG len;

    LONG prev;


    pRtlInitUnicodeString(&str, L"\\BaseNamedObjects\\test_mutant");

    InitializeObjectAttributes(&attr, &str, 0, 0, NULL);

    status = pNtCreateMutant(&mutant, GENERIC_ALL, &attr, TRUE);

    ok( status == STATUS_SUCCESS, "Failed to create Mutant(%08lx)\n", status );


    /* bogus */

    status = pNtQueryMutant(mutant, MutantBasicInformation, &info, 0, NULL);

    ok( status == STATUS_INFO_LENGTH_MISMATCH,

        "Failed to NtQueryMutant, expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status );

    status = pNtQueryMutant(mutant, 0x42, &info, sizeof(info), NULL);

    ok( status == STATUS_INVALID_INFO_CLASS || broken(status == STATUS_NOT_IMPLEMENTED), /* 32-bit on Vista/2k8 */

        "Failed to NtQueryMutant, expected STATUS_INVALID_INFO_CLASS, got %08lx\n", status );

    status = pNtQueryMutant((HANDLE)0xdeadbeef, MutantBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_INVALID_HANDLE,

        "Failed to NtQueryMutant, expected STATUS_INVALID_HANDLE, got %08lx\n", status );


    /* new */

    len = -1;

    memset(&info, 0xcc, sizeof(info));

    status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), &len);

    ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08lx\n", status );

    ok( info.CurrentCount == 0, "expected 0, got %ld\n", info.CurrentCount );

    ok( info.OwnedByCaller == TRUE, "expected TRUE, got %d\n", info.OwnedByCaller );

    ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );

    ok( len == sizeof(info), "got %lu\n", len );


    ret = WaitForSingleObject( mutant, 1000 );

    ok( ret == WAIT_OBJECT_0, "WaitForSingleObject failed %08lx\n", ret );


    memset(&info, 0xcc, sizeof(info));

    status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08lx\n", status );

    ok( info.CurrentCount == -1, "expected -1, got %ld\n", info.CurrentCount );

    ok( info.OwnedByCaller == TRUE, "expected TRUE, got %d\n", info.OwnedByCaller );

    ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );


    prev = 0xdeadbeef;

    status = pNtReleaseMutant(mutant, &prev);

    ok( status == STATUS_SUCCESS, "NtReleaseMutant failed %08lx\n", status );

    ok( prev == -1, "NtReleaseMutant failed, expected -1, got %ld\n", prev );


    prev = 0xdeadbeef;

    status = pNtReleaseMutant(mutant, &prev);

    ok( status == STATUS_SUCCESS, "NtReleaseMutant failed %08lx\n", status );

    ok( prev == 0, "NtReleaseMutant failed, expected 0, got %ld\n", prev );


    memset(&info, 0xcc, sizeof(info));

    status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08lx\n", status );

    ok( info.CurrentCount == 1, "expected 1, got %ld\n", info.CurrentCount );

    ok( info.OwnedByCaller == FALSE, "expected FALSE, got %d\n", info.OwnedByCaller );

    ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );


    /* abandoned */

    thread = CreateThread( NULL, 0, mutant_thread, mutant, 0, NULL );

    ret = WaitForSingleObject( thread, 1000 );

    ok( ret == WAIT_OBJECT_0, "WaitForSingleObject failed %08lx\n", ret );

    CloseHandle( thread );


    memset(&info, 0xcc, sizeof(info));

    status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08lx\n", status );

    ok( info.CurrentCount == 1, "expected 0, got %ld\n", info.CurrentCount );

    ok( info.OwnedByCaller == FALSE, "expected FALSE, got %d\n", info.OwnedByCaller );

    ok( info.AbandonedState == TRUE, "expected TRUE, got %d\n", info.AbandonedState );


    ret = WaitForSingleObject( mutant, 1000 );

    ok( ret == WAIT_ABANDONED_0, "WaitForSingleObject failed %08lx\n", ret );


    memset(&info, 0xcc, sizeof(info));

    status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08lx\n", status );

    ok( info.CurrentCount == 0, "expected 0, got %ld\n", info.CurrentCount );

    ok( info.OwnedByCaller == TRUE, "expected TRUE, got %d\n", info.OwnedByCaller );

    ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );


    NtClose( mutant );

}


static void test_semaphore(void)

{

    SEMAPHORE_BASIC_INFORMATION info;

    OBJECT_ATTRIBUTES attr;

    UNICODE_STRING str;

    NTSTATUS status;

    HANDLE semaphore;

    ULONG prev;

    ULONG len;

    DWORD ret;


    pRtlInitUnicodeString(&str, L"\\BaseNamedObjects\\test_semaphore");

    InitializeObjectAttributes(&attr, &str, 0, 0, NULL);


    status = pNtCreateSemaphore(&semaphore, GENERIC_ALL, &attr, 2, 1);

    ok( status == STATUS_INVALID_PARAMETER, "Failed to create Semaphore(%08lx)\n", status );

    status = pNtCreateSemaphore(&semaphore, GENERIC_ALL, &attr, 1, 2);

    ok( status == STATUS_SUCCESS, "Failed to create Semaphore(%08lx)\n", status );


    /* bogus */

    status = pNtQuerySemaphore(semaphore, SemaphoreBasicInformation, &info, 0, NULL);

    ok( status == STATUS_INFO_LENGTH_MISMATCH,

        "Failed to NtQuerySemaphore, expected STATUS_INFO_LENGTH_MISMATCH, got %08lx\n", status );

    status = pNtQuerySemaphore(semaphore, 0x42, &info, sizeof(info), NULL);

    ok( status == STATUS_INVALID_INFO_CLASS,

        "Failed to NtQuerySemaphore, expected STATUS_INVALID_INFO_CLASS, got %08lx\n", status );

    status = pNtQuerySemaphore((HANDLE)0xdeadbeef, SemaphoreBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_INVALID_HANDLE,

        "Failed to NtQuerySemaphore, expected STATUS_INVALID_HANDLE, got %08lx\n", status );


    len = -1;

    memset(&info, 0xcc, sizeof(info));

    status = pNtQuerySemaphore(semaphore, SemaphoreBasicInformation, &info, sizeof(info), &len);

    ok( status == STATUS_SUCCESS, "NtQuerySemaphore failed %08lx\n", status );

    ok( info.CurrentCount == 1, "expected 1, got %ld\n", info.CurrentCount );

    ok( info.MaximumCount == 2, "expected 2, got %ld\n", info.MaximumCount );

    ok( len == sizeof(info), "got %lu\n", len );


    ret = WaitForSingleObject( semaphore, 1000 );

    ok( ret == WAIT_OBJECT_0, "WaitForSingleObject failed %08lx\n", ret );


    memset(&info, 0xcc, sizeof(info));

    status = pNtQuerySemaphore(semaphore, SemaphoreBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_SUCCESS, "NtQuerySemaphore failed %08lx\n", status );

    ok( info.CurrentCount == 0, "expected 0, got %ld\n", info.CurrentCount );

    ok( info.MaximumCount == 2, "expected 2, got %ld\n", info.MaximumCount );


    prev = 0xdeadbeef;

    status = pNtReleaseSemaphore(semaphore, 3, &prev);

    ok( status == STATUS_SEMAPHORE_LIMIT_EXCEEDED, "NtReleaseSemaphore failed %08lx\n", status );

    ok( prev == 0xdeadbeef, "NtReleaseSemaphore failed, expected 0xdeadbeef, got %ld\n", prev );


    prev = 0xdeadbeef;

    status = pNtReleaseSemaphore(semaphore, 1, &prev);

    ok( status == STATUS_SUCCESS, "NtReleaseSemaphore failed %08lx\n", status );

    ok( prev == 0, "NtReleaseSemaphore failed, expected 0, got %ld\n", prev );


    prev = 0xdeadbeef;

    status = pNtReleaseSemaphore(semaphore, 1, &prev);

    ok( status == STATUS_SUCCESS, "NtReleaseSemaphore failed %08lx\n", status );

    ok( prev == 1, "NtReleaseSemaphore failed, expected 1, got %ld\n", prev );


    prev = 0xdeadbeef;

    status = pNtReleaseSemaphore(semaphore, 1, &prev);

    ok( status == STATUS_SEMAPHORE_LIMIT_EXCEEDED, "NtReleaseSemaphore failed %08lx\n", status );

    ok( prev == 0xdeadbeef, "NtReleaseSemaphore failed, expected 0xdeadbeef, got %ld\n", prev );


    memset(&info, 0xcc, sizeof(info));

    status = pNtQuerySemaphore(semaphore, SemaphoreBasicInformation, &info, sizeof(info), NULL);

    ok( status == STATUS_SUCCESS, "NtQuerySemaphore failed %08lx\n", status );

    ok( info.CurrentCount == 2, "expected 2, got %ld\n", info.CurrentCount );

    ok( info.MaximumCount == 2, "expected 2, got %ld\n", info.MaximumCount );


    NtClose( semaphore );

}


static void test_wait_on_address(void)

{

    SIZE_T size;

    NTSTATUS status;

    LARGE_INTEGER start, end, timeout;

    DWORD elapsed;

    LONG64 address, compare;


    if (!pRtlWaitOnAddress)

    {

        win_skip("RtlWaitOnAddress not supported, skipping test\n");

        return;

    }


    if (0) /* crash on Windows */

    {

        pRtlWaitOnAddress(&address, NULL, 8, NULL);

        pRtlWaitOnAddress(NULL, &compare, 8, NULL);

        pRtlWaitOnAddress(NULL, NULL, 8, NULL);

    }


    /* don't crash */

    pRtlWakeAddressSingle(NULL);

    pRtlWakeAddressAll(NULL);


    /* invalid values */

    address = 0;

    compare = 0;

    status = pRtlWaitOnAddress(&address, &compare, 5, NULL);

    ok(status == STATUS_INVALID_PARAMETER, "got %lx\n", status);


    /* values match */

    address = 0;

    compare = 0;

    pNtQuerySystemTime(&start);

    timeout.QuadPart = start.QuadPart + 100 * 10000;

    status = pRtlWaitOnAddress(&address, &compare, 8, &timeout);

    pNtQuerySystemTime(&end);

    ok(status == STATUS_TIMEOUT, "got 0x%08lx\n", status);

    elapsed = (end.QuadPart - start.QuadPart) / 10000;

    ok(90 <= elapsed && elapsed <= 900, "timed out in %lu ms\n", elapsed);

    ok(address == 0, "got %s\n", wine_dbgstr_longlong(address));

    ok(compare == 0, "got %s\n", wine_dbgstr_longlong(compare));


    /* different address size */

    for (size = 1; size <= 4; size <<= 1)

    {

        compare = ~0;

        compare <<= size * 8;


        pNtQuerySystemTime(&start);

        timeout.QuadPart = -100 * 10000;

        status = pRtlWaitOnAddress(&address, &compare, size, &timeout);

        pNtQuerySystemTime(&end);

        ok(status == STATUS_TIMEOUT, "got 0x%08lx\n", status);

        elapsed = (end.QuadPart - start.QuadPart) / 10000;

        ok(90 <= elapsed && elapsed <= 900, "timed out in %lu ms\n", elapsed);


        status = pRtlWaitOnAddress(&address, &compare, size << 1, &timeout);

        ok(!status, "got 0x%08lx\n", status);

    }

    address = 0;

    compare = 1;

    status = pRtlWaitOnAddress(&address, &compare, 8, NULL);

    ok(!status, "got 0x%08lx\n", status);


    /* no waiters */

    address = 0;

    pRtlWakeAddressSingle(&address);

    ok(address == 0, "got %s\n", wine_dbgstr_longlong(address));

    pRtlWakeAddressAll(&address);

    ok(address == 0, "got %s\n", wine_dbgstr_longlong(address));

}


static HANDLE thread_ready, thread_done;


static DWORD WINAPI resource_shared_thread(void *arg)

{

    RTL_RWLOCK *resource = arg;

    BOOLEAN ret;


    ret = pRtlAcquireResourceShared(resource, TRUE);

    ok(ret == TRUE, "got %u\n", ret);


    SetEvent(thread_ready);

    ok(!WaitForSingleObject(thread_done, 1000), "wait failed\n");

    pRtlReleaseResource(resource);

    return 0;

}


static DWORD WINAPI resource_exclusive_thread(void *arg)

{

    RTL_RWLOCK *resource = arg;

    BOOLEAN ret;


    ret = pRtlAcquireResourceExclusive(resource, TRUE);

    ok(ret == TRUE, "got %u\n", ret);


    SetEvent(thread_ready);

    ok(!WaitForSingleObject(thread_done, 1000), "wait failed\n");

    pRtlReleaseResource(resource);

    return 0;

}


static void test_resource(void)

{

    HANDLE thread, thread2;

    RTL_RWLOCK resource;

    BOOLEAN ret;


    pRtlInitializeResource(&resource);

    thread_ready = CreateEventA(NULL, FALSE, FALSE, NULL);

    thread_done = CreateEventA(NULL, FALSE, FALSE, NULL);


    ret = pRtlAcquireResourceShared(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    ret = pRtlAcquireResourceShared(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    ret = pRtlAcquireResourceExclusive(&resource, FALSE);

    ok(ret == FALSE, "got %u\n", ret);

    pRtlReleaseResource(&resource);

    pRtlReleaseResource(&resource);


    ret = pRtlAcquireResourceExclusive(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    ret = pRtlAcquireResourceExclusive(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    ret = pRtlAcquireResourceShared(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    pRtlReleaseResource(&resource);

    pRtlReleaseResource(&resource);

    pRtlReleaseResource(&resource);


    /* Do not acquire the resource ourselves, but spawn a shared thread holding it. */


    thread = CreateThread(NULL, 0, resource_shared_thread, &resource, 0, NULL);

    ok(!WaitForSingleObject(thread_ready, 1000), "wait failed\n");


    ret = pRtlAcquireResourceExclusive(&resource, FALSE);

    ok(ret == FALSE, "got %u\n", ret);

    ret = pRtlAcquireResourceShared(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    pRtlReleaseResource(&resource);


    SetEvent(thread_done);

    ok(!WaitForSingleObject(thread, 1000), "wait failed\n");

    CloseHandle(thread);


    ret = pRtlAcquireResourceExclusive(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    pRtlReleaseResource(&resource);

    ret = pRtlAcquireResourceShared(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    pRtlReleaseResource(&resource);


    /* Acquire the resource as exclusive, and then spawn a shared thread. */


    ret = pRtlAcquireResourceExclusive(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    thread = CreateThread(NULL, 0, resource_shared_thread, &resource, 0, NULL);

    ok(WaitForSingleObject(thread_ready, 100) == WAIT_TIMEOUT, "expected timeout\n");


    ret = pRtlAcquireResourceExclusive(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    pRtlReleaseResource(&resource);

    ret = pRtlAcquireResourceShared(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    pRtlReleaseResource(&resource);


    pRtlReleaseResource(&resource);

    ok(!WaitForSingleObject(thread_ready, 1000), "wait failed\n");

    SetEvent(thread_done);

    ok(!WaitForSingleObject(thread, 1000), "wait failed\n");

    CloseHandle(thread);


    /* Acquire the resource as shared, and then spawn an exclusive thread. */


    ret = pRtlAcquireResourceShared(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    thread = CreateThread(NULL, 0, resource_exclusive_thread, &resource, 0, NULL);

    ok(WaitForSingleObject(thread_ready, 100) == WAIT_TIMEOUT, "expected timeout\n");


    ret = pRtlAcquireResourceExclusive(&resource, FALSE);

    ok(ret == FALSE, "got %u\n", ret);

    ret = pRtlAcquireResourceShared(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    pRtlReleaseResource(&resource);


    pRtlReleaseResource(&resource);

    ok(!WaitForSingleObject(thread_ready, 1000), "wait failed\n");

    SetEvent(thread_done);

    ok(!WaitForSingleObject(thread, 1000), "wait failed\n");

    CloseHandle(thread);


    /* Spawn a shared and then exclusive waiter. */

    thread = CreateThread(NULL, 0, resource_shared_thread, &resource, 0, NULL);

    ok(!WaitForSingleObject(thread_ready, 1000), "wait failed\n");

    thread2 = CreateThread(NULL, 0, resource_exclusive_thread, &resource, 0, NULL);

    ok(WaitForSingleObject(thread_ready, 100) == WAIT_TIMEOUT, "expected timeout\n");


    ret = pRtlAcquireResourceExclusive(&resource, FALSE);

    ok(ret == FALSE, "got %u\n", ret);

    ret = pRtlAcquireResourceShared(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    pRtlReleaseResource(&resource);


    SetEvent(thread_done);

    ok(!WaitForSingleObject(thread, 1000), "wait failed\n");

    CloseHandle(thread);


    ok(!WaitForSingleObject(thread_ready, 1000), "wait failed\n");

    SetEvent(thread_done);

    ok(!WaitForSingleObject(thread2, 1000), "wait failed\n");

    CloseHandle(thread2);


    ret = pRtlAcquireResourceExclusive(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    pRtlReleaseResource(&resource);

    ret = pRtlAcquireResourceShared(&resource, FALSE);

    ok(ret == TRUE, "got %u\n", ret);

    pRtlReleaseResource(&resource);


    CloseHandle(thread_ready);

    CloseHandle(thread_done);

    pRtlDeleteResource(&resource);

}


static DWORD WINAPI tid_alert_thread( void *arg )

{

    NTSTATUS ret;


    ret = pNtAlertThreadByThreadId( arg );

    ok(!ret, "got %#lx\n", ret);


    ret = pNtWaitForAlertByThreadId( (void *)0x123, NULL );

    ok(ret == STATUS_ALERTED, "got %#lx\n", ret);


    return 0;

}


static void test_tid_alert( char **argv )

{

    LARGE_INTEGER timeout = {{0}};

    char cmdline[MAX_PATH];

    STARTUPINFOA si = {0};

    PROCESS_INFORMATION pi;

    HANDLE thread;

    NTSTATUS ret;

    DWORD tid;


    if (!pNtWaitForAlertByThreadId)

    {

        win_skip("NtWaitForAlertByThreadId is not available\n");

        return;

    }


    ret = pNtWaitForAlertByThreadId( (void *)0x123, &timeout );

    ok(ret == STATUS_TIMEOUT, "got %#lx\n", ret);


    ret = pNtAlertThreadByThreadId( 0 );

    ok(ret == STATUS_INVALID_CID, "got %#lx\n", ret);


    ret = pNtAlertThreadByThreadId( (HANDLE)0xdeadbeef );

    ok(ret == STATUS_INVALID_CID, "got %#lx\n", ret);


    ret = pNtAlertThreadByThreadId( (HANDLE)(DWORD_PTR)GetCurrentThreadId() );

    ok(!ret, "got %#lx\n", ret);


    ret = pNtAlertThreadByThreadId( (HANDLE)(DWORD_PTR)GetCurrentThreadId() );

    ok(!ret, "got %#lx\n", ret);


    ret = pNtWaitForAlertByThreadId( (void *)0x123, &timeout );

    ok(ret == STATUS_ALERTED, "got %#lx\n", ret);


    ret = pNtWaitForAlertByThreadId( (void *)0x123, &timeout );

    ok(ret == STATUS_TIMEOUT, "got %#lx\n", ret);


    ret = pNtWaitForAlertByThreadId( (void *)0x321, &timeout );

    ok(ret == STATUS_TIMEOUT, "got %#lx\n", ret);


    thread = CreateThread( NULL, 0, tid_alert_thread, (HANDLE)(DWORD_PTR)GetCurrentThreadId(), 0, &tid );

    timeout.QuadPart = -1000 * 10000;

    ret = pNtWaitForAlertByThreadId( (void *)0x123, &timeout );

    ok(ret == STATUS_ALERTED, "got %#lx\n", ret);


    ret = WaitForSingleObject( thread, 100 );

    ok(ret == WAIT_TIMEOUT, "got %ld\n", ret);

    ret = pNtAlertThreadByThreadId( (HANDLE)(DWORD_PTR)tid );

    ok(!ret, "got %#lx\n", ret);


    ret = WaitForSingleObject( thread, 1000 );

    ok(!ret, "got %ld\n", ret);


    ret = pNtAlertThreadByThreadId( (HANDLE)(DWORD_PTR)tid );

    ok(!ret, "got %#lx\n", ret);


    CloseHandle(thread);


    sprintf( cmdline, "%s %s subprocess", argv[0], argv[1] );

    ret = CreateProcessA( NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi );

    ok(ret, "failed to create process, error %lu\n", GetLastError());

    ret = pNtAlertThreadByThreadId( (HANDLE)(DWORD_PTR)pi.dwThreadId );

    todo_wine ok(ret == STATUS_ACCESS_DENIED, "got %#lx\n", ret);

    ok(!WaitForSingleObject( pi.hProcess, 1000 ), "wait failed\n");

    CloseHandle( pi.hProcess );

    CloseHandle( pi.hThread );

}


struct test_completion_port_scheduling_param

{

    HANDLE ready, test_ready;

    HANDLE port;

    int index;

};


static DWORD WINAPI test_completion_port_scheduling_thread(void *param)

{

    struct test_completion_port_scheduling_param *p = param;

    FILE_IO_COMPLETION_INFORMATION info;

    OVERLAPPED_ENTRY overlapped_entry;

    OVERLAPPED *overlapped;

    IO_STATUS_BLOCK iosb;

    ULONG_PTR key, value;

    NTSTATUS status;

    DWORD ret, err;

    ULONG count;

    BOOL bret;


    /* both threads are woken when comleption added. */

    ret = WaitForSingleObject( p->ready, INFINITE );

    ok( ret == WAIT_OBJECT_0, "got %#lx.\n", ret );

    ret = WaitForSingleObject( p->port, INFINITE );

    ok( ret == WAIT_OBJECT_0, "got %#lx.\n", ret );

    SetEvent( p->test_ready );


    /* if a thread is waiting for completion which is added threads which wait on port handle are not woken. */

    ret = WaitForSingleObject( p->ready, INFINITE );

    if (p->index)

    {

        bret = GetQueuedCompletionStatus( p->port, &count, &key, &overlapped, INFINITE );

        ok( bret, "got error %lu.\n", GetLastError() );

    }

    else

    {

        ret = WaitForSingleObject( p->port, 100 );

        ok( ret == WAIT_TIMEOUT || broken( !ret ) /* before Win10 1607 */, "got %#lx.\n", ret );

    }

    SetEvent( p->test_ready );


    /* Two threads in GetQueuedCompletionStatus, the second is supposed to start first. */

    ret = WaitForSingleObject( p->ready, INFINITE );

    ok( ret == WAIT_OBJECT_0, "got %#lx.\n", ret );

    bret = GetQueuedCompletionStatus( p->port, &count, &key, &overlapped, INFINITE );

    ok( bret, "got error %lu.\n", GetLastError() );

    ok( key == 3 + p->index || broken( p->index && key == 5 ) /* before Win10 */, "got %Iu, expected %u.\n", key, 3 + p->index );

    SetEvent( p->test_ready );


    /* Port is being closed. */

    ret = WaitForSingleObject( p->ready, INFINITE );

    ret = WaitForSingleObject( p->port, INFINITE );

    if (ret == WAIT_FAILED)

        skip( "Handle closed before wait started.\n" );

    else

        ok( ret == WAIT_OBJECT_0, "got %#lx.\n", ret );

    SetEvent( p->test_ready );


    /* Port is being closed. */

    ret = WaitForSingleObject( p->ready, INFINITE );

    ok( ret == WAIT_OBJECT_0, "got %#lx.\n", ret );

    SetEvent( p->test_ready );

    status = NtRemoveIoCompletion( p->port, &key, &value, &iosb, NULL );

    if (status == STATUS_INVALID_HANDLE)

        skip( "Handle closed before wait started.\n" );

    else

        ok( status == STATUS_ABANDONED_WAIT_0, "got %#lx.\n", status );


    /* Port is being closed. */

    ret = WaitForSingleObject( p->ready, INFINITE );

    ok( ret == WAIT_OBJECT_0, "got %#lx.\n", ret );

    SetEvent( p->test_ready );

    count = 0xdeadbeef;

    status = NtRemoveIoCompletionEx( p->port, &info, 1, &count, NULL, FALSE );

    ok( count <= 1, "Got unexpected count %lu.\n", count );

    if (status == STATUS_INVALID_HANDLE)

        skip( "Handle closed before wait started.\n" );

    else

        ok( status == STATUS_ABANDONED_WAIT_0, "got %#lx.\n", status );


    /* Port is being closed. */

    ret = WaitForSingleObject( p->ready, INFINITE );

    ok( ret == WAIT_OBJECT_0, "got %#lx.\n", ret );

    SetEvent( p->test_ready );

    bret = GetQueuedCompletionStatus( p->port, &count, &key, &overlapped, INFINITE );

    err = GetLastError();

    ok( !bret, "got %d.\n", bret );

    if (err == ERROR_INVALID_HANDLE)

        skip( "Handle closed before wait started.\n" );

    else

        ok( err == ERROR_ABANDONED_WAIT_0, "got error %#lx.\n", err );


#if !defined (__REACTOS__) || (DLL_EXPORT_VERSION >= 0x601)

    /* Port is being closed. */

    ret = WaitForSingleObject( p->ready, INFINITE );

    ok( ret == WAIT_OBJECT_0, "got %#lx.\n", ret );

    SetEvent( p->test_ready );

    bret = GetQueuedCompletionStatusEx( p->port, &overlapped_entry, 1, &count, INFINITE, TRUE );

    err = GetLastError();

    ok( !bret, "got %d.\n", bret );

    if (err == ERROR_INVALID_HANDLE)

        skip( "Handle closed before wait started.\n" );

    else

        ok( err == ERROR_ABANDONED_WAIT_0, "got error %#lx.\n", err );

#endif


    return 0;

}


static void test_completion_port_scheduling(void)

{

    struct test_completion_port_scheduling_param p[2];

    HANDLE threads[2], port;

    OVERLAPPED *overlapped;

    unsigned int i, j;

    DWORD ret, count;

    NTSTATUS status;

    ULONG_PTR key;

    BOOL bret;


#if defined(__REACTOS__)

    if ((GetNTVersion() < _WIN32_WINNT_WIN7) || is_reactos())

    {

        skip("Skipping completion port scheduling test, because it hangs on Windows 2003, Vista and ReactOS\n");

        return;

    }

#endif


    for (i = 0; i < 2; ++i)

    {

        p[i].index = 0;

        p[i].ready = CreateEventA(NULL, FALSE, FALSE, NULL);

        p[i].test_ready = CreateEventA(NULL, FALSE, FALSE, NULL);

        threads[i] = CreateThread( NULL, 0, test_completion_port_scheduling_thread, &p[i], 0, NULL );

        ok( !!threads[i], "got error %lu.\n", GetLastError() );

    }


    status = NtCreateIoCompletion( &port, IO_COMPLETION_ALL_ACCESS, NULL, 0 );

    ok( !status, "got %#lx.\n", status );

    /* Waking multiple threads directly waiting on port */

    for (i = 0; i < 2; ++i)

    {

        p[i].index = i;

        p[i].port = port;

        SetEvent( p[i].ready );

    }

    PostQueuedCompletionStatus( port, 0, 1, NULL );

    for (i = 0; i < 2; ++i) WaitForSingleObject( p[i].test_ready, INFINITE );

    bret = GetQueuedCompletionStatus( port, &count, &key, &overlapped, INFINITE );

    ok( bret, "got error %lu.\n", GetLastError() );


    /* One thread is waiting on port, another in GetQueuedCompletionStatus(). */

    SetEvent( p[1].ready );

    Sleep( 40 );

    SetEvent( p[0].ready );

    Sleep( 10 );

    PostQueuedCompletionStatus( port, 0, 2, NULL );

    for (i = 0; i < 2; ++i) WaitForSingleObject( p[i].test_ready, INFINITE );


    /* Both threads are waiting in GetQueuedCompletionStatus, LIFO wake up order. */

    SetEvent( p[1].ready );

    Sleep( 40 );

    SetEvent( p[0].ready );

    Sleep( 20 );

    PostQueuedCompletionStatus( port, 0, 3, NULL );

    PostQueuedCompletionStatus( port, 0, 4, NULL );

    PostQueuedCompletionStatus( port, 0, 5, NULL );

    bret = GetQueuedCompletionStatus( p->port, &count, &key, &overlapped, INFINITE );

    ok( bret, "got error %lu.\n", GetLastError() );

    ok( key == 5 || broken( key == 4 ) /* before Win10 */, "got %Iu, expected 5.\n", key );


    /* Close port handle while threads are waiting on it directly. */

    for (i = 0; i < 2; ++i) SetEvent( p[i].ready );

    Sleep( 20 );

    NtClose( port );

    for (i = 0; i < 2; ++i) WaitForSingleObject( p[i].test_ready, INFINITE );


    /* Test signaling on port close. */

    for (i = 0; i < 4; ++i)

    {

        status = NtCreateIoCompletion( &port, IO_COMPLETION_ALL_ACCESS, NULL, 0 );

        ok( !status, "got %#lx.\n", status );

        for (j = 0; j < 2; ++j)

        {

            p[j].port = port;

            ret = SignalObjectAndWait( p[j].ready, p[j].test_ready,

                                       INFINITE, FALSE );

            ok( ret == WAIT_OBJECT_0, "got %#lx.\n", ret );

        }

        Sleep( 20 );

        status = NtClose( port );

        ok( !status, "got %#lx.\n", status );

    }


    WaitForMultipleObjects( 2, threads, TRUE, INFINITE );

    for (i = 0; i < 2; ++i)

    {

        CloseHandle( threads[i] );

        CloseHandle( p[i].ready );

        CloseHandle( p[i].test_ready );

    }

}


START_TEST(sync)

{

    HMODULE module = GetModuleHandleA("ntdll.dll");

    char **argv;

    int argc;


    argc = winetest_get_mainargs( &argv );


    if (argc > 2) return;


    pNtAlertThreadByThreadId        = (void *)GetProcAddress(module, "NtAlertThreadByThreadId");

    pNtClose                        = (void *)GetProcAddress(module, "NtClose");

    pNtCreateEvent                  = (void *)GetProcAddress(module, "NtCreateEvent");

    pNtCreateKeyedEvent             = (void *)GetProcAddress(module, "NtCreateKeyedEvent");

    pNtCreateMutant                 = (void *)GetProcAddress(module, "NtCreateMutant");

    pNtCreateSemaphore              = (void *)GetProcAddress(module, "NtCreateSemaphore");

    pNtOpenEvent                    = (void *)GetProcAddress(module, "NtOpenEvent");

    pNtOpenKeyedEvent               = (void *)GetProcAddress(module, "NtOpenKeyedEvent");

    pNtPulseEvent                   = (void *)GetProcAddress(module, "NtPulseEvent");

    pNtQueryEvent                   = (void *)GetProcAddress(module, "NtQueryEvent");

    pNtQueryMutant                  = (void *)GetProcAddress(module, "NtQueryMutant");

    pNtQuerySemaphore               = (void *)GetProcAddress(module, "NtQuerySemaphore");

    pNtQuerySystemTime              = (void *)GetProcAddress(module, "NtQuerySystemTime");

    pNtReleaseKeyedEvent            = (void *)GetProcAddress(module, "NtReleaseKeyedEvent");

    pNtReleaseMutant                = (void *)GetProcAddress(module, "NtReleaseMutant");

    pNtReleaseSemaphore             = (void *)GetProcAddress(module, "NtReleaseSemaphore");

    pNtResetEvent                   = (void *)GetProcAddress(module, "NtResetEvent");

    pNtSetEvent                     = (void *)GetProcAddress(module, "NtSetEvent");

    pNtWaitForAlertByThreadId       = (void *)GetProcAddress(module, "NtWaitForAlertByThreadId");

    pNtWaitForKeyedEvent            = (void *)GetProcAddress(module, "NtWaitForKeyedEvent");

    pRtlAcquireResourceExclusive    = (void *)GetProcAddress(module, "RtlAcquireResourceExclusive");

    pRtlAcquireResourceShared       = (void *)GetProcAddress(module, "RtlAcquireResourceShared");

    pRtlDeleteResource              = (void *)GetProcAddress(module, "RtlDeleteResource");

    pRtlInitializeResource          = (void *)GetProcAddress(module, "RtlInitializeResource");

    pRtlInitUnicodeString           = (void *)GetProcAddress(module, "RtlInitUnicodeString");

    pRtlReleaseResource             = (void *)GetProcAddress(module, "RtlReleaseResource");

    pRtlWaitOnAddress               = (void *)GetProcAddress(module, "RtlWaitOnAddress");

    pRtlWakeAddressAll              = (void *)GetProcAddress(module, "RtlWakeAddressAll");

    pRtlWakeAddressSingle           = (void *)GetProcAddress(module, "RtlWakeAddressSingle");


    test_wait_on_address();

    test_event();

    test_mutant();

    test_semaphore();

    test_keyed_events();

    test_resource();

    test_tid_alert( argv );

    test_completion_port_scheduling();

}

compare
#define compare
Definition: CShellDesktop.cpp:45

BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127

GetNTVersion
#define GetNTVersion()
Definition: apitest.h:17

ok
#define ok(value,...)
Definition: atltest.h:57

skip
#define skip(...)
Definition: atltest.h:64

broken
#define broken(x)
Definition: atltest.h:178

START_TEST
#define START_TEST(x)
Definition: atltest.h:75

NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26

thread
static HANDLE thread
Definition: service.c:33

STATUS_TIMEOUT
#define STATUS_TIMEOUT
Definition: d3dkmdt.h:49

STATUS_INVALID_HANDLE
#define STATUS_INVALID_HANDLE
Definition: d3dkmdt.h:40

STATUS_NOT_IMPLEMENTED
#define STATUS_NOT_IMPLEMENTED
Definition: d3dkmdt.h:42

STATUS_OBJECT_TYPE_MISMATCH
#define STATUS_OBJECT_TYPE_MISMATCH
Definition: d3dkmdt.h:46

WAIT_TIMEOUT
#define WAIT_TIMEOUT
Definition: dderror.h:14

NULL
#define NULL
Definition: types.h:112

TRUE
#define TRUE
Definition: types.h:120

FALSE
#define FALSE
Definition: types.h:117

NTSTATUS
#define NTSTATUS
Definition: precomp.h:19

CloseHandle
#define CloseHandle
Definition: compat.h:739

GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753

wine_dbgstr_longlong
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49

GENERIC_READ
#define GENERIC_READ
Definition: compat.h:135

MAX_PATH
#define MAX_PATH
Definition: compat.h:34

ERROR_INVALID_HANDLE
#define ERROR_INVALID_HANDLE
Definition: compat.h:98

ERROR_ACCESS_DENIED
#define ERROR_ACCESS_DENIED
Definition: compat.h:97

GetModuleHandleA
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812

CreateThread
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137

CreateProcessA
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessA(const char *app_name, char *cmd_line, SECURITY_ATTRIBUTES *process_attr, SECURITY_ATTRIBUTES *thread_attr, BOOL inherit, DWORD flags, void *env, const char *cur_dir, STARTUPINFOA *startup_info, PROCESS_INFORMATION *info)
Definition: process.c:686

CreateEventA
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventA(SECURITY_ATTRIBUTES *sa, BOOL manual_reset, BOOL initial_state, LPCSTR name)
Definition: sync.c:510

SignalObjectAndWait
DWORD WINAPI DECLSPEC_HOTPATCH SignalObjectAndWait(HANDLE signal, HANDLE wait, DWORD timeout, BOOL alertable)
Definition: sync.c:309

Sleep
void WINAPI DECLSPEC_HOTPATCH Sleep(DWORD timeout)
Definition: sync.c:330

SetEvent
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(HANDLE handle)
Definition: sync.c:637

GetQueuedCompletionStatusEx
BOOL WINAPI DECLSPEC_HOTPATCH GetQueuedCompletionStatusEx(HANDLE port, OVERLAPPED_ENTRY *entries, ULONG count, ULONG *written, DWORD timeout, BOOL alertable)
Definition: sync.c:1209

WaitForMultipleObjects
DWORD WINAPI DECLSPEC_HOTPATCH WaitForMultipleObjects(DWORD count, const HANDLE *handles, BOOL wait_all, DWORD timeout)
Definition: sync.c:382

PostQueuedCompletionStatus
BOOL WINAPI DECLSPEC_HOTPATCH PostQueuedCompletionStatus(HANDLE port, DWORD count, ULONG_PTR key, LPOVERLAPPED overlapped)
Definition: sync.c:1232

WaitForSingleObject
DWORD WINAPI DECLSPEC_HOTPATCH WaitForSingleObject(HANDLE handle, DWORD timeout)
Definition: sync.c:364

GetQueuedCompletionStatus
BOOL WINAPI DECLSPEC_HOTPATCH GetQueuedCompletionStatus(HANDLE port, LPDWORD count, PULONG_PTR key, LPOVERLAPPED *overlapped, DWORD timeout)
Definition: sync.c:1180

argc
MonoAssembly int argc
Definition: metahost.c:107

port
USHORT port
Definition: uri.c:228

ret
return ret
Definition: mutex.c:146

L
#define L(x)
Definition: resources.c:13

INFINITE
#define INFINITE
Definition: serial.h:102

BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94

DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95

start
GLuint start
Definition: gl.h:1545

count
GLuint GLuint GLsizei count
Definition: gl.h:1545

end
GLuint GLuint end
Definition: gl.h:1545

event
struct _cl_event * event
Definition: glext.h:7739

address
GLuint address
Definition: glext.h:9393

size
GLsizeiptr size
Definition: glext.h:5919

p
GLfloat GLfloat p
Definition: glext.h:8902

param
GLfloat param
Definition: glext.h:5796

len
GLenum GLsizei len
Definition: glext.h:6722

i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248

j
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250

tid
static TfClientId tid
Definition: inputprocessor.c:40

void
Definition: nsiface.idl:2307

NtRemoveIoCompletion
NTSTATUS NTAPI NtRemoveIoCompletion(IN HANDLE IoCompletionHandle, OUT PVOID *KeyContext, OUT PVOID *ApcContext, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: iocomp.c:445

NtCreateIoCompletion
NTSTATUS NTAPI NtCreateIoCompletion(OUT PHANDLE IoCompletionHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN ULONG NumberOfConcurrentThreads)
Definition: iocomp.c:253

resource
#define resource
Definition: kernel32.h:9

win_skip
#define win_skip
Definition: minitest.h:67

todo_wine
#define todo_wine
Definition: minitest.h:80

sprintf
#define sprintf
Definition: sprintf.c:45

thread2
DWORD WINAPI thread2(LPVOID crap)
Definition: mutex.c:57

pi
static PROCESS_INFORMATION pi
Definition: debugger.c:2303

semaphore
static HANDLE semaphore
Definition: loader.c:2947

threads
static HANDLE ULONG_PTR DWORD threads
Definition: process.c:83

ULONG
static ULONG
Definition: sync.c:47

test_semaphore
static void test_semaphore(void)
Definition: sync.c:667

BOOLEAN
static BOOLEAN
Definition: sync.c:61

test_event
static void test_event(void)
Definition: sync.c:514

si
static SYSTEM_INFO si
Definition: virtual.c:39

IO_COMPLETION_ALL_ACCESS
#define IO_COMPLETION_ALL_ACCESS
Definition: file.c:43

iosb
static PIO_STATUS_BLOCK iosb
Definition: file.c:70

InitializeObjectAttributes
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:115

LONG
static const OBJECT_ATTRIBUTES LONG
Definition: sync.c:57

thread_ready
static HANDLE thread_ready
Definition: sync.c:629

keyed_nameW
static const WCHAR keyed_nameW[]
Definition: sync.c:173

test_completion_port_scheduling
static void test_completion_port_scheduling(void)
Definition: sync.c:972

test_resource
static void test_resource(void)
Definition: sync.c:659

EVENT_INFORMATION_CLASS
static const OBJECT_ATTRIBUTES *static const OBJECT_ATTRIBUTES *static LONG *static EVENT_INFORMATION_CLASS
Definition: sync.c:61

tid_alert_thread
static DWORD WINAPI tid_alert_thread(void *arg)
Definition: sync.c:782

thread_done
static HANDLE thread_done
Definition: sync.c:629

KEYEDEVENT_WAIT
#define KEYEDEVENT_WAIT
Definition: sync.c:82

KEYEDEVENT_ALL_ACCESS
#define KEYEDEVENT_ALL_ACCESS
Definition: sync.c:84

resource_shared_thread
static DWORD WINAPI resource_shared_thread(void *arg)
Definition: sync.c:631

KEYEDEVENT_WAKE
#define KEYEDEVENT_WAKE
Definition: sync.c:83

EVENT_TYPE
static const OBJECT_ATTRIBUTES EVENT_TYPE
Definition: sync.c:54

test_tid_alert
static void test_tid_alert(char **argv)
Definition: sync.c:795

SEMAPHORE_INFORMATION_CLASS
static const OBJECT_ATTRIBUTES *static const OBJECT_ATTRIBUTES *static LONG *static void ULONG *static void ULONG *static SEMAPHORE_INFORMATION_CLASS
Definition: sync.c:63

test_mutant
static void test_mutant(void)
Definition: sync.c:388

SIZE_T
static const void SIZE_T
Definition: sync.c:78

resource_exclusive_thread
static DWORD WINAPI resource_exclusive_thread(void *arg)
Definition: sync.c:645

keyed_event_thread
static DWORD WINAPI keyed_event_thread(void *arg)
Definition: sync.c:175

MUTANT_INFORMATION_CLASS
static const OBJECT_ATTRIBUTES *static const OBJECT_ATTRIBUTES *static LONG *static void ULONG *static MUTANT_INFORMATION_CLASS
Definition: sync.c:62

test_keyed_events
static void test_keyed_events(void)
Definition: sync.c:218

mutant_thread
static DWORD WINAPI mutant_thread(void *arg)
Definition: sync.c:366

test_wait_on_address
static void test_wait_on_address(void)
Definition: sync.c:555

ACCESS_MASK
static ACCESS_MASK
Definition: sync.c:54

test_completion_port_scheduling_thread
static DWORD WINAPI test_completion_port_scheduling_thread(void *param)
Definition: sync.c:870

argv
#define argv
Definition: mplay32.c:18

Alertable
_In_ PVOID _In_ BOOLEAN Alertable
Definition: exfuncs.h:453

SemaphoreBasicInformation
@ SemaphoreBasicInformation
Definition: extypes.h:520

MutantBasicInformation
@ MutantBasicInformation
Definition: extypes.h:494

EventBasicInformation
@ EventBasicInformation
Definition: extypes.h:528

_Out_
#define _Out_
Definition: no_sal2.h:160

_In_
#define _In_
Definition: no_sal2.h:158

_In_opt_
#define _In_opt_
Definition: no_sal2.h:212

_Out_writes_to_
#define _Out_writes_to_(s, c)
Definition: no_sal2.h:188

Count
int Count
Definition: noreturn.cpp:7

SYNCHRONIZE
#define SYNCHRONIZE
Definition: nt_native.h:61

RtlInitUnicodeString
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)

GENERIC_ALL
#define GENERIC_ALL
Definition: nt_native.h:92

NtClose
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402

GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90

NotificationEvent
@ NotificationEvent
Definition: ntdef.template.h:365

SynchronizationEvent
@ SynchronizationEvent
Definition: ntdef.template.h:366

IoStatusBlock
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:100

PHANDLE
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:455

ntstatus.h

STATUS_ALERTED
#define STATUS_ALERTED
Definition: ntstatus.h:133

STATUS_INVALID_CID
#define STATUS_INVALID_CID
Definition: ntstatus.h:341

STATUS_SEMAPHORE_LIMIT_EXCEEDED
#define STATUS_SEMAPHORE_LIMIT_EXCEEDED
Definition: ntstatus.h:401

STATUS_INVALID_INFO_CLASS
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:333

STATUS_INVALID_PARAMETER_1
#define STATUS_INVALID_PARAMETER_1
Definition: ntstatus.h:569

STATUS_ABANDONED_WAIT_0
#define STATUS_ABANDONED_WAIT_0
Definition: ntstatus.h:128

WCHAR
short WCHAR
Definition: pedump.c:58

LONG
long LONG
Definition: pedump.c:60

Timeout
static ULONG Timeout
Definition: ping.c:61

err
#define err(...)
Definition: reactos_support_code.h:30

str
const WCHAR * str
Definition: rpc_transport.c:2696

test.h

winetest_get_mainargs
int winetest_get_mainargs(char ***pargv)

memset
#define memset(x, y, z)
Definition: compat.h:39

_WIN32_WINNT_WIN7
#define _WIN32_WINNT_WIN7
Definition: sdkddkver.h:28

STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65

overlapped
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED * overlapped
Definition: sock.c:81

cmdline
TCHAR * cmdline
Definition: stretchblt.cpp:32

_EVENT_BASIC_INFORMATION
Definition: extypes.h:901

_FILE_IO_COMPLETION_INFORMATION
Definition: winternl.h:3788

_IO_STATUS_BLOCK
Definition: env_spec_w32.h:870

_MUTANT_BASIC_INFORMATION
Definition: extypes.h:851

_OBJECT_ATTRIBUTES
Definition: umtypes.h:184

_OVERLAPPED_ENTRY
Definition: minwinbase.h:234

_OVERLAPPED
Definition: minwinbase.h:218

_PROCESS_INFORMATION
Definition: processthreadsapi.h:65

_PROCESS_INFORMATION::hThread
HANDLE hThread
Definition: processthreadsapi.h:67

_PROCESS_INFORMATION::hProcess
HANDLE hProcess
Definition: processthreadsapi.h:66

_PROCESS_INFORMATION::dwThreadId
DWORD dwThreadId
Definition: processthreadsapi.h:69

_RTL_RWLOCK
Definition: winternl.h:2804

_SEMAPHORE_BASIC_INFORMATION
Definition: extypes.h:892

_STARTUPINFOA
Definition: processthreadsapi.h:15

_UNICODE_STRING
Definition: env_spec_w32.h:368

attr
Definition: cookie.c:202

compare
Definition: bug.cpp:8

handle
Definition: rpc_generic.c:61

info
Definition: notification.c:70

key
Definition: copy.c:22

module
Definition: dbghelp_private.h:377

resource
Definition: utils.c:168

status
Definition: ps.c:97

test_completion_port_scheduling_param
Definition: sync.c:864

test_completion_port_scheduling_param::port
HANDLE port
Definition: sync.c:866

test_completion_port_scheduling_param::test_ready
HANDLE test_ready
Definition: sync.c:865

test_completion_port_scheduling_param::index
int index
Definition: sync.c:867

test_completion_port_scheduling_param::ready
HANDLE ready
Definition: sync.c:865

timeout
Definition: dhcpd.h:248

PULONG
uint32_t * PULONG
Definition: typedefs.h:59

LONG64
int64_t LONG64
Definition: typedefs.h:68

DWORD_PTR
uint32_t DWORD_PTR
Definition: typedefs.h:65

HANDLE
PVOID HANDLE
Definition: typedefs.h:73

SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80

ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65

ULONG
uint32_t ULONG
Definition: typedefs.h:59

STATUS_ACCESS_DENIED
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145

STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135

STATUS_OBJECT_NAME_COLLISION
#define STATUS_OBJECT_NAME_COLLISION
Definition: udferr_usr.h:150

STATUS_INFO_LENGTH_MISMATCH
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133

_LARGE_INTEGER
Definition: typedefs.h:103

value
Definition: pdh_main.c:96

GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042

GetCurrentThreadId
DWORD WINAPI GetCurrentThreadId(void)
Definition: thread.c:459

WAIT_ABANDONED_0
#define WAIT_ABANDONED_0
Definition: winbase.h:384

WAIT_OBJECT_0
#define WAIT_OBJECT_0
Definition: winbase.h:383

WAIT_FAILED
#define WAIT_FAILED
Definition: winbase.h:390

windef.h

arg
void * arg
Definition: msvc.h:10

WINAPI
#define WINAPI
Definition: msvc.h:6

NtRemoveIoCompletionEx
NTSYSAPI NTSTATUS WINAPI NtRemoveIoCompletionEx(HANDLE, FILE_IO_COMPLETION_INFORMATION *, ULONG, ULONG *, LARGE_INTEGER *, BOOLEAN)

ERROR_ABANDONED_WAIT_0
#define ERROR_ABANDONED_WAIT_0
Definition: winerror.h:813