Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-06 22:23:05 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Updated kernel32 test to Wine-20040504.

Browse source 
svn path=/trunk/; revision=9299
This commit is contained in:
Filip Navara 2004-05-04 17:25:19 +00:00
parent 57aa128d43
commit c789493a59
10 changed files with 914 additions and 439 deletions
Download patch file Download diff file Expand all files Collapse all files

4
reactos/apps/tests/kernel32/Makefile
View file

@ -1,4 +1,4 @@
# $Id: Makefile,v 1.1 2004/02/14 20:11:42 sedwards Exp $ # $Id: Makefile,v 1.2 2004/05/04 17:25:18 navaraf Exp $
PATH_TO_TOP = ../../.. PATH_TO_TOP = ../../..
@ -9,7 +9,7 @@ TARGET_TYPE = program
TARGET_APPTYPE = console TARGET_APPTYPE = console
# require os code to explicitly request A/W version of structs/functions # require os code to explicitly request A/W version of structs/functions
TARGET_CFLAGS += -D_DISABLE_TIDENTS -D__USE_W32API TARGET_CFLAGS += -D_DISABLE_TIDENTS -D__USE_W32API -DWINVER=0x0500
TARGET_NAME = kernel32_test TARGET_NAME = kernel32_test

41
reactos/apps/tests/kernel32/console.c
View file

@ -137,8 +137,9 @@ static void testWriteNotWrappedNotProcessed(HANDLE hCon, COORD sbSize)
{ {
COORD c; COORD c;
DWORD len, mode; DWORD len, mode;
const char* mytest = "abcd\nf\tg"; char* mytest;
const int mylen = strlen(mytest); int mylen;
int ret;
int p; int p;
ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, mode & ~(ENABLE_PROCESSED_OUTPUT|ENABLE_WRAP_AT_EOL_OUTPUT)), ok(GetConsoleMode(hCon, &mode) && SetConsoleMode(hCon, mode & ~(ENABLE_PROCESSED_OUTPUT|ENABLE_WRAP_AT_EOL_OUTPUT)),
@ -148,7 +149,12 @@ static void testWriteNotWrappedNotProcessed(HANDLE hCon, COORD sbSize)
c.X = sbSize.X - 3; c.Y = 0; c.X = sbSize.X - 3; c.Y = 0;
ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n"); ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");
ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n"); mytest = "123";
mylen = strlen(mytest);
ret = WriteConsole(hCon, mytest, mylen, &len, NULL);
ok(ret != 0 && len == mylen, "Couldn't write, ret = %d, len = %ld\n", ret, len);
c.Y = 0; c.Y = 0;
for (p = mylen - 3; p < mylen; p++) for (p = mylen - 3; p < mylen; p++)
{ {
@ -161,26 +167,12 @@ static void testWriteNotWrappedNotProcessed(HANDLE hCon, COORD sbSize)
p = sbSize.X - 3 + mylen % 3; p = sbSize.X - 3 + mylen % 3;
c.X = p; c.Y = 0; c.X = p; c.Y = 0;
okCURSOR(hCon, c);
/* write line, wrapping disabled, strings end on end of line */ /* write line, wrapping disabled, strings end on end of line */
c.X = sbSize.X - mylen; c.Y = 0; c.X = sbSize.X - mylen; c.Y = 0;
ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n"); ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");
ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n"); ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
c.Y = 0;
for (p = 0; p < mylen; p++)
{
c.X = sbSize.X - mylen + p;
okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
}
c.X = 0; c.Y = 1;
okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
p = sbSize.X - mylen;
c.X = p; c.Y = 0;
okCURSOR(hCon, c);
} }
static void testWriteNotWrappedProcessed(HANDLE hCon, COORD sbSize) static void testWriteNotWrappedProcessed(HANDLE hCon, COORD sbSize)
@ -290,24 +282,9 @@ static void testWriteWrappedNotProcessed(HANDLE hCon, COORD sbSize)
c.X = sbSize.X - 3; c.Y = 0; c.X = sbSize.X - 3; c.Y = 0;
ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n"); ok(SetConsoleCursorPosition(hCon, c) != 0, "Cursor in upper-left-3\n");
ok(WriteConsole(hCon, mytest, mylen, &len, NULL) != 0 && len == mylen, "WriteConsole\n");
c.Y = 0;
for (p = 0; p < 3; p++)
{
c.X = sbSize.X - 3 + p;
okCHAR(hCon, c, mytest[p], TEST_ATTRIB);
}
c.Y = 1; c.Y = 1;
for (p = 0; p < mylen - 3; p++)
{
c.X = p;
okCHAR(hCon, c, mytest[p + 3], TEST_ATTRIB);
}
c.X = mylen - 3; c.X = mylen - 3;
okCHAR(hCon, c, ' ', DEFAULT_ATTRIB); okCHAR(hCon, c, ' ', DEFAULT_ATTRIB);
okCURSOR(hCon, c);
} }
static void testWriteWrappedProcessed(HANDLE hCon, COORD sbSize) static void testWriteWrappedProcessed(HANDLE hCon, COORD sbSize)

9
reactos/apps/tests/kernel32/directory.c
View file

@ -193,7 +193,6 @@ static void test_CreateDirectoryA(void)
ret = RemoveDirectoryA(tmpdir); ret = RemoveDirectoryA(tmpdir);
ok(ret == TRUE, "RemoveDirectoryA should always succeed\n"); ok(ret == TRUE, "RemoveDirectoryA should always succeed\n");
todo_wine {
lstrcatA(tmpdir, "?"); lstrcatA(tmpdir, "?");
ret = CreateDirectoryA(tmpdir, NULL); ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME, ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
@ -207,7 +206,6 @@ static void test_CreateDirectoryA(void)
"CreateDirectoryA with * wildcard name should fail, ret=%s error=%ld\n", "CreateDirectoryA with * wildcard name should fail, ret=%s error=%ld\n",
ret ? " True" : "False", GetLastError()); ret ? " True" : "False", GetLastError());
ret = RemoveDirectoryA(tmpdir); ret = RemoveDirectoryA(tmpdir);
}
} }
static void test_CreateDirectoryW(void) static void test_CreateDirectoryW(void)
@ -256,7 +254,6 @@ static void test_CreateDirectoryW(void)
ret = RemoveDirectoryW(tmpdir); ret = RemoveDirectoryW(tmpdir);
ok(ret == TRUE, "RemoveDirectoryW should always succeed\n"); ok(ret == TRUE, "RemoveDirectoryW should always succeed\n");
todo_wine {
lstrcatW(tmpdir, questionW); lstrcatW(tmpdir, questionW);
ret = CreateDirectoryW(tmpdir, NULL); ret = CreateDirectoryW(tmpdir, NULL);
ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME, ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
@ -270,7 +267,6 @@ static void test_CreateDirectoryW(void)
"CreateDirectoryW with * wildcard name should fail with error 183, ret=%s error=%ld\n", "CreateDirectoryW with * wildcard name should fail with error 183, ret=%s error=%ld\n",
ret ? " True" : "False", GetLastError()); ret ? " True" : "False", GetLastError());
ret = RemoveDirectoryW(tmpdir); ret = RemoveDirectoryW(tmpdir);
}
} }
static void test_RemoveDirectoryA(void) static void test_RemoveDirectoryA(void)
@ -286,7 +282,6 @@ static void test_RemoveDirectoryA(void)
ret = RemoveDirectoryA(tmpdir); ret = RemoveDirectoryA(tmpdir);
ok(ret == TRUE, "RemoveDirectoryA should always succeed\n"); ok(ret == TRUE, "RemoveDirectoryA should always succeed\n");
todo_wine {
lstrcatA(tmpdir, "?"); lstrcatA(tmpdir, "?");
ret = RemoveDirectoryA(tmpdir); ret = RemoveDirectoryA(tmpdir);
ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME, ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
@ -298,7 +293,6 @@ static void test_RemoveDirectoryA(void)
ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME, ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
"RemoveDirectoryA with * wildcard name should fail with error 183, ret=%s error=%ld\n", "RemoveDirectoryA with * wildcard name should fail with error 183, ret=%s error=%ld\n",
ret ? " True" : "False", GetLastError()); ret ? " True" : "False", GetLastError());
}
} }
static void test_RemoveDirectoryW(void) static void test_RemoveDirectoryW(void)
@ -319,7 +313,6 @@ static void test_RemoveDirectoryW(void)
ret = RemoveDirectoryW(tmpdir); ret = RemoveDirectoryW(tmpdir);
ok(ret == TRUE, "RemoveDirectoryW should always succeed\n"); ok(ret == TRUE, "RemoveDirectoryW should always succeed\n");
todo_wine {
lstrcatW(tmpdir, questionW); lstrcatW(tmpdir, questionW);
ret = RemoveDirectoryW(tmpdir); ret = RemoveDirectoryW(tmpdir);
ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME, ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
@ -331,8 +324,6 @@ static void test_RemoveDirectoryW(void)
ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME, ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
"RemoveDirectoryW with * wildcard name should fail with error 183, ret=%s error=%ld\n", "RemoveDirectoryW with * wildcard name should fail with error 183, ret=%s error=%ld\n",
ret ? " True" : "False", GetLastError()); ret ? " True" : "False", GetLastError());
}
} }
START_TEST(directory) START_TEST(directory)

289
reactos/apps/tests/kernel32/file.c
View file

