| /* |
| * Synchronization tests |
| * |
| * Copyright 2005 Mike McCormack for CodeWeavers |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include <stdarg.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <windef.h> |
| #include <winbase.h> |
| |
| #include "wine/test.h" |
| |
| static void test_signalandwait(void) |
| { |
| DWORD (WINAPI *pSignalObjectAndWait)(HANDLE, HANDLE, DWORD, BOOL); |
| HMODULE kernel32; |
| DWORD r; |
| int i; |
| HANDLE event[2], maxevents[MAXIMUM_WAIT_OBJECTS], semaphore[2], file; |
| |
| kernel32 = GetModuleHandle("kernel32"); |
| pSignalObjectAndWait = (void*) GetProcAddress(kernel32, "SignalObjectAndWait"); |
| |
| if (!pSignalObjectAndWait) |
| return; |
| |
| /* invalid parameters */ |
| r = pSignalObjectAndWait(NULL, NULL, 0, 0); |
| if (r == ERROR_INVALID_FUNCTION) |
| { |
| trace("SignalObjectAndWait not implemented, skipping tests\n"); |
| return; /* Win98/ME */ |
| } |
| ok( r == WAIT_FAILED, "should fail\n"); |
| |
| event[0] = CreateEvent(NULL, 0, 0, NULL); |
| event[1] = CreateEvent(NULL, 1, 1, NULL); |
| |
| ok( event[0] && event[1], "failed to create event flags\n"); |
| |
| r = pSignalObjectAndWait(event[0], NULL, 0, FALSE); |
| ok( r == WAIT_FAILED, "should fail\n"); |
| |
| r = pSignalObjectAndWait(NULL, event[0], 0, FALSE); |
| ok( r == WAIT_FAILED, "should fail\n"); |
| |
| |
| /* valid parameters */ |
| r = pSignalObjectAndWait(event[0], event[1], 0, FALSE); |
| ok( r == WAIT_OBJECT_0, "should succeed\n"); |
| |
| /* event[0] is now signalled */ |
| r = pSignalObjectAndWait(event[0], event[0], 0, FALSE); |
| ok( r == WAIT_OBJECT_0, "should succeed\n"); |
| |
| /* event[0] is not signalled */ |
| r = WaitForSingleObject(event[0], 0); |
| ok( r == WAIT_TIMEOUT, "event was signalled\n"); |
| |
| r = pSignalObjectAndWait(event[0], event[0], 0, FALSE); |
| ok( r == WAIT_OBJECT_0, "should succeed\n"); |
| |
| /* clear event[1] and check for a timeout */ |
| ok(ResetEvent(event[1]), "failed to clear event[1]\n"); |
| r = pSignalObjectAndWait(event[0], event[1], 0, FALSE); |
| ok( r == WAIT_TIMEOUT, "should timeout\n"); |
| |
| CloseHandle(event[0]); |
| CloseHandle(event[1]); |
| |
| /* create the maximum number of events and make sure |
| * we can wait on that many */ |
| for (i=0; i<MAXIMUM_WAIT_OBJECTS; i++) |
| { |
| maxevents[i] = CreateEvent(NULL, 1, 1, NULL); |
| ok( maxevents[i] != 0, "should create enough events\n"); |
| } |
| r = WaitForMultipleObjects(MAXIMUM_WAIT_OBJECTS, maxevents, 0, 0); |
| ok( r != WAIT_FAILED && r != WAIT_TIMEOUT, "should succeed\n"); |
| |
| for (i=0; i<MAXIMUM_WAIT_OBJECTS; i++) |
| if (maxevents[i]) CloseHandle(maxevents[i]); |
| |
| /* semaphores */ |
| semaphore[0] = CreateSemaphore( NULL, 0, 1, NULL ); |
| semaphore[1] = CreateSemaphore( NULL, 1, 1, NULL ); |
| ok( semaphore[0] && semaphore[1], "failed to create semaphore\n"); |
| |
| r = pSignalObjectAndWait(semaphore[0], semaphore[1], 0, FALSE); |
| ok( r == WAIT_OBJECT_0, "should succeed\n"); |
| |
| r = pSignalObjectAndWait(semaphore[0], semaphore[1], 0, FALSE); |
| ok( r == WAIT_FAILED, "should fail\n"); |
| |
| r = ReleaseSemaphore(semaphore[0],1,NULL); |
| ok( r == FALSE, "should fail\n"); |
| |
| r = ReleaseSemaphore(semaphore[1],1,NULL); |
| ok( r == TRUE, "should succeed\n"); |
| |
| CloseHandle(semaphore[0]); |
| CloseHandle(semaphore[1]); |
| |
| /* try a registry key */ |
| file = CreateFile("x", GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, |
| FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE, NULL); |
| r = pSignalObjectAndWait(file, file, 0, FALSE); |
| ok( r == WAIT_FAILED, "should fail\n"); |
| ok( ERROR_INVALID_HANDLE == GetLastError(), "should return invalid handle error\n"); |
| CloseHandle(file); |
| } |
| |
| START_TEST(sync) |
| { |
| test_signalandwait(); |
| } |