From 4b4aad7217d3292650e77eec2cf4c198ea9c3b4b Mon Sep 17 00:00:00 2001 From: Jiyoung Yun Date: Wed, 23 Nov 2016 19:09:09 +0900 Subject: Imported Upstream version 1.1.0 --- .../palsuite/threading/CreateEventA/test3/test3.c | 219 +++++++++++++++++++++ 1 file changed, 219 insertions(+) create mode 100644 src/pal/tests/palsuite/threading/CreateEventA/test3/test3.c (limited to 'src/pal/tests/palsuite/threading/CreateEventA/test3/test3.c') diff --git a/src/pal/tests/palsuite/threading/CreateEventA/test3/test3.c b/src/pal/tests/palsuite/threading/CreateEventA/test3/test3.c new file mode 100644 index 0000000000..56d107b22d --- /dev/null +++ b/src/pal/tests/palsuite/threading/CreateEventA/test3/test3.c @@ -0,0 +1,219 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +/*============================================================ +** +** Source: test3.c +** +** Purpose: Tests for CreateEventA. Create an event with an empty name, +** create an event with the same name as an already created event +** object. +** +** +**=========================================================*/ + +#include + +#define SWAPPTR ((VOID *)(-1)) + +struct testCase +{ + LPSECURITY_ATTRIBUTES lpEventAttributes; + BOOL bManualReset; + BOOL bInitialState; + char lpName[MAX_PATH + 2]; + DWORD dwNameLen; + DWORD lastError; + BOOL bResult; +}; + +struct testCase testCases[]= +{ + {0, TRUE, FALSE, "", 0, ERROR_SUCCESS, PASS}, + {0, TRUE, FALSE, "", 5, ERROR_SUCCESS, PASS}, + {0, TRUE, FALSE, "", 5, ERROR_ALREADY_EXISTS, PASS}, + {0, TRUE, FALSE, "", 6, ERROR_INVALID_HANDLE, PASS}, + {0, TRUE, FALSE, "", MAX_PATH - 1 - 60, ERROR_SUCCESS, PASS}, + {0, TRUE, FALSE, "", MAX_PATH + 1, ERROR_FILENAME_EXCED_RANGE, PASS} +}; + +static HANDLE hEvent[sizeof(testCases)/sizeof(struct testCase)]; + +DWORD result[sizeof(testCases)/sizeof(struct testCase)]; + +int __cdecl main(int argc, char **argv) +{ + + BOOL bRet = TRUE; + const char *nonEventName = "aaaaaa"; + HANDLE hUnnamedEvent; + HANDLE hFMap; + DWORD dwRet; + int i; + + if(0 != (PAL_Initialize(argc, argv))) + { + return ( FAIL ); + } + + hUnnamedEvent = CreateEventA(0, TRUE, FALSE, NULL); + + if ( NULL == hUnnamedEvent ) + { + bRet = FALSE; + Trace ( "PALSUITE ERROR: CreateEventA (%d, %d, %d, NULL) call " + "returned NULL.\nGetLastError returned %u.\n", 0, TRUE, FALSE, + GetLastError()); + } + + if (!CloseHandle(hUnnamedEvent)) + { + bRet = FALSE; + Trace("PALSUITE ERROR: CreateEventA: CloseHandle(%lp); call " + "failed\nGetLastError returned '%u'.\n", hUnnamedEvent, + GetLastError()); + } + + /* Create non-event with the same name as one of the testCases */ + hFMap = CreateFileMappingA( SWAPPTR, NULL, PAGE_READONLY, 0, 1, + nonEventName ); + + if ( NULL == hFMap ) + { + bRet = FALSE; + Trace ( "PALSUITE ERROR: CreateFileMapping (%p, %p, %d, %d, %d, %s)" + " call returned NULL.\nGetLastError returned %u.\n", + SWAPPTR, NULL, PAGE_READONLY, 0, 0, nonEventName, + GetLastError()); + goto done; + } + + /* Create Events */ + for (i = 0; i < sizeof(testCases)/sizeof(struct testCase); i++) + { + /* create name */ + memset (testCases[i].lpName, '\0', (MAX_PATH + 2)); + memset (testCases[i].lpName, 'a', testCases[i].dwNameLen ); + + SetLastError(ERROR_SUCCESS); + + hEvent[i] = CreateEventA( testCases[i].lpEventAttributes, + testCases[i].bManualReset, + testCases[i].bInitialState, + testCases[i].lpName); + + if (hEvent[i] != INVALID_HANDLE_VALUE) + { + DWORD dwError = GetLastError(); + + if (dwError != testCases[i].lastError) + { + bRet = FALSE; + Trace ("PALSUITE ERROR:\nCreateEventA(%lp, %d, %d, %s)" + "\nGetLastError returned '%u', it should have returned" + "'%d' at index '%d'.\n", testCases[i].lpEventAttributes, + testCases[i].bManualReset, testCases[i].bInitialState, + testCases[i].lpName, dwError, + testCases[i].lastError, i); + } + if ( ERROR_FILENAME_EXCED_RANGE == testCases[i].lastError ) + { + result [i] = 1; + } + if ( ERROR_INVALID_HANDLE == testCases[i].lastError ) + { + result [i] = 1; + } + /* + * If we expected the testcase to FAIL and it passed, + * report an error. + */ + if (testCases[i].bResult == FAIL) + { + bRet = FALSE; + Trace ("PALSUITE ERROR:\nCreateEventA(%lp, %d, %d, %s)" + "\nShould have returned INVALID_HANDLE_VALUE but " + "didn't at index '%d'.\n", + testCases[i].lpEventAttributes, + testCases[i].bManualReset, + testCases[i].bInitialState, + testCases[i].lpName, i); + } + /* + * If result hasn't been set already set it to 0 so all the + * resources will be freed. + */ + if (!result[i] ) + { + result[i] = 0; + } + } + else + { + /* + * If we get an INVALID_HANDLE_VALUE and we expected the + * test case to pass, report an error. + */ + result[i] = 1; + + if (testCases[i].bResult == PASS) + { + bRet = FALSE; + Trace ("PALSUITE ERROR:\nCreateEventA(%lp, %d, %d, %s);" + "\nReturned INVALID_HANDLE_VALUE at index '%d'.\n", + testCases[i].lpEventAttributes, + testCases[i].bManualReset, testCases[i].bInitialState, + testCases[i].lpName, i); + } + } + } + + /* cleanup */ + for (i = 0; i < sizeof(testCases)/sizeof(struct testCase); i++) + { + if (result[i]) + { + continue; + } + dwRet = WaitForSingleObject ( hEvent[i], 0 ); + + if (dwRet != WAIT_TIMEOUT) + { + bRet = FALSE; + Trace("PALSUITE ERROR: CreateEventA:\nWaitForSingleObject (%lp, " + "%d) call failed at index %d .\nGetLastError returned " + "'%u'.\n", hEvent[i], 0, i, GetLastError()); + } + + if (!CloseHandle(hEvent[i])) + { + bRet = FALSE; + Trace("PALSUITE ERROR: CreateEventA: CloseHandle(%lp) call " + "failed at index %d\nGetLastError returned '%u'.\n", + hEvent[i], i, GetLastError()); + } + } + +done: + if (!CloseHandle(hFMap)) + { + bRet = FALSE; + Trace("PALSUITE ERROR: CreateEventW: CloseHandle(%p) call " + "failed\nGetLastError returned '%u'.\n", hFMap, + GetLastError()); + } + + if (FALSE == bRet) + { + bRet = FAIL; + } + else + { + bRet = PASS; + } + + PAL_TerminateEx(bRet); + + return(bRet); +} -- cgit v1.2.3