@ -1,7 +1,7 @@
/* /*
* Unit tests for file functions in Wine * Unit tests for file functions in Wine
* *
* Copyright (c) 2002 Jakob Eriksson * Copyright (c) 2002, 2004 Jakob Eriksson
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -28,6 +28,15 @@
#include "winbase.h" #include "winbase.h"
#include "winerror.h" #include "winerror.h"
static int dll_capable(const char *dll, const char *function)
{
HMODULE module = GetModuleHandleA(dll);
if (!module) return 0;
return (GetProcAddress(module, function) != NULL);
}
LPCSTR filename = "testfile.xxx"; LPCSTR filename = "testfile.xxx";
LPCSTR sillytext = LPCSTR sillytext =
"en larvig liten text dx \033 gx hej 84 hej 4484 ! \001\033 bla bl\na.. bla bla." "en larvig liten text dx \033 gx hej 84 hej 4484 ! \001\033 bla bl\na.. bla bla."
@ -270,9 +279,8 @@ static void test__lcreat( void )
} else { /* only NT succeeds */ } else { /* only NT succeeds */
_lclose(filehandle); _lclose(filehandle);
find=FindFirstFileA (slashname, &search_results); find=FindFirstFileA (slashname, &search_results);
if (INVALID_HANDLE_VALUE==find) if (INVALID_HANDLE_VALUE!=find)
ok (0, "file \"%s\" not found\n", slashname); {
else {
ok (0!=FindClose (find), "FindClose complains (%ld)\n", GetLastError ()); ok (0!=FindClose (find), "FindClose complains (%ld)\n", GetLastError ());
slashname[strlen(slashname)-1]=0; slashname[strlen(slashname)-1]=0;
ok (!strcmp (slashname, search_results.cFileName), ok (!strcmp (slashname, search_results.cFileName),
@ -597,6 +605,7 @@ static void test_CreateFileW(void)
HANDLE hFile; HANDLE hFile;
WCHAR temp_path[MAX_PATH]; WCHAR temp_path[MAX_PATH];
WCHAR filename[MAX_PATH]; WCHAR filename[MAX_PATH];
static const WCHAR emptyW[]={'\0'};
static const WCHAR prefix[] = {'p','f','x',0}; static const WCHAR prefix[] = {'p','f','x',0};
DWORD ret; DWORD ret;
@ -616,25 +625,55 @@ static void test_CreateFileW(void)
ret = DeleteFileW(filename); ret = DeleteFileW(filename);
ok(ret, "DeleteFileW: error %ld\n", GetLastError()); ok(ret, "DeleteFileW: error %ld\n", GetLastError());
hFile = CreateFileW(NULL, GENERIC_READ, 0, NULL,
CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
"CreateFileW(NULL) returned ret=%p error=%ld\n",hFile,GetLastError());
hFile = CreateFileW(emptyW, GENERIC_READ, 0, NULL,
CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
"CreateFileW(\"\") returned ret=%p error=%ld\n",hFile,GetLastError());
} }
static void test_GetTempFileNameA()
static void test_GetTempFileNameA() { {
UINT result; UINT result;
char out[MAX_PATH]; char out[MAX_PATH];
char *expected = "c:\\windows\\abc2.tmp"; char expected[MAX_PATH + 10];
char windowsdir[MAX_PATH + 10];
char windowsdrive[3];
/* this test may depend on the config file settings */ result = GetWindowsDirectory(windowsdir, sizeof(windowsdir));
result = GetTempFileNameA("C:", "abc", 1, out); ok(result < sizeof(windowsdir), "windowsdir is abnormally long!\n");
ok( result != 0, "GetTempFileNameA: error %ld\n", GetLastError() ); ok(result != 0, "GetWindowsDirectory: error %ld\n", GetLastError());
ok( ((out[0] == 'C') && (out[1] == ':')) && (out[2] == '\\'), "GetTempFileNameA: first three characters should be C:\\, string was actually %s\n", out );
result = GetTempFileNameA("c:\\windows\\", "abc", 2, out); /* If the Windows directory is the root directory, it ends in backslash, not else. */
ok( result != 0, "GetTempFileNameA: error %ld\n", GetLastError() ); if (strlen(windowsdir) != 3) /* As in "C:\" or "F:\" */
ok( lstrcmpiA( out, expected ) == 0, "GetTempFileNameA: Unexpected output \"%s\" vs \"%s\"\n", out, expected ); {
strcat(windowsdir, "\\");
}
windowsdrive[0] = windowsdir[0];
windowsdrive[1] = windowsdir[1];
windowsdrive[2] = '\0';
result = GetTempFileNameA(windowsdrive, "abc", 1, out);
ok(result != 0, "GetTempFileNameA: error %ld\n", GetLastError());
ok(((out[0] == windowsdrive[0]) && (out[1] == ':')) && (out[2] == '\\'),
"GetTempFileNameA: first three characters should be %c:\\, string was actually %s\n",
windowsdrive[0], out);
result = GetTempFileNameA(windowsdir, "abc", 2, out);
ok(result != 0, "GetTempFileNameA: error %ld\n", GetLastError());
expected[0] = '\0';
strcat(expected, windowsdir);
strcat(expected, "abc2.tmp");
ok(lstrcmpiA(out, expected) == 0, "GetTempFileNameA: Unexpected output \"%s\" vs \"%s\"\n",
out, expected);
} }
static void test_DeleteFileA( void ) static void test_DeleteFileA( void )
{ {
BOOL ret; BOOL ret;
@ -648,12 +687,18 @@ static void test_DeleteFileA( void )
ok(!ret && (GetLastError() == ERROR_PATH_NOT_FOUND || ok(!ret && (GetLastError() == ERROR_PATH_NOT_FOUND ||
GetLastError() == ERROR_BAD_PATHNAME), GetLastError() == ERROR_BAD_PATHNAME),
"DeleteFileA(\"\") returned ret=%d error=%ld\n",ret,GetLastError()); "DeleteFileA(\"\") returned ret=%d error=%ld\n",ret,GetLastError());
ret = DeleteFileA("nul");
ok(!ret && (GetLastError() == ERROR_FILE_NOT_FOUND ||
GetLastError() == ERROR_INVALID_PARAMETER ||
GetLastError() == ERROR_ACCESS_DENIED),
"DeleteFileA(\"nul\") returned ret=%d error=%ld\n",ret,GetLastError());
} }
static void test_DeleteFileW( void ) static void test_DeleteFileW( void )
{ {
BOOL ret; BOOL ret;
WCHAR emptyW[]={'\0'}; static const WCHAR emptyW[]={'\0'};
ret = DeleteFileW(NULL); ret = DeleteFileW(NULL);
if (ret==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED) if (ret==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
@ -702,12 +747,11 @@ static void test_MoveFileA(void)
lstrcpyA(source, dest); lstrcpyA(source, dest);
lstrcpyA(dest, tempdir); lstrcpyA(dest, tempdir);
lstrcatA(dest, "\\wild?.*"); lstrcatA(dest, "\\wild?.*");
/* FIXME: if we create a file with wildcards we can't delete it now that DeleteFile works correctly */
ret = MoveFileA(source, dest); ret = MoveFileA(source, dest);
todo_wine {
ok(!ret, "MoveFileA: shouldn't move to wildcard file\n"); ok(!ret, "MoveFileA: shouldn't move to wildcard file\n");
ok(GetLastError() == ERROR_INVALID_NAME, ok(GetLastError() == ERROR_INVALID_NAME,
"MoveFileA: with wildcards, unexpected error %ld\n", GetLastError()); "MoveFileA: with wildcards, unexpected error %ld\n", GetLastError());
#if 0
if (ret || (GetLastError() != ERROR_INVALID_NAME)) if (ret || (GetLastError() != ERROR_INVALID_NAME))
{ {
WIN32_FIND_DATAA fd; WIN32_FIND_DATAA fd;
@ -731,13 +775,10 @@ static void test_MoveFileA(void)
FindClose(hFind); FindClose(hFind);
} }
} }
#endif
ret = DeleteFileA(source); ret = DeleteFileA(source);
ok(ret, "DeleteFileA: error %ld\n", GetLastError()); ok(ret, "DeleteFileA: error %ld\n", GetLastError());
ret = DeleteFileA(dest); ret = DeleteFileA(dest);
ok(!ret, "DeleteFileA: error %ld\n", GetLastError()); ok(!ret, "DeleteFileA: error %ld\n", GetLastError());
}
ret = RemoveDirectoryA(tempdir); ret = RemoveDirectoryA(tempdir);
ok(ret, "DeleteDirectoryA: error %ld\n", GetLastError()); ok(ret, "DeleteDirectoryA: error %ld\n", GetLastError());
} }
@ -803,7 +844,7 @@ static void test_offset_in_overlapped_structure(void)
if (rc || GetLastError()!=ERROR_INVALID_PARAMETER) { if (rc || GetLastError()!=ERROR_INVALID_PARAMETER) {
ok(rc, "WriteFile error %ld\n", GetLastError()); ok(rc, "WriteFile error %ld\n", GetLastError());
ok(done == sizeof(pattern), "expected number of bytes written %lu\n", done); ok(done == sizeof(pattern), "expected number of bytes written %lu\n", done);
trace("Current offset = %04lx\n", SetFilePointer(hFile, 0, NULL, FILE_CURRENT)); /*trace("Current offset = %04lx\n", SetFilePointer(hFile, 0, NULL, FILE_CURRENT));*/
ok(SetFilePointer(hFile, 0, NULL, FILE_CURRENT) == (PATTERN_OFFSET + sizeof(pattern)), ok(SetFilePointer(hFile, 0, NULL, FILE_CURRENT) == (PATTERN_OFFSET + sizeof(pattern)),
"expected file offset %d\n", PATTERN_OFFSET + sizeof(pattern)); "expected file offset %d\n", PATTERN_OFFSET + sizeof(pattern));
@ -832,7 +873,7 @@ static void test_offset_in_overlapped_structure(void)
if (rc || GetLastError()!=ERROR_INVALID_PARAMETER) { if (rc || GetLastError()!=ERROR_INVALID_PARAMETER) {
ok(rc, "ReadFile error %ld\n", GetLastError()); ok(rc, "ReadFile error %ld\n", GetLastError());
ok(done == sizeof(pattern), "expected number of bytes read %lu\n", done); ok(done == sizeof(pattern), "expected number of bytes read %lu\n", done);
trace("Current offset = %04lx\n", SetFilePointer(hFile, 0, NULL, FILE_CURRENT)); /*trace("Current offset = %04lx\n", SetFilePointer(hFile, 0, NULL, FILE_CURRENT));*/
ok(SetFilePointer(hFile, 0, NULL, FILE_CURRENT) == (PATTERN_OFFSET + sizeof(pattern)), ok(SetFilePointer(hFile, 0, NULL, FILE_CURRENT) == (PATTERN_OFFSET + sizeof(pattern)),
"expected file offset %d\n", PATTERN_OFFSET + sizeof(pattern)); "expected file offset %d\n", PATTERN_OFFSET + sizeof(pattern));
ok(!memcmp(buf, pattern, sizeof(pattern)), "pattern match failed\n"); ok(!memcmp(buf, pattern, sizeof(pattern)), "pattern match failed\n");
@ -848,6 +889,9 @@ static void test_LockFile(void)
HANDLE handle; HANDLE handle;
DWORD written; DWORD written;
OVERLAPPED overlapped; OVERLAPPED overlapped;
int limited_LockFile;
int limited_UnLockFile;
int lockfileex_capable;
handle = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE, handle = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
@ -861,7 +905,12 @@ static void test_LockFile(void)
ok( LockFile( handle, 0, 0, 0, 0 ), "LockFile failed\n" ); ok( LockFile( handle, 0, 0, 0, 0 ), "LockFile failed\n" );
ok( UnlockFile( handle, 0, 0, 0, 0 ), "UnlockFile failed\n" ); ok( UnlockFile( handle, 0, 0, 0, 0 ), "UnlockFile failed\n" );
ok( !UnlockFile( handle, 0, 0, 0, 0 ), "UnlockFile succeeded\n" );
limited_UnLockFile = 0;
if (UnlockFile( handle, 0, 0, 0, 0 ))
{
limited_UnLockFile = 1;
}
ok( LockFile( handle, 10, 0, 20, 0 ), "LockFile 10,20 failed\n" ); ok( LockFile( handle, 10, 0, 20, 0 ), "LockFile 10,20 failed\n" );
/* overlapping locks must fail */ /* overlapping locks must fail */
@ -878,18 +927,39 @@ static void test_LockFile(void)
overlapped.Offset = 100; overlapped.Offset = 100;
overlapped.OffsetHigh = 0; overlapped.OffsetHigh = 0;
overlapped.hEvent = 0; overlapped.hEvent = 0;
ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ), "LockFileEx 100,100 failed\n" );
lockfileex_capable = dll_capable("kernel32", "LockFileEx");
if (lockfileex_capable)
{
/* Test for broken LockFileEx a la Windows 95 OSR2. */
if (LockFileEx( handle, 0, 0, 100, 0, &overlapped ))
{
/* LockFileEx is probably OK, test it more. */
ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ),
"LockFileEx 100,100 failed\n" );
}
}
/* overlapping shared locks are OK */ /* overlapping shared locks are OK */
overlapped.Offset = 150; overlapped.Offset = 150;
ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ), "LockFileEx 150,100 failed\n" ); limited_UnLockFile || ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ), "LockFileEx 150,100 failed\n" );
/* but exclusive is not */ /* but exclusive is not */
ok( !LockFileEx( handle, LOCKFILE_EXCLUSIVE_LOCK|LOCKFILE_FAIL_IMMEDIATELY, 0, 50, 0, &overlapped ), if (lockfileex_capable)
{
ok( !LockFileEx( handle, LOCKFILE_EXCLUSIVE_LOCK|LOCKFILE_FAIL_IMMEDIATELY,
0, 50, 0, &overlapped ),
"LockFileEx exclusive 150,50 succeeded\n" ); "LockFileEx exclusive 150,50 succeeded\n" );
ok( UnlockFileEx( handle, 0, 100, 0, &overlapped ), "UnlockFileEx 150,100 failed\n" ); if (dll_capable("kernel32.dll", "UnlockFileEx"))
ok( !UnlockFileEx( handle, 0, 100, 0, &overlapped ), "UnlockFileEx 150,100 again succeeded\n" ); {
if (!UnlockFileEx( handle, 0, 100, 0, &overlapped ))
{ /* UnLockFile is capable. */
overlapped.Offset = 100; overlapped.Offset = 100;
ok( UnlockFileEx( handle, 0, 100, 0, &overlapped ), "UnlockFileEx 100,100 failed\n" ); ok( !UnlockFileEx( handle, 0, 100, 0, &overlapped ),
ok( !UnlockFileEx( handle, 0, 100, 0, &overlapped ), "UnlockFileEx 100,100 again succeeded\n" ); "UnlockFileEx 150,100 again succeeded\n" );
}
}
}
ok( LockFile( handle, 0, 0x10000000, 0, 0xf0000000 ), "LockFile failed\n" ); ok( LockFile( handle, 0, 0x10000000, 0, 0xf0000000 ), "LockFile failed\n" );
ok( !LockFile( handle, ~0, ~0, 1, 0 ), "LockFile ~0,1 succeeded\n" ); ok( !LockFile( handle, ~0, ~0, 1, 0 ), "LockFile ~0,1 succeeded\n" );
@ -899,22 +969,102 @@ static void test_LockFile(void)
/* wrap-around lock should not do anything */ /* wrap-around lock should not do anything */
/* (but still succeeds on NT4 so we don't check result) */ /* (but still succeeds on NT4 so we don't check result) */
LockFile( handle, 0, 0x10000000, 0, 0xf0000001 ); LockFile( handle, 0, 0x10000000, 0, 0xf0000001 );
ok( LockFile( handle, ~0, ~0, 1, 0 ), "LockFile ~0,1 failed\n" );
ok( UnlockFile( handle, ~0, ~0, 1, 0 ), "Unlockfile ~0,1 failed\n" ); limited_LockFile = 0;
if (!LockFile( handle, ~0, ~0, 1, 0 ))
{
limited_LockFile = 1;
}
limited_UnLockFile || ok( UnlockFile( handle, ~0, ~0, 1, 0 ), "Unlockfile ~0,1 failed\n" );
/* zero-byte lock */ /* zero-byte lock */
ok( LockFile( handle, 100, 0, 0, 0 ), "LockFile 100,0 failed\n" ); ok( LockFile( handle, 100, 0, 0, 0 ), "LockFile 100,0 failed\n" );
ok( !LockFile( handle, 98, 0, 4, 0 ), "LockFile 98,4 succeeded\n" ); limited_LockFile || ok( !LockFile( handle, 98, 0, 4, 0 ), "LockFile 98,4 succeeded\n" );
ok( LockFile( handle, 90, 0, 10, 0 ), "LockFile 90,10 failed\n" ); ok( LockFile( handle, 90, 0, 10, 0 ), "LockFile 90,10 failed\n" );
ok( LockFile( handle, 100, 0, 10, 0 ), "LockFile 100,10 failed\n" ); limited_LockFile || ok( !LockFile( handle, 100, 0, 10, 0 ), "LockFile 100,10 failed\n" );
ok( UnlockFile( handle, 90, 0, 10, 0 ), "UnlockFile 90,10 failed\n" ); ok( UnlockFile( handle, 90, 0, 10, 0 ), "UnlockFile 90,10 failed\n" );
ok( UnlockFile( handle, 100, 0, 10, 0 ), "UnlockFile 100,10 failed\n" ); !ok( UnlockFile( handle, 100, 0, 10, 0 ), "UnlockFile 100,10 failed\n" );
ok( UnlockFile( handle, 100, 0, 0, 0 ), "UnlockFile 100,0 failed\n" ); ok( UnlockFile( handle, 100, 0, 0, 0 ), "UnlockFile 100,0 failed\n" );
CloseHandle( handle ); CloseHandle( handle );
DeleteFileA( filename ); DeleteFileA( filename );
} }
static inline int is_sharing_compatible( DWORD access1, DWORD sharing1, DWORD access2, DWORD sharing2 )
{
if (!access1 || !access2) return 1;
if ((access1 & GENERIC_READ) && !(sharing2 & FILE_SHARE_READ)) return 0;
if ((access1 & GENERIC_WRITE) && !(sharing2 & FILE_SHARE_WRITE)) return 0;
if ((access2 & GENERIC_READ) && !(sharing1 & FILE_SHARE_READ)) return 0;
if ((access2 & GENERIC_WRITE) && !(sharing1 & FILE_SHARE_WRITE)) return 0;
return 1;
}
static void test_file_sharing(void)
{
static const DWORD access_modes[4] = { 0, GENERIC_READ, GENERIC_WRITE, GENERIC_READ|GENERIC_WRITE };
static const DWORD sharing_modes[4] = { 0, FILE_SHARE_READ, FILE_SHARE_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE };
int a1, s1, a2, s2;
int ret;
/* make sure the file exists */
HANDLE h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
CloseHandle( h );
for (a1 = 0; a1 < 4; a1++)
{
for (s1 = 0; s1 < 4; s1++)
{
HANDLE h = CreateFileA( filename, access_modes[a1], sharing_modes[s1],
NULL, OPEN_EXISTING, 0, 0 );
if (h == INVALID_HANDLE_VALUE)
{
ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename,GetLastError());
return;
}
for (a2 = 0; a2 < 4; a2++)
{
for (s2 = 0; s2 < 4; s2++)
{
HANDLE h2 = CreateFileA( filename, access_modes[a2], sharing_modes[s2],
NULL, OPEN_EXISTING, 0, 0 );
if (is_sharing_compatible( access_modes[a1], sharing_modes[s1],
access_modes[a2], sharing_modes[s2] ))
{
ret = GetLastError();
ok( ERROR_SHARING_VIOLATION == ret || 0 == ret,
"Windows 95 sets GetLastError() = ERROR_SHARING_VIOLATION and\n"
" Windows XP GetLastError() = 0, but now it is %d.\n"
" indexes = %d, %d, %d, %d\n"
" modes =\n %lx/%lx/%lx/%lx\n",
ret,
a1, s1, a2, s2,
access_modes[a1], sharing_modes[s1],
access_modes[a2], sharing_modes[s2]
);
}
else
{
ok( h2 == INVALID_HANDLE_VALUE,
"open succeeded for modes %lx/%lx/%lx/%lx\n",
access_modes[a1], sharing_modes[s1],
access_modes[a2], sharing_modes[s2] );
if (h2 == INVALID_HANDLE_VALUE)
ok( GetLastError() == ERROR_SHARING_VIOLATION,
"wrong error code %ld\n", GetLastError() );
}
if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
}
}
CloseHandle( h );
}
}
DeleteFileA( filename );
}
static void test_FindFirstFileA() static void test_FindFirstFileA()
{ {
HANDLE handle; HANDLE handle;
@ -948,37 +1098,78 @@ static void test_FindNextFileA()
ok ( err == ERROR_NO_MORE_FILES, "GetLastError should return ERROR_NO_MORE_FILES\n"); ok ( err == ERROR_NO_MORE_FILES, "GetLastError should return ERROR_NO_MORE_FILES\n");
} }
static void test_MapFile() static int test_Mapfile_createtemp(HANDLE *handle)
{ {
HANDLE handle, hmap;
/* be sure to remove stale files */
SetFileAttributesA(filename,FILE_ATTRIBUTE_NORMAL); SetFileAttributesA(filename,FILE_ATTRIBUTE_NORMAL);
DeleteFile(filename); DeleteFile(filename);
handle = CreateFile( filename, GENERIC_READ|GENERIC_WRITE, 0, 0, *handle = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, 0,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
ok( handle != INVALID_HANDLE_VALUE, "couldn't create test file\n"); if (*handle != INVALID_HANDLE_VALUE) {
return 1;
}
return 0;
}
static void test_MapFile()
{
HANDLE handle;
HANDLE hmap;
ok(test_Mapfile_createtemp(&handle), "Couldn't create test file.\n");
hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0x1000, "named_file_map" );
ok( hmap != NULL, "mapping should work, I named it!\n" );
ok( CloseHandle( hmap ), "can't close mapping handle\n");
/* We have to close file before we try new stuff with mapping again.
Else we would always succeed on XP or block descriptors on 95. */
hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0, NULL );
ok( hmap != NULL, "We should still be able to map!\n" );
ok( CloseHandle( hmap ), "can't close mapping handle\n");
ok( CloseHandle( handle ), "can't close file handle\n");
handle = NULL;
ok(test_Mapfile_createtemp(&handle), "Couldn't create test file.\n");
hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0, NULL ); hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0, NULL );
ok( hmap == NULL, "Mapping should not work, no name provided.\n" );
ok( hmap == NULL, "mapped zero size file\n"); ok( hmap == NULL, "mapped zero size file\n");
ok( GetLastError() == ERROR_FILE_INVALID, "not ERROR_FILE_INVALID\n"); ok( GetLastError() == ERROR_FILE_INVALID, "not ERROR_FILE_INVALID\n");
hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0x1000, 0, NULL ); hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0x1000, 0, NULL );
ok( hmap == NULL, "mapping should fail\n"); ok( hmap == NULL, "mapping should fail\n");
/* GetLastError() varies between win9x and WinNT */ /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0x1000, 0x10000, NULL ); hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0x1000, 0x10000, NULL );
ok( hmap == NULL, "mapping should fail\n"); ok( hmap == NULL, "mapping should fail\n");
/* GetLastError() varies between win9x and WinNT */ /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0x1000, NULL ); /* On XP you can now map again, on Win 95 you can not. */
ok( hmap != NULL, "mapping should succeed\n");
ok( CloseHandle( hmap ), "can't close mapping handle\n");
ok( CloseHandle( handle ), "can't close file handle\n"); ok( CloseHandle( handle ), "can't close file handle\n");
ok( DeleteFileA( filename ), "DeleteFile failed after map\n" ); ok( DeleteFileA( filename ), "DeleteFile failed after map\n" );
} }
static void test_GetFileType(void)
{
DWORD type;
HANDLE h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
ok( h != INVALID_HANDLE_VALUE, "open %s failed\n", filename );
type = GetFileType(h);
ok( type == FILE_TYPE_DISK, "expected type disk got %ld\n", type );
CloseHandle( h );
h = CreateFileA( "nul", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
ok( h != INVALID_HANDLE_VALUE, "open nul failed\n" );
type = GetFileType(h);
ok( type == FILE_TYPE_CHAR, "expected type char for nul got %ld\n", type );
CloseHandle( h );
DeleteFileA( filename );
}
START_TEST(file) START_TEST(file)
{ {
test__hread( ); test__hread( );
@ -1001,6 +1192,8 @@ START_TEST(file)
test_FindFirstFileA(); test_FindFirstFileA();
test_FindNextFileA(); test_FindNextFileA();
test_LockFile(); test_LockFile();
test_file_sharing();
test_offset_in_overlapped_structure(); test_offset_in_overlapped_structure();
test_MapFile(); test_MapFile();
test_GetFileType();
} }

2
reactos/apps/tests/kernel32/format_msg.c
View file

@ -42,7 +42,7 @@ void test_message_from_string(void)
{ {
CHAR out[0x100] = {0}; CHAR out[0x100] = {0};
DWORD r; DWORD r;
WCHAR szwTest[] = { 't','e','s','t',0}; static const WCHAR szwTest[] = { 't','e','s','t',0};
/* the basics */ /* the basics */
r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "test", 0, r = FormatMessageA(FORMAT_MESSAGE_FROM_STRING, "test", 0,

610
reactos/apps/tests/kernel32/generated.c
View file

@ -109,6 +109,221 @@
#define TEST_TYPE_UNSIGNED(type) \ #define TEST_TYPE_UNSIGNED(type) \
ok((type) -1 > 0, "(" #type ") -1 > 0\n"); ok((type) -1 > 0, "(" #type ") -1 > 0\n");
static void test_pack_LPOSVERSIONINFOA(void)
{
/* LPOSVERSIONINFOA */
TEST_TYPE(LPOSVERSIONINFOA, 4, 4);
TEST_TYPE_POINTER(LPOSVERSIONINFOA, 148, 4);
}
static void test_pack_LPOSVERSIONINFOEXA(void)
{
/* LPOSVERSIONINFOEXA */
TEST_TYPE(LPOSVERSIONINFOEXA, 4, 4);
TEST_TYPE_POINTER(LPOSVERSIONINFOEXA, 156, 4);
}
static void test_pack_LPOSVERSIONINFOEXW(void)
{
/* LPOSVERSIONINFOEXW */
TEST_TYPE(LPOSVERSIONINFOEXW, 4, 4);
TEST_TYPE_POINTER(LPOSVERSIONINFOEXW, 284, 4);
}
static void test_pack_LPOSVERSIONINFOW(void)
{
/* LPOSVERSIONINFOW */
TEST_TYPE(LPOSVERSIONINFOW, 4, 4);
TEST_TYPE_POINTER(LPOSVERSIONINFOW, 276, 4);
}
static void test_pack_OSVERSIONINFOA(void)
{
/* OSVERSIONINFOA (pack 4) */
TEST_TYPE(OSVERSIONINFOA, 148, 4);
TEST_FIELD(OSVERSIONINFOA, DWORD, dwOSVersionInfoSize, 0, 4, 4);
TEST_FIELD(OSVERSIONINFOA, DWORD, dwMajorVersion, 4, 4, 4);
TEST_FIELD(OSVERSIONINFOA, DWORD, dwMinorVersion, 8, 4, 4);
TEST_FIELD(OSVERSIONINFOA, DWORD, dwBuildNumber, 12, 4, 4);
TEST_FIELD(OSVERSIONINFOA, DWORD, dwPlatformId, 16, 4, 4);
TEST_FIELD(OSVERSIONINFOA, CHAR[128], szCSDVersion, 20, 128, 1);
}
static void test_pack_OSVERSIONINFOEXA(void)
{
/* OSVERSIONINFOEXA (pack 4) */
TEST_TYPE(OSVERSIONINFOEXA, 156, 4);
TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwOSVersionInfoSize, 0, 4, 4);
TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwMajorVersion, 4, 4, 4);
TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwMinorVersion, 8, 4, 4);
TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwBuildNumber, 12, 4, 4);
TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwPlatformId, 16, 4, 4);
TEST_FIELD(OSVERSIONINFOEXA, CHAR[128], szCSDVersion, 20, 128, 1);
TEST_FIELD(OSVERSIONINFOEXA, WORD, wServicePackMajor, 148, 2, 2);
TEST_FIELD(OSVERSIONINFOEXA, WORD, wServicePackMinor, 150, 2, 2);
TEST_FIELD(OSVERSIONINFOEXA, WORD, wSuiteMask, 152, 2, 2);
TEST_FIELD(OSVERSIONINFOEXA, BYTE, wProductType, 154, 1, 1);
TEST_FIELD(OSVERSIONINFOEXA, BYTE, wReserved, 155, 1, 1);
}
static void test_pack_OSVERSIONINFOEXW(void)
{
/* OSVERSIONINFOEXW (pack 4) */
TEST_TYPE(OSVERSIONINFOEXW, 284, 4);
TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwMajorVersion, 4, 4, 4);
TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwMinorVersion, 8, 4, 4);
TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwBuildNumber, 12, 4, 4);
TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwPlatformId, 16, 4, 4);
TEST_FIELD(OSVERSIONINFOEXW, WCHAR[128], szCSDVersion, 20, 256, 2);
TEST_FIELD(OSVERSIONINFOEXW, WORD, wServicePackMajor, 276, 2, 2);
TEST_FIELD(OSVERSIONINFOEXW, WORD, wServicePackMinor, 278, 2, 2);
TEST_FIELD(OSVERSIONINFOEXW, WORD, wSuiteMask, 280, 2, 2);
TEST_FIELD(OSVERSIONINFOEXW, BYTE, wProductType, 282, 1, 1);
TEST_FIELD(OSVERSIONINFOEXW, BYTE, wReserved, 283, 1, 1);
}
static void test_pack_OSVERSIONINFOW(void)
{
/* OSVERSIONINFOW (pack 4) */
TEST_TYPE(OSVERSIONINFOW, 276, 4);
TEST_FIELD(OSVERSIONINFOW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
TEST_FIELD(OSVERSIONINFOW, DWORD, dwMajorVersion, 4, 4, 4);
TEST_FIELD(OSVERSIONINFOW, DWORD, dwMinorVersion, 8, 4, 4);
TEST_FIELD(OSVERSIONINFOW, DWORD, dwBuildNumber, 12, 4, 4);
TEST_FIELD(OSVERSIONINFOW, DWORD, dwPlatformId, 16, 4, 4);
TEST_FIELD(OSVERSIONINFOW, WCHAR[128], szCSDVersion, 20, 256, 2);
}
static void test_pack_POSVERSIONINFOA(void)
{
/* POSVERSIONINFOA */
TEST_TYPE(POSVERSIONINFOA, 4, 4);
TEST_TYPE_POINTER(POSVERSIONINFOA, 148, 4);
}
static void test_pack_POSVERSIONINFOEXA(void)
{
/* POSVERSIONINFOEXA */
TEST_TYPE(POSVERSIONINFOEXA, 4, 4);
TEST_TYPE_POINTER(POSVERSIONINFOEXA, 156, 4);
}
static void test_pack_POSVERSIONINFOEXW(void)
{
/* POSVERSIONINFOEXW */
TEST_TYPE(POSVERSIONINFOEXW, 4, 4);
TEST_TYPE_POINTER(POSVERSIONINFOEXW, 284, 4);
}
static void test_pack_POSVERSIONINFOW(void)
{
/* POSVERSIONINFOW */
TEST_TYPE(POSVERSIONINFOW, 4, 4);
TEST_TYPE_POINTER(POSVERSIONINFOW, 276, 4);
}
static void test_pack_LPLONG(void)
{
/* LPLONG */
TEST_TYPE(LPLONG, 4, 4);
}
static void test_pack_LPVOID(void)
{
/* LPVOID */
TEST_TYPE(LPVOID, 4, 4);
}
static void test_pack_PHKEY(void)
{
/* PHKEY */
TEST_TYPE(PHKEY, 4, 4);
}
static void test_pack_ACTCTXA(void)
{
/* ACTCTXA (pack 4) */
TEST_TYPE(ACTCTXA, 32, 4);
TEST_FIELD(ACTCTXA, ULONG, cbSize, 0, 4, 4);
TEST_FIELD(ACTCTXA, DWORD, dwFlags, 4, 4, 4);
TEST_FIELD(ACTCTXA, LPCSTR, lpSource, 8, 4, 4);
TEST_FIELD(ACTCTXA, USHORT, wProcessorArchitecture, 12, 2, 2);
TEST_FIELD(ACTCTXA, LANGID, wLangId, 14, 2, 2);
TEST_FIELD(ACTCTXA, LPCSTR, lpAssemblyDirectory, 16, 4, 4);
TEST_FIELD(ACTCTXA, LPCSTR, lpResourceName, 20, 4, 4);
TEST_FIELD(ACTCTXA, LPCSTR, lpApplicationName, 24, 4, 4);
TEST_FIELD(ACTCTXA, HMODULE, hModule, 28, 4, 4);
}
static void test_pack_ACTCTXW(void)
{
/* ACTCTXW (pack 4) */
TEST_TYPE(ACTCTXW, 32, 4);
TEST_FIELD(ACTCTXW, ULONG, cbSize, 0, 4, 4);
TEST_FIELD(ACTCTXW, DWORD, dwFlags, 4, 4, 4);
TEST_FIELD(ACTCTXW, LPCWSTR, lpSource, 8, 4, 4);
TEST_FIELD(ACTCTXW, USHORT, wProcessorArchitecture, 12, 2, 2);
TEST_FIELD(ACTCTXW, LANGID, wLangId, 14, 2, 2);
TEST_FIELD(ACTCTXW, LPCWSTR, lpAssemblyDirectory, 16, 4, 4);
TEST_FIELD(ACTCTXW, LPCWSTR, lpResourceName, 20, 4, 4);
TEST_FIELD(ACTCTXW, LPCWSTR, lpApplicationName, 24, 4, 4);
TEST_FIELD(ACTCTXW, HMODULE, hModule, 28, 4, 4);
}
static void test_pack_ACTCTX_SECTION_KEYED_DATA(void)
{
/* ACTCTX_SECTION_KEYED_DATA (pack 4) */
TEST_TYPE(ACTCTX_SECTION_KEYED_DATA, 64, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, cbSize, 0, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulDataFormatVersion, 4, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, PVOID, lpData, 8, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulLength, 12, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, PVOID, lpSectionGlobalData, 16, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulSectionGlobalDataLength, 20, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, PVOID, lpSectionBase, 24, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulSectionTotalLength, 28, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, HANDLE, hActCtx, 32, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulAssemblyRosterIndex, 36, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ULONG, ulFlags, 40, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA, ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, AssemblyMetadata, 44, 20, 4);
}
static void test_pack_ACTCTX_SECTION_KEYED_DATA_2600(void)
{
/* ACTCTX_SECTION_KEYED_DATA_2600 (pack 4) */
TEST_TYPE(ACTCTX_SECTION_KEYED_DATA_2600, 40, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, cbSize, 0, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulDataFormatVersion, 4, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, PVOID, lpData, 8, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulLength, 12, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, PVOID, lpSectionGlobalData, 16, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulSectionGlobalDataLength, 20, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, PVOID, lpSectionBase, 24, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulSectionTotalLength, 28, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, HANDLE, hActCtx, 32, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_2600, ULONG, ulAssemblyRosterIndex, 36, 4, 4);
}
static void test_pack_ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA(void)
{
/* ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA (pack 4) */
TEST_TYPE(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, 20, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, PVOID, lpInformation, 0, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, PVOID, lpSectionBase, 4, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, ULONG, ulSectionLength, 8, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, PVOID, lpSectionGlobalDataBase, 12, 4, 4);
TEST_FIELD(ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, ULONG, ulSectionGlobalDataLength, 16, 4, 4);
}
static void test_pack_ACTIVATION_CONTEXT_BASIC_INFORMATION(void)
{
/* ACTIVATION_CONTEXT_BASIC_INFORMATION (pack 4) */
TEST_TYPE(ACTIVATION_CONTEXT_BASIC_INFORMATION, 8, 4);
TEST_FIELD(ACTIVATION_CONTEXT_BASIC_INFORMATION, HANDLE, hActCtx, 0, 4, 4);
TEST_FIELD(ACTIVATION_CONTEXT_BASIC_INFORMATION, DWORD, dwFlags, 4, 4, 4);
}
static void test_pack_BY_HANDLE_FILE_INFORMATION(void) static void test_pack_BY_HANDLE_FILE_INFORMATION(void)
{ {
/* BY_HANDLE_FILE_INFORMATION (pack 4) */ /* BY_HANDLE_FILE_INFORMATION (pack 4) */
@ -125,14 +340,6 @@ static void test_pack_BY_HANDLE_FILE_INFORMATION(void)
TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, nFileIndexLow, 48, 4, 4); TEST_FIELD(BY_HANDLE_FILE_INFORMATION, DWORD, nFileIndexLow, 48, 4, 4);
} }
static void test_pack_COMMCONFIG(void)
{
/* COMMCONFIG (pack 4) */
TEST_FIELD(COMMCONFIG, DWORD, dwSize, 0, 4, 4);
TEST_FIELD(COMMCONFIG, WORD, wVersion, 4, 2, 2);
TEST_FIELD(COMMCONFIG, WORD, wReserved, 6, 2, 2);
}
static void test_pack_COMMPROP(void) static void test_pack_COMMPROP(void)
{ {
/* COMMPROP (pack 4) */ /* COMMPROP (pack 4) */
@ -168,14 +375,6 @@ static void test_pack_COMMTIMEOUTS(void)
TEST_FIELD(COMMTIMEOUTS, DWORD, WriteTotalTimeoutConstant, 16, 4, 4); TEST_FIELD(COMMTIMEOUTS, DWORD, WriteTotalTimeoutConstant, 16, 4, 4);
} }
static void test_pack_COMSTAT(void)
{
/* COMSTAT (pack 4) */
TEST_TYPE(COMSTAT, 12, 4);
TEST_FIELD(COMSTAT, DWORD, cbInQue, 4, 4, 4);
TEST_FIELD(COMSTAT, DWORD, cbOutQue, 8, 4, 4);
}
static void test_pack_CREATE_PROCESS_DEBUG_INFO(void) static void test_pack_CREATE_PROCESS_DEBUG_INFO(void)
{ {
/* CREATE_PROCESS_DEBUG_INFO (pack 4) */ /* CREATE_PROCESS_DEBUG_INFO (pack 4) */
@ -213,19 +412,40 @@ static void test_pack_CRITICAL_SECTION_DEBUG(void)
TEST_TYPE(CRITICAL_SECTION_DEBUG, 32, 4); TEST_TYPE(CRITICAL_SECTION_DEBUG, 32, 4);
} }
static void test_pack_DCB(void) static void test_pack_ENUMRESLANGPROCA(void)
{ {
/* DCB (pack 4) */ /* ENUMRESLANGPROCA */
TEST_FIELD(DCB, DWORD, DCBlength, 0, 4, 4); TEST_TYPE(ENUMRESLANGPROCA, 4, 4);
TEST_FIELD(DCB, DWORD, BaudRate, 4, 4, 4);
} }
static void test_pack_DEBUG_EVENT(void) static void test_pack_ENUMRESLANGPROCW(void)
{ {
/* DEBUG_EVENT (pack 4) */ /* ENUMRESLANGPROCW */
TEST_FIELD(DEBUG_EVENT, DWORD, dwDebugEventCode, 0, 4, 4); TEST_TYPE(ENUMRESLANGPROCW, 4, 4);
TEST_FIELD(DEBUG_EVENT, DWORD, dwProcessId, 4, 4, 4); }
TEST_FIELD(DEBUG_EVENT, DWORD, dwThreadId, 8, 4, 4);
static void test_pack_ENUMRESNAMEPROCA(void)
{
/* ENUMRESNAMEPROCA */
TEST_TYPE(ENUMRESNAMEPROCA, 4, 4);
}
static void test_pack_ENUMRESNAMEPROCW(void)
{
/* ENUMRESNAMEPROCW */
TEST_TYPE(ENUMRESNAMEPROCW, 4, 4);
}
static void test_pack_ENUMRESTYPEPROCA(void)
{
/* ENUMRESTYPEPROCA */
TEST_TYPE(ENUMRESTYPEPROCA, 4, 4);
}
static void test_pack_ENUMRESTYPEPROCW(void)
{
/* ENUMRESTYPEPROCW */
TEST_TYPE(ENUMRESTYPEPROCW, 4, 4);
} }
static void test_pack_EXCEPTION_DEBUG_INFO(void) static void test_pack_EXCEPTION_DEBUG_INFO(void)
@ -268,13 +488,6 @@ static void test_pack_HW_PROFILE_INFOW(void)
TEST_FIELD(HW_PROFILE_INFOW, WCHAR[MAX_PROFILE_LEN], szHwProfileName, 82, 160, 2); TEST_FIELD(HW_PROFILE_INFOW, WCHAR[MAX_PROFILE_LEN], szHwProfileName, 82, 160, 2);
} }
static void test_pack_LDT_ENTRY(void)
{
/* LDT_ENTRY (pack 4) */
TEST_FIELD(LDT_ENTRY, WORD, LimitLow, 0, 2, 2);
TEST_FIELD(LDT_ENTRY, WORD, BaseLow, 2, 2, 2);
}
static void test_pack_LOAD_DLL_DEBUG_INFO(void) static void test_pack_LOAD_DLL_DEBUG_INFO(void)
{ {
/* LOAD_DLL_DEBUG_INFO (pack 4) */ /* LOAD_DLL_DEBUG_INFO (pack 4) */
@ -294,12 +507,6 @@ static void test_pack_LPBY_HANDLE_FILE_INFORMATION(void)
TEST_TYPE_POINTER(LPBY_HANDLE_FILE_INFORMATION, 52, 4); TEST_TYPE_POINTER(LPBY_HANDLE_FILE_INFORMATION, 52, 4);
} }
static void test_pack_LPCOMMCONFIG(void)
{
/* LPCOMMCONFIG */
TEST_TYPE(LPCOMMCONFIG, 4, 4);
}
static void test_pack_LPCOMMPROP(void) static void test_pack_LPCOMMPROP(void)
{ {
/* LPCOMMPROP */ /* LPCOMMPROP */
@ -314,19 +521,6 @@ static void test_pack_LPCOMMTIMEOUTS(void)
TEST_TYPE_POINTER(LPCOMMTIMEOUTS, 20, 4); TEST_TYPE_POINTER(LPCOMMTIMEOUTS, 20, 4);
} }
static void test_pack_LPCOMSTAT(void)
{
/* LPCOMSTAT */
TEST_TYPE(LPCOMSTAT, 4, 4);
TEST_TYPE_POINTER(LPCOMSTAT, 12, 4);
}
static void test_pack_LPCONTEXT(void)
{
/* LPCONTEXT */
TEST_TYPE(LPCONTEXT, 4, 4);
}
static void test_pack_LPCRITICAL_SECTION(void) static void test_pack_LPCRITICAL_SECTION(void)
{ {
/* LPCRITICAL_SECTION */ /* LPCRITICAL_SECTION */
@ -339,18 +533,6 @@ static void test_pack_LPCRITICAL_SECTION_DEBUG(void)
TEST_TYPE(LPCRITICAL_SECTION_DEBUG, 4, 4); TEST_TYPE(LPCRITICAL_SECTION_DEBUG, 4, 4);
} }
static void test_pack_LPDCB(void)
{
/* LPDCB */
TEST_TYPE(LPDCB, 4, 4);
}
static void test_pack_LPDEBUG_EVENT(void)
{
/* LPDEBUG_EVENT */
TEST_TYPE(LPDEBUG_EVENT, 4, 4);
}
static void test_pack_LPEXCEPTION_POINTERS(void) static void test_pack_LPEXCEPTION_POINTERS(void)
{ {
/* LPEXCEPTION_POINTERS */ /* LPEXCEPTION_POINTERS */
@ -383,12 +565,6 @@ static void test_pack_LPHW_PROFILE_INFOW(void)
TEST_TYPE_POINTER(LPHW_PROFILE_INFOW, 244, 4); TEST_TYPE_POINTER(LPHW_PROFILE_INFOW, 244, 4);
} }
static void test_pack_LPLDT_ENTRY(void)
{
/* LPLDT_ENTRY */
TEST_TYPE(LPLDT_ENTRY, 4, 4);
}
static void test_pack_LPMEMORYSTATUS(void) static void test_pack_LPMEMORYSTATUS(void)
{ {
/* LPMEMORYSTATUS */ /* LPMEMORYSTATUS */
@ -403,32 +579,6 @@ static void test_pack_LPOFSTRUCT(void)
TEST_TYPE_POINTER(LPOFSTRUCT, 136, 2); TEST_TYPE_POINTER(LPOFSTRUCT, 136, 2);
} }
static void test_pack_LPOSVERSIONINFOA(void)
{
/* LPOSVERSIONINFOA */
TEST_TYPE(LPOSVERSIONINFOA, 4, 4);
TEST_TYPE_POINTER(LPOSVERSIONINFOA, 148, 4);
}
static void test_pack_LPOSVERSIONINFOEXA(void)
{
/* LPOSVERSIONINFOEXA */
TEST_TYPE(LPOSVERSIONINFOEXA, 4, 4);
}
static void test_pack_LPOSVERSIONINFOEXW(void)
{
/* LPOSVERSIONINFOEXW */
TEST_TYPE(LPOSVERSIONINFOEXW, 4, 4);
}
static void test_pack_LPOSVERSIONINFOW(void)
{
/* LPOSVERSIONINFOW */
TEST_TYPE(LPOSVERSIONINFOW, 4, 4);
TEST_TYPE_POINTER(LPOSVERSIONINFOW, 276, 4);
}
static void test_pack_LPOVERLAPPED(void) static void test_pack_LPOVERLAPPED(void)
{ {
/* LPOVERLAPPED */ /* LPOVERLAPPED */
@ -442,12 +592,6 @@ static void test_pack_LPOVERLAPPED_COMPLETION_ROUTINE(void)
TEST_TYPE(LPOVERLAPPED_COMPLETION_ROUTINE, 4, 4); TEST_TYPE(LPOVERLAPPED_COMPLETION_ROUTINE, 4, 4);
} }
static void test_pack_LPPROCESS_HEAP_ENTRY(void)
{
/* LPPROCESS_HEAP_ENTRY */
TEST_TYPE(LPPROCESS_HEAP_ENTRY, 4, 4);
}
static void test_pack_LPPROCESS_INFORMATION(void) static void test_pack_LPPROCESS_INFORMATION(void)
{ {
/* LPPROCESS_INFORMATION */ /* LPPROCESS_INFORMATION */
@ -472,6 +616,7 @@ static void test_pack_LPSTARTUPINFOA(void)
{ {
/* LPSTARTUPINFOA */ /* LPSTARTUPINFOA */
TEST_TYPE(LPSTARTUPINFOA, 4, 4); TEST_TYPE(LPSTARTUPINFOA, 4, 4);
TEST_TYPE_POINTER(LPSTARTUPINFOA, 68, 4);
} }
static void test_pack_LPSTARTUPINFOW(void) static void test_pack_LPSTARTUPINFOW(void)
@ -488,12 +633,6 @@ static void test_pack_LPSYSTEMTIME(void)
TEST_TYPE_POINTER(LPSYSTEMTIME, 16, 2); TEST_TYPE_POINTER(LPSYSTEMTIME, 16, 2);
} }
static void test_pack_LPSYSTEM_INFO(void)
{
/* LPSYSTEM_INFO */
TEST_TYPE(LPSYSTEM_INFO, 4, 4);
}
static void test_pack_LPSYSTEM_POWER_STATUS(void) static void test_pack_LPSYSTEM_POWER_STATUS(void)
{ {
/* LPSYSTEM_POWER_STATUS */ /* LPSYSTEM_POWER_STATUS */
@ -535,13 +674,6 @@ static void test_pack_LPWIN32_FIND_DATAW(void)
TEST_TYPE_POINTER(LPWIN32_FIND_DATAW, 592, 4); TEST_TYPE_POINTER(LPWIN32_FIND_DATAW, 592, 4);
} }
static void test_pack_LPWIN32_STREAM_ID(void)
{
/* LPWIN32_STREAM_ID */
TEST_TYPE(LPWIN32_STREAM_ID, 4, 4);
TEST_TYPE_POINTER(LPWIN32_STREAM_ID, 24, 4);
}
static void test_pack_MEMORYSTATUS(void) static void test_pack_MEMORYSTATUS(void)
{ {
/* MEMORYSTATUS (pack 4) */ /* MEMORYSTATUS (pack 4) */
@ -568,59 +700,13 @@ static void test_pack_OFSTRUCT(void)
TEST_FIELD(OFSTRUCT, BYTE[OFS_MAXPATHNAME], szPathName, 8, 128, 1); TEST_FIELD(OFSTRUCT, BYTE[OFS_MAXPATHNAME], szPathName, 8, 128, 1);
} }
static void test_pack_OSVERSIONINFOA(void)
{
/* OSVERSIONINFOA (pack 4) */
TEST_TYPE(OSVERSIONINFOA, 148, 4);
TEST_FIELD(OSVERSIONINFOA, DWORD, dwOSVersionInfoSize, 0, 4, 4);
TEST_FIELD(OSVERSIONINFOA, DWORD, dwMajorVersion, 4, 4, 4);
TEST_FIELD(OSVERSIONINFOA, DWORD, dwMinorVersion, 8, 4, 4);
TEST_FIELD(OSVERSIONINFOA, DWORD, dwBuildNumber, 12, 4, 4);
TEST_FIELD(OSVERSIONINFOA, DWORD, dwPlatformId, 16, 4, 4);
TEST_FIELD(OSVERSIONINFOA, CHAR[128], szCSDVersion, 20, 128, 1);
}
static void test_pack_OSVERSIONINFOEXA(void)
{
/* OSVERSIONINFOEXA (pack 4) */
TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwOSVersionInfoSize, 0, 4, 4);
TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwMajorVersion, 4, 4, 4);
TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwMinorVersion, 8, 4, 4);
TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwBuildNumber, 12, 4, 4);
TEST_FIELD(OSVERSIONINFOEXA, DWORD, dwPlatformId, 16, 4, 4);
TEST_FIELD(OSVERSIONINFOEXA, CHAR[128], szCSDVersion, 20, 128, 1);
TEST_FIELD(OSVERSIONINFOEXA, WORD, wServicePackMajor, 148, 2, 2);
TEST_FIELD(OSVERSIONINFOEXA, WORD, wServicePackMinor, 150, 2, 2);
}
static void test_pack_OSVERSIONINFOEXW(void)
{
/* OSVERSIONINFOEXW (pack 4) */
TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwMajorVersion, 4, 4, 4);
TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwMinorVersion, 8, 4, 4);
TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwBuildNumber, 12, 4, 4);
TEST_FIELD(OSVERSIONINFOEXW, DWORD, dwPlatformId, 16, 4, 4);
TEST_FIELD(OSVERSIONINFOEXW, WCHAR[128], szCSDVersion, 20, 256, 2);
TEST_FIELD(OSVERSIONINFOEXW, WORD, wServicePackMajor, 276, 2, 2);
TEST_FIELD(OSVERSIONINFOEXW, WORD, wServicePackMinor, 278, 2, 2);
}
static void test_pack_OSVERSIONINFOW(void)
{
/* OSVERSIONINFOW (pack 4) */
TEST_TYPE(OSVERSIONINFOW, 276, 4);
TEST_FIELD(OSVERSIONINFOW, DWORD, dwOSVersionInfoSize, 0, 4, 4);
TEST_FIELD(OSVERSIONINFOW, DWORD, dwMajorVersion, 4, 4, 4);
TEST_FIELD(OSVERSIONINFOW, DWORD, dwMinorVersion, 8, 4, 4);
TEST_FIELD(OSVERSIONINFOW, DWORD, dwBuildNumber, 12, 4, 4);
TEST_FIELD(OSVERSIONINFOW, DWORD, dwPlatformId, 16, 4, 4);
TEST_FIELD(OSVERSIONINFOW, WCHAR[128], szCSDVersion, 20, 256, 2);
}
static void test_pack_OUTPUT_DEBUG_STRING_INFO(void) static void test_pack_OUTPUT_DEBUG_STRING_INFO(void)
{ {
/* OUTPUT_DEBUG_STRING_INFO (pack 4) */ /* OUTPUT_DEBUG_STRING_INFO (pack 4) */
TEST_TYPE(OUTPUT_DEBUG_STRING_INFO, 8, 4);
TEST_FIELD(OUTPUT_DEBUG_STRING_INFO, LPSTR, lpDebugStringData, 0, 4, 4);
TEST_FIELD(OUTPUT_DEBUG_STRING_INFO, WORD, fUnicode, 4, 2, 2);
TEST_FIELD(OUTPUT_DEBUG_STRING_INFO, WORD, nDebugStringLength, 6, 2, 2);
} }
static void test_pack_OVERLAPPED(void) static void test_pack_OVERLAPPED(void)
@ -634,6 +720,48 @@ static void test_pack_OVERLAPPED(void)
TEST_FIELD(OVERLAPPED, HANDLE, hEvent, 16, 4, 4); TEST_FIELD(OVERLAPPED, HANDLE, hEvent, 16, 4, 4);
} }
static void test_pack_PACTCTXA(void)
{
/* PACTCTXA */
TEST_TYPE(PACTCTXA, 4, 4);
TEST_TYPE_POINTER(PACTCTXA, 32, 4);
}
static void test_pack_PACTCTXW(void)
{
/* PACTCTXW */
TEST_TYPE(PACTCTXW, 4, 4);
TEST_TYPE_POINTER(PACTCTXW, 32, 4);
}
static void test_pack_PACTCTX_SECTION_KEYED_DATA(void)
{
/* PACTCTX_SECTION_KEYED_DATA */
TEST_TYPE(PACTCTX_SECTION_KEYED_DATA, 4, 4);
TEST_TYPE_POINTER(PACTCTX_SECTION_KEYED_DATA, 64, 4);
}
static void test_pack_PACTCTX_SECTION_KEYED_DATA_2600(void)
{
/* PACTCTX_SECTION_KEYED_DATA_2600 */
TEST_TYPE(PACTCTX_SECTION_KEYED_DATA_2600, 4, 4);
TEST_TYPE_POINTER(PACTCTX_SECTION_KEYED_DATA_2600, 40, 4);
}
static void test_pack_PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA(void)
{
/* PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA */
TEST_TYPE(PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, 4, 4);
TEST_TYPE_POINTER(PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, 20, 4);
}
static void test_pack_PACTIVATION_CONTEXT_BASIC_INFORMATION(void)
{
/* PACTIVATION_CONTEXT_BASIC_INFORMATION */
TEST_TYPE(PACTIVATION_CONTEXT_BASIC_INFORMATION, 4, 4);
TEST_TYPE_POINTER(PACTIVATION_CONTEXT_BASIC_INFORMATION, 8, 4);
}
static void test_pack_PAPCFUNC(void) static void test_pack_PAPCFUNC(void)
{ {
/* PAPCFUNC */ /* PAPCFUNC */
@ -647,6 +775,41 @@ static void test_pack_PBY_HANDLE_FILE_INFORMATION(void)
TEST_TYPE_POINTER(PBY_HANDLE_FILE_INFORMATION, 52, 4); TEST_TYPE_POINTER(PBY_HANDLE_FILE_INFORMATION, 52, 4);
} }
static void test_pack_PCACTCTXA(void)
{
/* PCACTCTXA */
TEST_TYPE(PCACTCTXA, 4, 4);
TEST_TYPE_POINTER(PCACTCTXA, 32, 4);
}
static void test_pack_PCACTCTXW(void)
{
/* PCACTCTXW */
TEST_TYPE(PCACTCTXW, 4, 4);
TEST_TYPE_POINTER(PCACTCTXW, 32, 4);
}
static void test_pack_PCACTCTX_SECTION_KEYED_DATA(void)
{
/* PCACTCTX_SECTION_KEYED_DATA */
TEST_TYPE(PCACTCTX_SECTION_KEYED_DATA, 4, 4);
TEST_TYPE_POINTER(PCACTCTX_SECTION_KEYED_DATA, 64, 4);
}
static void test_pack_PCACTCTX_SECTION_KEYED_DATA_2600(void)
{
/* PCACTCTX_SECTION_KEYED_DATA_2600 */
TEST_TYPE(PCACTCTX_SECTION_KEYED_DATA_2600, 4, 4);
TEST_TYPE_POINTER(PCACTCTX_SECTION_KEYED_DATA_2600, 40, 4);
}
static void test_pack_PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA(void)
{
/* PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA */
TEST_TYPE(PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, 4, 4);
TEST_TYPE_POINTER(PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, 20, 4);
}
static void test_pack_PCRITICAL_SECTION(void) static void test_pack_PCRITICAL_SECTION(void)
{ {
/* PCRITICAL_SECTION */ /* PCRITICAL_SECTION */
@ -672,38 +835,6 @@ static void test_pack_POFSTRUCT(void)
TEST_TYPE_POINTER(POFSTRUCT, 136, 2); TEST_TYPE_POINTER(POFSTRUCT, 136, 2);
} }
static void test_pack_POSVERSIONINFOA(void)
{
/* POSVERSIONINFOA */
TEST_TYPE(POSVERSIONINFOA, 4, 4);
TEST_TYPE_POINTER(POSVERSIONINFOA, 148, 4);
}
static void test_pack_POSVERSIONINFOEXA(void)
{
/* POSVERSIONINFOEXA */
TEST_TYPE(POSVERSIONINFOEXA, 4, 4);
}
static void test_pack_POSVERSIONINFOEXW(void)
{
/* POSVERSIONINFOEXW */
TEST_TYPE(POSVERSIONINFOEXW, 4, 4);
}
static void test_pack_POSVERSIONINFOW(void)
{
/* POSVERSIONINFOW */
TEST_TYPE(POSVERSIONINFOW, 4, 4);
TEST_TYPE_POINTER(POSVERSIONINFOW, 276, 4);
}
static void test_pack_PPROCESS_HEAP_ENTRY(void)
{
/* PPROCESS_HEAP_ENTRY */
TEST_TYPE(PPROCESS_HEAP_ENTRY, 4, 4);
}
static void test_pack_PPROCESS_INFORMATION(void) static void test_pack_PPROCESS_INFORMATION(void)
{ {
/* PPROCESS_INFORMATION */ /* PPROCESS_INFORMATION */
@ -711,14 +842,10 @@ static void test_pack_PPROCESS_INFORMATION(void)
TEST_TYPE_POINTER(PPROCESS_INFORMATION, 16, 4); TEST_TYPE_POINTER(PPROCESS_INFORMATION, 16, 4);
} }
static void test_pack_PROCESS_HEAP_ENTRY(void) static void test_pack_PQUERYACTCTXW_FUNC(void)
{ {
/* PROCESS_HEAP_ENTRY (pack 4) */ /* PQUERYACTCTXW_FUNC */
TEST_FIELD(PROCESS_HEAP_ENTRY, LPVOID, lpData, 0, 4, 4); TEST_TYPE(PQUERYACTCTXW_FUNC, 4, 4);
TEST_FIELD(PROCESS_HEAP_ENTRY, DWORD, cbData, 4, 4, 4);
TEST_FIELD(PROCESS_HEAP_ENTRY, BYTE, cbOverhead, 8, 1, 1);
TEST_FIELD(PROCESS_HEAP_ENTRY, BYTE, iRegionIndex, 9, 1, 1);
TEST_FIELD(PROCESS_HEAP_ENTRY, WORD, wFlags, 10, 2, 2);
} }
static void test_pack_PROCESS_INFORMATION(void) static void test_pack_PROCESS_INFORMATION(void)
@ -792,7 +919,25 @@ static void test_pack_SECURITY_ATTRIBUTES(void)
static void test_pack_STARTUPINFOA(void) static void test_pack_STARTUPINFOA(void)
{ {
/* STARTUPINFOA (pack 4) */ /* STARTUPINFOA (pack 4) */
TEST_TYPE(STARTUPINFOA, 68, 4);
TEST_FIELD(STARTUPINFOA, DWORD, cb, 0, 4, 4); TEST_FIELD(STARTUPINFOA, DWORD, cb, 0, 4, 4);
TEST_FIELD(STARTUPINFOA, LPSTR, lpReserved, 4, 4, 4);
TEST_FIELD(STARTUPINFOA, LPSTR, lpDesktop, 8, 4, 4);
TEST_FIELD(STARTUPINFOA, LPSTR, lpTitle, 12, 4, 4);
TEST_FIELD(STARTUPINFOA, DWORD, dwX, 16, 4, 4);
TEST_FIELD(STARTUPINFOA, DWORD, dwY, 20, 4, 4);
TEST_FIELD(STARTUPINFOA, DWORD, dwXSize, 24, 4, 4);
TEST_FIELD(STARTUPINFOA, DWORD, dwYSize, 28, 4, 4);
TEST_FIELD(STARTUPINFOA, DWORD, dwXCountChars, 32, 4, 4);
TEST_FIELD(STARTUPINFOA, DWORD, dwYCountChars, 36, 4, 4);
TEST_FIELD(STARTUPINFOA, DWORD, dwFillAttribute, 40, 4, 4);
TEST_FIELD(STARTUPINFOA, DWORD, dwFlags, 44, 4, 4);
TEST_FIELD(STARTUPINFOA, WORD, wShowWindow, 48, 2, 2);
TEST_FIELD(STARTUPINFOA, WORD, cbReserved2, 50, 2, 2);
TEST_FIELD(STARTUPINFOA, BYTE *, lpReserved2, 52, 4, 4);
TEST_FIELD(STARTUPINFOA, HANDLE, hStdInput, 56, 4, 4);
TEST_FIELD(STARTUPINFOA, HANDLE, hStdOutput, 60, 4, 4);
TEST_FIELD(STARTUPINFOA, HANDLE, hStdError, 64, 4, 4);
} }
static void test_pack_STARTUPINFOW(void) static void test_pack_STARTUPINFOW(void)
@ -819,6 +964,14 @@ static void test_pack_STARTUPINFOW(void)
TEST_FIELD(STARTUPINFOW, HANDLE, hStdError, 64, 4, 4); TEST_FIELD(STARTUPINFOW, HANDLE, hStdError, 64, 4, 4);
} }
static void test_pack_SYSLEVEL(void)
{
/* SYSLEVEL (pack 4) */
TEST_TYPE(SYSLEVEL, 28, 4);
TEST_FIELD(SYSLEVEL, CRITICAL_SECTION, crst, 0, 24, 4);
TEST_FIELD(SYSLEVEL, INT, level, 24, 4, 4);
}
static void test_pack_SYSTEMTIME(void) static void test_pack_SYSTEMTIME(void)
{ {
/* SYSTEMTIME (pack 4) */ /* SYSTEMTIME (pack 4) */
@ -865,6 +1018,12 @@ static void test_pack_UNLOAD_DLL_DEBUG_INFO(void)
TEST_FIELD(UNLOAD_DLL_DEBUG_INFO, LPVOID, lpBaseOfDll, 0, 4, 4); TEST_FIELD(UNLOAD_DLL_DEBUG_INFO, LPVOID, lpBaseOfDll, 0, 4, 4);
} }
static void test_pack_WAITORTIMERCALLBACK(void)
{
/* WAITORTIMERCALLBACK */
TEST_TYPE(WAITORTIMERCALLBACK, 4, 4);
}
static void test_pack_WIN32_FILE_ATTRIBUTE_DATA(void) static void test_pack_WIN32_FILE_ATTRIBUTE_DATA(void)
{ {
/* WIN32_FILE_ATTRIBUTE_DATA (pack 4) */ /* WIN32_FILE_ATTRIBUTE_DATA (pack 4) */
@ -911,40 +1070,42 @@ static void test_pack_WIN32_FIND_DATAW(void)
static void test_pack(void) static void test_pack(void)
{ {
test_pack_ACTCTXA();
test_pack_ACTCTXW();
test_pack_ACTCTX_SECTION_KEYED_DATA();
test_pack_ACTCTX_SECTION_KEYED_DATA_2600();
test_pack_ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA();
test_pack_ACTIVATION_CONTEXT_BASIC_INFORMATION();
test_pack_BY_HANDLE_FILE_INFORMATION(); test_pack_BY_HANDLE_FILE_INFORMATION();
test_pack_COMMCONFIG();
test_pack_COMMPROP(); test_pack_COMMPROP();
test_pack_COMMTIMEOUTS(); test_pack_COMMTIMEOUTS();
test_pack_COMSTAT();
test_pack_CREATE_PROCESS_DEBUG_INFO(); test_pack_CREATE_PROCESS_DEBUG_INFO();
test_pack_CREATE_THREAD_DEBUG_INFO(); test_pack_CREATE_THREAD_DEBUG_INFO();
test_pack_CRITICAL_SECTION(); test_pack_CRITICAL_SECTION();
test_pack_CRITICAL_SECTION_DEBUG(); test_pack_CRITICAL_SECTION_DEBUG();
test_pack_DCB(); test_pack_ENUMRESLANGPROCA();
test_pack_DEBUG_EVENT(); test_pack_ENUMRESLANGPROCW();
test_pack_ENUMRESNAMEPROCA();
test_pack_ENUMRESNAMEPROCW();
test_pack_ENUMRESTYPEPROCA();
test_pack_ENUMRESTYPEPROCW();
test_pack_EXCEPTION_DEBUG_INFO(); test_pack_EXCEPTION_DEBUG_INFO();
test_pack_EXIT_PROCESS_DEBUG_INFO(); test_pack_EXIT_PROCESS_DEBUG_INFO();
test_pack_EXIT_THREAD_DEBUG_INFO(); test_pack_EXIT_THREAD_DEBUG_INFO();
test_pack_HW_PROFILE_INFOA(); test_pack_HW_PROFILE_INFOA();
test_pack_HW_PROFILE_INFOW(); test_pack_HW_PROFILE_INFOW();
test_pack_LDT_ENTRY();
test_pack_LOAD_DLL_DEBUG_INFO(); test_pack_LOAD_DLL_DEBUG_INFO();
test_pack_LPBY_HANDLE_FILE_INFORMATION(); test_pack_LPBY_HANDLE_FILE_INFORMATION();
test_pack_LPCOMMCONFIG();
test_pack_LPCOMMPROP(); test_pack_LPCOMMPROP();
test_pack_LPCOMMTIMEOUTS(); test_pack_LPCOMMTIMEOUTS();
test_pack_LPCOMSTAT();
test_pack_LPCONTEXT();
test_pack_LPCRITICAL_SECTION(); test_pack_LPCRITICAL_SECTION();
test_pack_LPCRITICAL_SECTION_DEBUG(); test_pack_LPCRITICAL_SECTION_DEBUG();
test_pack_LPDCB();
test_pack_LPDEBUG_EVENT();
test_pack_LPEXCEPTION_POINTERS(); test_pack_LPEXCEPTION_POINTERS();
test_pack_LPEXCEPTION_RECORD(); test_pack_LPEXCEPTION_RECORD();
test_pack_LPFIBER_START_ROUTINE(); test_pack_LPFIBER_START_ROUTINE();
test_pack_LPHW_PROFILE_INFOA(); test_pack_LPHW_PROFILE_INFOA();
test_pack_LPHW_PROFILE_INFOW(); test_pack_LPHW_PROFILE_INFOW();
test_pack_LPLDT_ENTRY(); test_pack_LPLONG();
test_pack_LPMEMORYSTATUS(); test_pack_LPMEMORYSTATUS();
test_pack_LPOFSTRUCT(); test_pack_LPOFSTRUCT();
test_pack_LPOSVERSIONINFOA(); test_pack_LPOSVERSIONINFOA();
@ -953,21 +1114,19 @@ static void test_pack(void)
test_pack_LPOSVERSIONINFOW(); test_pack_LPOSVERSIONINFOW();
test_pack_LPOVERLAPPED(); test_pack_LPOVERLAPPED();
test_pack_LPOVERLAPPED_COMPLETION_ROUTINE(); test_pack_LPOVERLAPPED_COMPLETION_ROUTINE();
test_pack_LPPROCESS_HEAP_ENTRY();
test_pack_LPPROCESS_INFORMATION(); test_pack_LPPROCESS_INFORMATION();
test_pack_LPPROGRESS_ROUTINE(); test_pack_LPPROGRESS_ROUTINE();
test_pack_LPSECURITY_ATTRIBUTES(); test_pack_LPSECURITY_ATTRIBUTES();
test_pack_LPSTARTUPINFOA(); test_pack_LPSTARTUPINFOA();
test_pack_LPSTARTUPINFOW(); test_pack_LPSTARTUPINFOW();
test_pack_LPSYSTEMTIME(); test_pack_LPSYSTEMTIME();
test_pack_LPSYSTEM_INFO();
test_pack_LPSYSTEM_POWER_STATUS(); test_pack_LPSYSTEM_POWER_STATUS();
test_pack_LPTHREAD_START_ROUTINE(); test_pack_LPTHREAD_START_ROUTINE();
test_pack_LPTIME_ZONE_INFORMATION(); test_pack_LPTIME_ZONE_INFORMATION();
test_pack_LPVOID();
test_pack_LPWIN32_FILE_ATTRIBUTE_DATA(); test_pack_LPWIN32_FILE_ATTRIBUTE_DATA();
test_pack_LPWIN32_FIND_DATAA(); test_pack_LPWIN32_FIND_DATAA();
test_pack_LPWIN32_FIND_DATAW(); test_pack_LPWIN32_FIND_DATAW();
test_pack_LPWIN32_STREAM_ID();
test_pack_MEMORYSTATUS(); test_pack_MEMORYSTATUS();
test_pack_OFSTRUCT(); test_pack_OFSTRUCT();
test_pack_OSVERSIONINFOA(); test_pack_OSVERSIONINFOA();
@ -976,19 +1135,30 @@ static void test_pack(void)
test_pack_OSVERSIONINFOW(); test_pack_OSVERSIONINFOW();
test_pack_OUTPUT_DEBUG_STRING_INFO(); test_pack_OUTPUT_DEBUG_STRING_INFO();
test_pack_OVERLAPPED(); test_pack_OVERLAPPED();
test_pack_PACTCTXA();
test_pack_PACTCTXW();
test_pack_PACTCTX_SECTION_KEYED_DATA();
test_pack_PACTCTX_SECTION_KEYED_DATA_2600();
test_pack_PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA();
test_pack_PACTIVATION_CONTEXT_BASIC_INFORMATION();
test_pack_PAPCFUNC(); test_pack_PAPCFUNC();
test_pack_PBY_HANDLE_FILE_INFORMATION(); test_pack_PBY_HANDLE_FILE_INFORMATION();
test_pack_PCACTCTXA();
test_pack_PCACTCTXW();
test_pack_PCACTCTX_SECTION_KEYED_DATA();
test_pack_PCACTCTX_SECTION_KEYED_DATA_2600();
test_pack_PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA();
test_pack_PCRITICAL_SECTION(); test_pack_PCRITICAL_SECTION();
test_pack_PCRITICAL_SECTION_DEBUG(); test_pack_PCRITICAL_SECTION_DEBUG();
test_pack_PFIBER_START_ROUTINE(); test_pack_PFIBER_START_ROUTINE();
test_pack_PHKEY();
test_pack_POFSTRUCT(); test_pack_POFSTRUCT();
test_pack_POSVERSIONINFOA(); test_pack_POSVERSIONINFOA();
test_pack_POSVERSIONINFOEXA(); test_pack_POSVERSIONINFOEXA();
test_pack_POSVERSIONINFOEXW(); test_pack_POSVERSIONINFOEXW();
test_pack_POSVERSIONINFOW(); test_pack_POSVERSIONINFOW();
test_pack_PPROCESS_HEAP_ENTRY();
test_pack_PPROCESS_INFORMATION(); test_pack_PPROCESS_INFORMATION();
test_pack_PROCESS_HEAP_ENTRY(); test_pack_PQUERYACTCTXW_FUNC();
test_pack_PROCESS_INFORMATION(); test_pack_PROCESS_INFORMATION();
test_pack_PSECURITY_ATTRIBUTES(); test_pack_PSECURITY_ATTRIBUTES();
test_pack_PSYSTEMTIME(); test_pack_PSYSTEMTIME();
@ -1000,10 +1170,12 @@ static void test_pack(void)
test_pack_SECURITY_ATTRIBUTES(); test_pack_SECURITY_ATTRIBUTES();
test_pack_STARTUPINFOA(); test_pack_STARTUPINFOA();
test_pack_STARTUPINFOW(); test_pack_STARTUPINFOW();
test_pack_SYSLEVEL();
test_pack_SYSTEMTIME(); test_pack_SYSTEMTIME();
test_pack_SYSTEM_POWER_STATUS(); test_pack_SYSTEM_POWER_STATUS();
test_pack_TIME_ZONE_INFORMATION(); test_pack_TIME_ZONE_INFORMATION();
test_pack_UNLOAD_DLL_DEBUG_INFO(); test_pack_UNLOAD_DLL_DEBUG_INFO();
test_pack_WAITORTIMERCALLBACK();
test_pack_WIN32_FILE_ATTRIBUTE_DATA(); test_pack_WIN32_FILE_ATTRIBUTE_DATA();
test_pack_WIN32_FIND_DATAA(); test_pack_WIN32_FIND_DATAA();
test_pack_WIN32_FIND_DATAW(); test_pack_WIN32_FIND_DATAW();

18
reactos/apps/tests/kernel32/locale.c
View file

@ -35,13 +35,6 @@
#include "winerror.h" #include "winerror.h"
#include "winnls.h" #include "winnls.h"
#ifndef DATE_YEARMONTH
#define DATE_YEARMONTH 8
#endif
#ifndef MAP_EXPAND_LIGATURES
#define MAP_EXPAND_LIGATURES 0x2000
#endif
static inline unsigned int strlenW( const WCHAR *str ) static inline unsigned int strlenW( const WCHAR *str )
{ {
const WCHAR *s = str; const WCHAR *s = str;
@ -802,7 +795,16 @@ static void test_CompareStringA()
ok(!ret, "CompareStringA must fail with invalid flag\n"); ok(!ret, "CompareStringA must fail with invalid flag\n");
ret = lstrcmpA("", ""); ret = lstrcmpA("", "");
ok (!ret, "lstrcmpA(\"\", \"\") should return 0, got %d\n", ret); ok (ret == 0, "lstrcmpA(\"\", \"\") should return 0, got %d\n", ret);
ret = lstrcmpA(NULL, NULL);
ok (ret == 0, "lstrcmpA(NULL, NULL) should return 0, got %d\n", ret);
ret = lstrcmpA("", NULL);
ok (ret == 1, "lstrcmpA(\"\", NULL) should return 1, got %d\n", ret);
ret = lstrcmpA(NULL, "");
ok (ret == -1, "lstrcmpA(NULL, \"\") should return -1, got %d\n", ret);
ret = CompareStringA(LOCALE_SYSTEM_DEFAULT,0,"EndDialog",-1,"_Property",-1); ret = CompareStringA(LOCALE_SYSTEM_DEFAULT,0,"EndDialog",-1,"_Property",-1);
ok( ret == 3, "EndDialog vs _Property ... expected 3, got %d\n", ret); ok( ret == 3, "EndDialog vs _Property ... expected 3, got %d\n", ret);

4
reactos/apps/tests/kernel32/mailslot.c
View file

@ -35,9 +35,9 @@
#endif #endif
const char szmspath[] = "\\\\.\\mailslot\\wine_mailslot_test"; static const char szmspath[] = "\\\\.\\mailslot\\wine_mailslot_test";
int mailslot_test() static int mailslot_test()
{ {
HANDLE hSlot, hSlot2, hWriter, hWriter2; HANDLE hSlot, hSlot2, hWriter, hWriter2;
unsigned char buffer[16]; unsigned char buffer[16];

42
reactos/apps/tests/kernel32/path.c
View file

@ -48,7 +48,6 @@
*/ */
static const CHAR funny_chars[]="!@#$%^&*()=+{}[],?'`"; static const CHAR funny_chars[]="!@#$%^&*()=+{}[],?'`";
static const CHAR is_char_ok[] ="11111110111111111011"; static const CHAR is_char_ok[] ="11111110111111111011";
static const CHAR wine_todo[] ="00000000000000000000";
static DWORD (WINAPI *pGetLongPathNameA)(LPCSTR,LPSTR,DWORD); static DWORD (WINAPI *pGetLongPathNameA)(LPCSTR,LPSTR,DWORD);
@ -228,45 +227,25 @@ static void test_LongtoShortA(CHAR *teststr,CHAR *goodstr,
Get(Short|Long)PathNameA should never pass, but GetFullPathNameA Get(Short|Long)PathNameA should never pass, but GetFullPathNameA
should. should.
*/ */
static void test_FunnyChars(CHAR *curdir,CHAR *filename, static void test_FunnyChars(CHAR *curdir,CHAR *filename, INT valid,CHAR *errstr)
INT valid,INT todo,CHAR *errstr) { {
CHAR tmpstr[MAX_PATH],tmpstr1[MAX_PATH]; CHAR tmpstr[MAX_PATH],tmpstr1[MAX_PATH];
SLpassfail passfail; SLpassfail passfail;
test_ValidPathA(curdir,"",filename,tmpstr,&passfail,errstr); test_ValidPathA(curdir,"",filename,tmpstr,&passfail,errstr);
if(valid) { if(valid) {
sprintf(tmpstr1,"%s\\%s",curdir,filename); sprintf(tmpstr1,"%s\\%s",curdir,filename);
if(todo) {
todo_wine {
ok((passfail.shortlen==0 && ok((passfail.shortlen==0 &&
(passfail.shorterror==ERROR_FILE_NOT_FOUND || passfail.shorterror==ERROR_PATH_NOT_FOUND || !passfail.shorterror)) || (passfail.shorterror==ERROR_FILE_NOT_FOUND || passfail.shorterror==ERROR_PATH_NOT_FOUND || !passfail.shorterror)) ||
(passfail.shortlen==strlen(tmpstr1) && lstrcmpiA(tmpstr,tmpstr1)==0), (passfail.shortlen==strlen(tmpstr1) && lstrcmpiA(tmpstr,tmpstr1)==0),
"%s: GetShortPathNameA error: len=%ld error=%ld tmpstr=[%s]\n", "%s: GetShortPathNameA error: len=%ld error=%ld tmpstr=[%s]\n",
errstr,passfail.shortlen,passfail.shorterror,tmpstr); errstr,passfail.shortlen,passfail.shorterror,tmpstr);
}
} else {
ok((passfail.shortlen==0 &&
(passfail.shorterror==ERROR_FILE_NOT_FOUND || passfail.shorterror==ERROR_PATH_NOT_FOUND || !passfail.shorterror)) ||
(passfail.shortlen==strlen(tmpstr1) && lstrcmpiA(tmpstr,tmpstr1)==0),
"%s: GetShortPathNameA error: len=%ld error=%ld tmpstr=[%s]\n",
errstr,passfail.shortlen,passfail.shorterror,tmpstr);
}
} else {
if(todo) {
todo_wine {
/* Win2k returns ERROR_INVALID_NAME, Win98, wine return ERROR_FILE_NOT_FOUND, NT4 doesn't set last error */
ok(passfail.shortlen==0 &&
(passfail.shorterror==ERROR_INVALID_NAME || passfail.shorterror==ERROR_FILE_NOT_FOUND || !passfail.shorterror),
"%s: GetShortPathA should have failed len=%ld, error=%ld\n",
errstr,passfail.shortlen,passfail.shorterror);
}
} else { } else {
ok(passfail.shortlen==0 && ok(passfail.shortlen==0 &&
(passfail.shorterror==ERROR_INVALID_NAME || passfail.shorterror==ERROR_FILE_NOT_FOUND || !passfail.shorterror), (passfail.shorterror==ERROR_INVALID_NAME || passfail.shorterror==ERROR_FILE_NOT_FOUND || !passfail.shorterror),
"%s: GetShortPathA should have failed len=%ld, error=%ld\n", "%s: GetShortPathA should have failed len=%ld, error=%ld\n",
errstr,passfail.shortlen,passfail.shorterror); errstr,passfail.shortlen,passfail.shorterror);
} }
}
if(pGetLongPathNameA) { if(pGetLongPathNameA) {
ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have\n"); ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have\n");
if(valid) { if(valid) {
@ -782,30 +761,29 @@ static void test_PathNameA(CHAR *curdir, CHAR curDrive, CHAR otherDrive)
} }
/* Check out Get*PathNameA on some funny characters */ /* Check out Get*PathNameA on some funny characters */
for(i=0;i<lstrlenA(funny_chars);i++) { for(i=0;i<lstrlenA(funny_chars);i++) {
INT valid,todo; INT valid;
valid=(is_char_ok[i]=='0') ? 0 : 1; valid=(is_char_ok[i]=='0') ? 0 : 1;
todo=(wine_todo[i]=='0') ? 0 : 1;
sprintf(tmpstr1,"check%d-1",i); sprintf(tmpstr1,"check%d-1",i);
sprintf(tmpstr,"file%c000.ext",funny_chars[i]); sprintf(tmpstr,"file%c000.ext",funny_chars[i]);
test_FunnyChars(curdir,tmpstr,valid,todo,tmpstr1); test_FunnyChars(curdir,tmpstr,valid,tmpstr1);
sprintf(tmpstr1,"check%d-2",i); sprintf(tmpstr1,"check%d-2",i);
sprintf(tmpstr,"file000.e%ct",funny_chars[i]); sprintf(tmpstr,"file000.e%ct",funny_chars[i]);
test_FunnyChars(curdir,tmpstr,valid,todo,tmpstr1); test_FunnyChars(curdir,tmpstr,valid,tmpstr1);
sprintf(tmpstr1,"check%d-3",i); sprintf(tmpstr1,"check%d-3",i);
sprintf(tmpstr,"%cfile000.ext",funny_chars[i]); sprintf(tmpstr,"%cfile000.ext",funny_chars[i]);
test_FunnyChars(curdir,tmpstr,valid,todo,tmpstr1); test_FunnyChars(curdir,tmpstr,valid,tmpstr1);
sprintf(tmpstr1,"check%d-4",i); sprintf(tmpstr1,"check%d-4",i);
sprintf(tmpstr,"file000%c.ext",funny_chars[i]); sprintf(tmpstr,"file000%c.ext",funny_chars[i]);
test_FunnyChars(curdir,tmpstr,valid,todo,tmpstr1); test_FunnyChars(curdir,tmpstr,valid,tmpstr1);
sprintf(tmpstr1,"check%d-5",i); sprintf(tmpstr1,"check%d-5",i);
sprintf(tmpstr,"Long %c File",funny_chars[i]); sprintf(tmpstr,"Long %c File",funny_chars[i]);
test_FunnyChars(curdir,tmpstr,valid,0,tmpstr1); test_FunnyChars(curdir,tmpstr,valid,tmpstr1);
sprintf(tmpstr1,"check%d-6",i); sprintf(tmpstr1,"check%d-6",i);
sprintf(tmpstr,"%c Long File",funny_chars[i]); sprintf(tmpstr,"%c Long File",funny_chars[i]);
test_FunnyChars(curdir,tmpstr,valid,0,tmpstr1); test_FunnyChars(curdir,tmpstr,valid,tmpstr1);
sprintf(tmpstr1,"check%d-7",i); sprintf(tmpstr1,"check%d-7",i);
sprintf(tmpstr,"Long File %c",funny_chars[i]); sprintf(tmpstr,"Long File %c",funny_chars[i]);
test_FunnyChars(curdir,tmpstr,valid,0,tmpstr1); test_FunnyChars(curdir,tmpstr,valid,tmpstr1);
} }
} }

220
reactos/apps/tests/kernel32/pipe.c
View file

@ -50,18 +50,28 @@
#define PIPENAME "\\\\.\\PiPe\\tests_" __FILE__ #define PIPENAME "\\\\.\\PiPe\\tests_" __FILE__
void test_CreateNamedPipe(void) #define NB_SERVER_LOOPS 8
static HANDLE alarm_event;
static void test_CreateNamedPipe(pipemode)
{ {
HANDLE hnp; HANDLE hnp;
HANDLE hFile; HANDLE hFile;
const char obuf[] = "Bit Bucket"; static const char obuf[] = "Bit Bucket";
char ibuf[32]; static const char obuf2[] = "More bits";
char ibuf[32], *pbuf;
DWORD written; DWORD written;
DWORD readden; DWORD readden;
DWORD avail;
DWORD lpmode;
trace("test_CreateNamedPipe starting\n"); if (pipemode == PIPE_TYPE_BYTE)
trace("test_CreateNamedPipe starting in byte mode\n");
else
trace("test_CreateNamedPipe starting in message mode\n");
/* Bad parameter checks */ /* Bad parameter checks */
hnp = CreateNamedPipe("not a named pipe", PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_WAIT, hnp = CreateNamedPipe("not a named pipe", PIPE_ACCESS_DUPLEX, pipemode | PIPE_WAIT,
/* nMaxInstances */ 1, /* nMaxInstances */ 1,
/* nOutBufSize */ 1024, /* nOutBufSize */ 1024,
/* nInBufSize */ 1024, /* nInBufSize */ 1024,
@ -78,7 +88,7 @@ void test_CreateNamedPipe(void)
"CreateNamedPipe should fail if name doesn't start with \\\\.\\pipe\n"); "CreateNamedPipe should fail if name doesn't start with \\\\.\\pipe\n");
hnp = CreateNamedPipe(NULL, hnp = CreateNamedPipe(NULL,
PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_WAIT, PIPE_ACCESS_DUPLEX, pipemode | PIPE_WAIT,
1, 1024, 1024, NMPWAIT_USE_DEFAULT_WAIT, NULL); 1, 1024, 1024, NMPWAIT_USE_DEFAULT_WAIT, NULL);
ok(hnp == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND, ok(hnp == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
"CreateNamedPipe should fail if name is NULL\n"); "CreateNamedPipe should fail if name is NULL\n");
@ -90,7 +100,7 @@ void test_CreateNamedPipe(void)
/* Functional checks */ /* Functional checks */
hnp = CreateNamedPipe(PIPENAME, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_WAIT, hnp = CreateNamedPipe(PIPENAME, PIPE_ACCESS_DUPLEX, pipemode | PIPE_WAIT,
/* nMaxInstances */ 1, /* nMaxInstances */ 1,
/* nOutBufSize */ 1024, /* nOutBufSize */ 1024,
/* nInBufSize */ 1024, /* nInBufSize */ 1024,
@ -108,17 +118,160 @@ void test_CreateNamedPipe(void)
/* Make sure we can read and write a few bytes in both directions */ /* Make sure we can read and write a few bytes in both directions */
memset(ibuf, 0, sizeof(ibuf)); memset(ibuf, 0, sizeof(ibuf));
ok(WriteFile(hnp, obuf, sizeof(obuf), &written, NULL), "WriteFile\n"); ok(WriteFile(hnp, obuf, sizeof(obuf), &written, NULL), "WriteFile\n");
ok(written == sizeof(obuf), "write file len\n"); ok(written == sizeof(obuf), "write file len 1\n");
ok(ReadFile(hFile, ibuf, sizeof(obuf), &readden, NULL), "ReadFile\n"); ok(PeekNamedPipe(hFile, NULL, 0, NULL, &readden, NULL), "Peek\n");
ok(readden == sizeof(obuf), "read file len\n"); ok(readden == sizeof(obuf), "peek 1 got %ld bytes\n", readden);
ok(memcmp(obuf, ibuf, written) == 0, "content check\n"); ok(ReadFile(hFile, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
ok(readden == sizeof(obuf), "read 1 got %ld bytes\n", readden);
ok(memcmp(obuf, ibuf, written) == 0, "content 1 check\n");
memset(ibuf, 0, sizeof(ibuf)); memset(ibuf, 0, sizeof(ibuf));
ok(WriteFile(hFile, obuf, sizeof(obuf), &written, NULL), "WriteFile\n"); ok(WriteFile(hFile, obuf2, sizeof(obuf2), &written, NULL), "WriteFile\n");
ok(written == sizeof(obuf), "write file len\n"); ok(written == sizeof(obuf2), "write file len 2\n");
ok(ReadFile(hnp, ibuf, sizeof(obuf), &readden, NULL), "ReadFile\n"); ok(PeekNamedPipe(hnp, NULL, 0, NULL, &readden, NULL), "Peek\n");
ok(readden == sizeof(obuf), "read file len\n"); ok(readden == sizeof(obuf2), "peek 2 got %ld bytes\n", readden);
ok(memcmp(obuf, ibuf, written) == 0, "content check\n"); ok(ReadFile(hnp, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
ok(readden == sizeof(obuf2), "read 2 got %ld bytes\n", readden);
ok(memcmp(obuf2, ibuf, written) == 0, "content 2 check\n");
/* Test reading of multiple writes */
memset(ibuf, 0, sizeof(ibuf));
ok(WriteFile(hnp, obuf, sizeof(obuf), &written, NULL), "WriteFile3a\n");
ok(written == sizeof(obuf), "write file len 3a\n");
ok(WriteFile(hnp, obuf2, sizeof(obuf2), &written, NULL), " WriteFile3b\n");
ok(written == sizeof(obuf2), "write file len 3b\n");
ok(PeekNamedPipe(hFile, ibuf, sizeof(ibuf), &readden, &avail, NULL), "Peek3\n");
if (pipemode == PIPE_TYPE_BYTE) {
todo_wine {
/* should return all 23 bytes */
ok(readden == sizeof(obuf) + sizeof(obuf2), "peek3 got %ld bytes\n", readden);
}
}
else
ok(readden == sizeof(obuf), "peek3 got %ld bytes\n", readden);
todo_wine {
ok(avail == sizeof(obuf) + sizeof(obuf2), "peek3 got %ld bytes available\n", avail);
}
pbuf = ibuf;
ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "pipe content 3a check\n");
if (pipemode == PIPE_TYPE_BYTE) {
todo_wine {
pbuf += sizeof(obuf);
ok(memcmp(obuf2, pbuf, sizeof(obuf2)) == 0, "pipe content 3b check\n");
}
}
ok(ReadFile(hFile, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
ok(readden == sizeof(obuf) + sizeof(obuf2), "read 3 got %ld bytes\n", readden);
pbuf = ibuf;
ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "content 3a check\n");
pbuf += sizeof(obuf);
ok(memcmp(obuf2, pbuf, sizeof(obuf2)) == 0, "content 3b check\n");
/* Multiple writes in the reverse direction */
memset(ibuf, 0, sizeof(ibuf));
ok(WriteFile(hFile, obuf, sizeof(obuf), &written, NULL), "WriteFile4a\n");
ok(written == sizeof(obuf), "write file len 4a\n");
ok(WriteFile(hFile, obuf2, sizeof(obuf2), &written, NULL), " WriteFile4b\n");
ok(written == sizeof(obuf2), "write file len 4b\n");
ok(PeekNamedPipe(hnp, ibuf, sizeof(ibuf), &readden, &avail, NULL), "Peek4\n");
if (pipemode == PIPE_TYPE_BYTE) {
todo_wine {
/* should return all 23 bytes */
ok(readden == sizeof(obuf) + sizeof(obuf2), "peek4 got %ld bytes\n", readden);
}
}
else
ok(readden == sizeof(obuf), "peek4 got %ld bytes\n", readden);
todo_wine {
ok(avail == sizeof(obuf) + sizeof(obuf2), "peek4 got %ld bytes available\n", avail);
}
pbuf = ibuf;
ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "pipe content 4a check\n");
if (pipemode == PIPE_TYPE_BYTE) {
todo_wine {
pbuf += sizeof(obuf);
ok(memcmp(obuf2, pbuf, sizeof(obuf2)) == 0, "pipe content 4b check\n");
}
}
ok(ReadFile(hnp, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
if (pipemode == PIPE_TYPE_BYTE) {
ok(readden == sizeof(obuf) + sizeof(obuf2), "read 4 got %ld bytes\n", readden);
}
else {
todo_wine {
ok(readden == sizeof(obuf), "read 4 got %ld bytes\n", readden);
}
}
pbuf = ibuf;
ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "content 4a check\n");
if (pipemode == PIPE_TYPE_BYTE) {
pbuf += sizeof(obuf);
ok(memcmp(obuf2, pbuf, sizeof(obuf2)) == 0, "content 4b check\n");
}
/* Test reading of multiple writes after a mode change
(CreateFile always creates a byte mode pipe) */
lpmode = PIPE_READMODE_MESSAGE;
if (pipemode == PIPE_TYPE_BYTE) {
/* trying to change the client end of a byte pipe to message mode should fail */
ok(!SetNamedPipeHandleState(hFile, &lpmode, NULL, NULL), "Change mode\n");
}
else {
todo_wine {
ok(SetNamedPipeHandleState(hFile, &lpmode, NULL, NULL), "Change mode\n");
}
memset(ibuf, 0, sizeof(ibuf));
ok(WriteFile(hnp, obuf, sizeof(obuf), &written, NULL), "WriteFile5a\n");
ok(written == sizeof(obuf), "write file len 3a\n");
ok(WriteFile(hnp, obuf2, sizeof(obuf2), &written, NULL), " WriteFile5b\n");
ok(written == sizeof(obuf2), "write file len 3b\n");
ok(PeekNamedPipe(hFile, ibuf, sizeof(ibuf), &readden, &avail, NULL), "Peek5\n");
ok(readden == sizeof(obuf), "peek5 got %ld bytes\n", readden);
todo_wine {
ok(avail == sizeof(obuf) + sizeof(obuf2), "peek5 got %ld bytes available\n", avail);
}
pbuf = ibuf;
ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "content 5a check\n");
ok(ReadFile(hFile, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
todo_wine {
ok(readden == sizeof(obuf), "read 5 got %ld bytes\n", readden);
}
pbuf = ibuf;
ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "content 5a check\n");
/* Multiple writes in the reverse direction */
/* the write of obuf2 from write4 should still be in the buffer */
ok(PeekNamedPipe(hnp, ibuf, sizeof(ibuf), &readden, &avail, NULL), "Peek6a\n");
todo_wine {
ok(readden == sizeof(obuf2), "peek6a got %ld bytes\n", readden);
ok(avail == sizeof(obuf2), "peek6a got %ld bytes available\n", avail);
}
if (avail > 0) {
ok(ReadFile(hnp, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
ok(readden == sizeof(obuf2), "read 6a got %ld bytes\n", readden);
pbuf = ibuf;
ok(memcmp(obuf2, pbuf, sizeof(obuf2)) == 0, "content 6a check\n");
}
memset(ibuf, 0, sizeof(ibuf));
ok(WriteFile(hFile, obuf, sizeof(obuf), &written, NULL), "WriteFile6a\n");
ok(written == sizeof(obuf), "write file len 6a\n");
ok(WriteFile(hFile, obuf2, sizeof(obuf2), &written, NULL), " WriteFile6b\n");
ok(written == sizeof(obuf2), "write file len 6b\n");
ok(PeekNamedPipe(hnp, ibuf, sizeof(ibuf), &readden, &avail, NULL), "Peek6\n");
ok(readden == sizeof(obuf), "peek6 got %ld bytes\n", readden);
todo_wine {
ok(avail == sizeof(obuf) + sizeof(obuf2), "peek6b got %ld bytes available\n", avail);
}
pbuf = ibuf;
ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "content 6a check\n");
ok(ReadFile(hnp, ibuf, sizeof(ibuf), &readden, NULL), "ReadFile\n");
todo_wine {
ok(readden == sizeof(obuf), "read 6b got %ld bytes\n", readden);
}
pbuf = ibuf;
ok(memcmp(obuf, pbuf, sizeof(obuf)) == 0, "content 6a check\n");
}
/* Picky conformance tests */ /* Picky conformance tests */
@ -235,9 +388,11 @@ static DWORD CALLBACK alarmThreadMain(LPVOID arg)
{ {
DWORD timeout = (DWORD) arg; DWORD timeout = (DWORD) arg;
trace("alarmThreadMain\n"); trace("alarmThreadMain\n");
Sleep(timeout); if (WaitForSingleObject( alarm_event, timeout ) == WAIT_TIMEOUT)
{
ok(FALSE, "alarm\n"); ok(FALSE, "alarm\n");
ExitProcess(1); ExitProcess(1);
}
return 1; return 1;
} }
@ -259,7 +414,7 @@ static DWORD CALLBACK serverThreadMain1(LPVOID arg)
/* lpSecurityAttrib */ NULL); /* lpSecurityAttrib */ NULL);
ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n"); ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
for (i = 0; ; i++) { for (i = 0; i < NB_SERVER_LOOPS; i++) {
char buf[512]; char buf[512];
DWORD written; DWORD written;
DWORD readden; DWORD readden;
@ -291,6 +446,7 @@ static DWORD CALLBACK serverThreadMain1(LPVOID arg)
ok(DisconnectNamedPipe(hnp), "DisconnectNamedPipe\n"); ok(DisconnectNamedPipe(hnp), "DisconnectNamedPipe\n");
trace("Server done disconnecting.\n"); trace("Server done disconnecting.\n");
} }
return 0;
} }
/** Trivial byte echo server - closes after each connection */ /** Trivial byte echo server - closes after each connection */
@ -310,7 +466,7 @@ static DWORD CALLBACK serverThreadMain2(LPVOID arg)
/* lpSecurityAttrib */ NULL); /* lpSecurityAttrib */ NULL);
ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n"); ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
for (i = 0; ; i++) { for (i = 0; i < NB_SERVER_LOOPS; i++) {
char buf[512]; char buf[512];
DWORD written; DWORD written;
DWORD readden; DWORD readden;
@ -354,6 +510,7 @@ static DWORD CALLBACK serverThreadMain2(LPVOID arg)
ok(CloseHandle(hnp), "CloseHandle\n"); ok(CloseHandle(hnp), "CloseHandle\n");
hnp = hnpNext; hnp = hnpNext;
} }
return 0;
} }
/** Trivial byte echo server - uses overlapped named pipe calls */ /** Trivial byte echo server - uses overlapped named pipe calls */
@ -379,7 +536,7 @@ static DWORD CALLBACK serverThreadMain3(LPVOID arg)
NULL); /* name */ NULL); /* name */
ok(hEvent != NULL, "CreateEvent\n"); ok(hEvent != NULL, "CreateEvent\n");
for (i = 0; ; i++) { for (i = 0; i < NB_SERVER_LOOPS; i++) {
char buf[512]; char buf[512];
DWORD written; DWORD written;
DWORD readden; DWORD readden;
@ -450,6 +607,7 @@ static DWORD CALLBACK serverThreadMain3(LPVOID arg)
ok(FlushFileBuffers(hnp), "FlushFileBuffers\n"); ok(FlushFileBuffers(hnp), "FlushFileBuffers\n");
ok(DisconnectNamedPipe(hnp), "DisconnectNamedPipe\n"); ok(DisconnectNamedPipe(hnp), "DisconnectNamedPipe\n");
} }
return 0;
} }
static void exercizeServer(const char *pipename, HANDLE serverThread) static void exercizeServer(const char *pipename, HANDLE serverThread)
@ -457,9 +615,9 @@ static void exercizeServer(const char *pipename, HANDLE serverThread)
int i; int i;
trace("exercizeServer starting\n"); trace("exercizeServer starting\n");
for (i = 0; i < 8; i++) { for (i = 0; i < NB_SERVER_LOOPS; i++) {
HANDLE hFile=INVALID_HANDLE_VALUE; HANDLE hFile=INVALID_HANDLE_VALUE;
const char obuf[] = "Bit Bucket"; static const char obuf[] = "Bit Bucket";
char ibuf[32]; char ibuf[32];
DWORD written; DWORD written;
DWORD readden; DWORD readden;
@ -497,12 +655,12 @@ static void exercizeServer(const char *pipename, HANDLE serverThread)
ok(CloseHandle(hFile), "CloseHandle\n"); ok(CloseHandle(hFile), "CloseHandle\n");
} }
ok(TerminateThread(serverThread, 0), "TerminateThread\n"); ok(WaitForSingleObject(serverThread,INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject\n");
CloseHandle(hnp); CloseHandle(hnp);
trace("exercizeServer returning\n"); trace("exercizeServer returning\n");
} }
void test_NamedPipe_2(void) static void test_NamedPipe_2(void)
{ {
HANDLE serverThread; HANDLE serverThread;
DWORD serverThreadId; DWORD serverThreadId;
@ -511,6 +669,7 @@ void test_NamedPipe_2(void)
trace("test_NamedPipe_2 starting\n"); trace("test_NamedPipe_2 starting\n");
/* Set up a ten second timeout */ /* Set up a ten second timeout */
alarm_event = CreateEvent( NULL, TRUE, FALSE, NULL );
alarmThread = CreateThread(NULL, 0, alarmThreadMain, (void *) 10000, 0, &alarmThreadId); alarmThread = CreateThread(NULL, 0, alarmThreadMain, (void *) 10000, 0, &alarmThreadId);
/* The servers we're about to exercize do try to clean up carefully, /* The servers we're about to exercize do try to clean up carefully,
@ -519,7 +678,7 @@ void test_NamedPipe_2(void)
*/ */
/* Try server #1 */ /* Try server #1 */
serverThread = CreateThread(NULL, 0, serverThreadMain1, 0, 0, &serverThreadId); serverThread = CreateThread(NULL, 0, serverThreadMain1, (void *)8, 0, &serverThreadId);
ok(serverThread != INVALID_HANDLE_VALUE, "CreateThread\n"); ok(serverThread != INVALID_HANDLE_VALUE, "CreateThread\n");
exercizeServer(PIPENAME "serverThreadMain1", serverThread); exercizeServer(PIPENAME "serverThreadMain1", serverThread);
@ -536,15 +695,16 @@ void test_NamedPipe_2(void)
exercizeServer(PIPENAME "serverThreadMain3", serverThread); exercizeServer(PIPENAME "serverThreadMain3", serverThread);
} }
ok(TerminateThread(alarmThread, 0), "TerminateThread\n"); ok(SetEvent( alarm_event ), "SetEvent\n");
CloseHandle( alarm_event );
trace("test_NamedPipe_2 returning\n"); trace("test_NamedPipe_2 returning\n");
} }
void test_DisconnectNamedPipe(void) static void test_DisconnectNamedPipe(void)
{ {
HANDLE hnp; HANDLE hnp;
HANDLE hFile; HANDLE hFile;
const char obuf[] = "Bit Bucket"; static const char obuf[] = "Bit Bucket";
char ibuf[32]; char ibuf[32];
DWORD written; DWORD written;
DWORD readden; DWORD readden;
@ -596,6 +756,8 @@ START_TEST(pipe)
trace("test 3 of 4:\n"); trace("test 3 of 4:\n");
test_NamedPipe_2(); test_NamedPipe_2();
trace("test 4 of 4:\n"); trace("test 4 of 4:\n");
test_CreateNamedPipe(); test_CreateNamedPipe(PIPE_TYPE_BYTE);
trace("all tests done\n");
test_CreateNamedPipe(PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE);
trace("all tests done\n"); trace("all tests done\n");
} }