Mike McCormack wrote:
Well, I'm curious to know what happens when you:
* put a pipe into message mode, then do partial reads.
* do TransactNamedPipe, and there is already read data
available in the pipe.
* DisconnectNamedPipe on a pipe that still has messages in it
* try reading from a pipe that is not connected (before and after
connecting)
* switch pipes between message mode and byte mode with data in the pipe
Er, looks like it'll be a while before I test those,
but I do have a just-barely-nontrivial test;
wine fails it in several ways. Attached for your
testing pleasure.
- Dan
--
Dan Kegel
http://www.kegel.com
http://counter.li.org/cgi-bin/runscript/display-person.cgi?user=78045
/*
* Unit tests for named pipe functions in Wine
*
* Copyright (c) 2002 Dan Kegel
*
* 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 <stdlib.h>
#include <stdio.h>
#include <time.h>
#ifndef STANDALONE
#include "wine/test.h"
#else
#include <assert.h>
#define START_TEST(name) main(int argc, char **argv)
#define ok(condition, msg) assert(condition)
#define todo_wine
#endif
#include <wtypes.h>
#include <windef.h>
#include <winbase.h>
#include <winerror.h>
#define PIPENAME "\\\\.\\PiPe\\tests_" __FILE__
static void msg(const char *s)
{
DWORD cbWritten;
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),
s, strlen(s), &cbWritten, NULL);
}
void test_CreateNamedPipeA(void)
{
HANDLE hnp;
HANDLE hFile;
const char obuf[] = "Bit Bucket";
char ibuf[32];
DWORD written;
DWORD gelesen;
/* Bad parameter checks */
hnp = CreateNamedPipeA("not a named pipe",
PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE|PIPE_WAIT,
/* nMaxInstances */ 1,
/* nOutBufSize */ 1024,
/* nInBufSize */ 1024,
/* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
/* lpSecurityAttrib */ NULL);
if (hnp == INVALID_HANDLE_VALUE && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) {
/* Is this the right way to notify user of skipped tests? */
ok(hnp == INVALID_HANDLE_VALUE && GetLastError() ==
ERROR_CALL_NOT_IMPLEMENTED,
"CreateNamedPipe not supported on this platform, skipping tests.");
return;
}
ok(hnp == INVALID_HANDLE_VALUE && GetLastError() == ERROR_INVALID_NAME,
"CreateNamedPipe should fail if name doesn't start with \\\\.\\pipe");
hnp = CreateNamedPipeA(NULL,
PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE|PIPE_WAIT,
1, 1024, 1024, NMPWAIT_USE_DEFAULT_WAIT, NULL);
ok(hnp == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
"CreateNamedPipe should fail if name is NULL");
hFile = CreateFileA(PIPENAME, GENERIC_READ|GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, 0, 0);
ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_NOT_FOUND,
"connecting to nonexistent named pipe should fail with ERROR_FILE_NOT_FOUND");
/* Functional checks */
hnp = CreateNamedPipeA(PIPENAME,
PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE|PIPE_WAIT,
/* nMaxInstances */ 1,
/* nOutBufSize */ 1024,
/* nInBufSize */ 1024,
/* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
/* lpSecurityAttrib */ NULL);
ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed");
hFile = CreateFileA(PIPENAME, GENERIC_READ|GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, 0, 0);
todo_wine
{
ok(hFile != INVALID_HANDLE_VALUE, "CreateFile failed");
}
/* don't try to do i/o if one side couldn't be opened, as it hangs */
if (hFile != INVALID_HANDLE_VALUE) {
HANDLE hFile2;
/* Make sure we can read and write a few bytes in both directions*/
memset(ibuf, 0, sizeof(ibuf));
ok(WriteFile(hnp, obuf, sizeof(obuf), &written, NULL), "WriteFile");
ok(written == sizeof(obuf), "write file len");
ok(ReadFile(hFile, ibuf, sizeof(obuf), &gelesen, NULL), "ReadFile");
ok(gelesen == sizeof(obuf), "read file len");
ok(memcmp(obuf, ibuf, written) == 0, "content check");
memset(ibuf, 0, sizeof(ibuf));
ok(WriteFile(hFile, obuf, sizeof(obuf), &written, NULL), "WriteFile");
ok(written == sizeof(obuf), "write file len");
ok(ReadFile(hnp, ibuf, sizeof(obuf), &gelesen, NULL), "ReadFile");
ok(gelesen == sizeof(obuf), "read file len");
ok(memcmp(obuf, ibuf, written) == 0, "content check");
/* Picky conformance tests */
/* Verify that you can't connect to pipe again
* until server calls DisconnectNamedPipe+ConnectNamedPipe
* or creates a new pipe
* case 1: other client not yet closed
*/
hFile2 = CreateFileA(PIPENAME, GENERIC_READ|GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, 0, 0);
ok(hFile2 == INVALID_HANDLE_VALUE, "connecting to named pipe after other
client closes but before DisconnectNamedPipe should fail");
ok(GetLastError() == ERROR_PIPE_BUSY, "connecting to named pipe before other
client closes should fail with ERROR_PIPE_BUSY");
ok(CloseHandle(hFile), "CloseHandle");
/* case 2: other client already closed */
hFile = CreateFileA(PIPENAME, GENERIC_READ|GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, 0, 0);
ok(hFile == INVALID_HANDLE_VALUE, "connecting to named pipe after other client
closes but before DisconnectNamedPipe should fail");
ok(GetLastError() == ERROR_PIPE_BUSY, "connecting to named pipe after other
client closes but before DisconnectNamedPipe should fail with ERROR_PIPE_BUSY");
ok(DisconnectNamedPipe(hnp), "DisconnectNamedPipe");
/* case 3: server has called DisconnectNamedPipe but not ConnectNamed Pipe */
hFile = CreateFileA(PIPENAME, GENERIC_READ|GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, 0, 0);
ok(hFile == INVALID_HANDLE_VALUE, "connecting to named pipe after other client
closes but before DisconnectNamedPipe should fail");
ok(GetLastError() == ERROR_PIPE_BUSY, "connecting to named pipe after other
client closes but before ConnectNamedPipe should fail with ERROR_PIPE_BUSY");
/* to be complete, we'd call ConnectNamedPipe here and loop,
* but by default that's blocking, so we'd either have
* to turn on the uncommon nonblocking mode, or
* use another thread.
*/
}
ok(CloseHandle(hnp), "CloseHandle");
}
/** implementation of alarm() */
static DWORD CALLBACK alarmThreadMain(LPVOID arg)
{
DWORD timeout = (DWORD) arg;
msg("alarmThreadMain\n");
Sleep(timeout);
ok(FALSE, "alarm");
ExitProcess(1);
return 1;
}
/** Trivial byte echo server */
static DWORD CALLBACK serverThreadMain(LPVOID arg)
{
HANDLE hnp = (HANDLE) arg;
int i;
for (i=0; ; i++) {
char buf[512];
DWORD written;
DWORD gelesen;
DWORD success;
/* Wait for client to connect */
msg("Server calling ConnectNamedPipe...\n");
ok(ConnectNamedPipe(hnp, NULL) || GetLastError() ==
ERROR_PIPE_CONNECTED, "ConnectNamedPipe");
msg("ConnectNamedPipe returned.\n");
/* Echo bytes once */
memset(buf, 0, sizeof(buf));
/* Hmm. This read seems to completely hose wine. Total lockup. */
msg("Server reading...\n");
success = ReadFile(hnp, buf, sizeof(buf), &gelesen, NULL);
msg("Server done reading.\n");
ok(success, "ReadFile");
msg("Server writing...\n");
ok(WriteFile(hnp, buf, gelesen, &written, NULL), "WriteFile");
msg("Server done writing.\n");
ok(written == gelesen, "write file len");
/* finish this connection, wait for next one */
ok(FlushFileBuffers(hnp), "FlushFileBuffers");
ok(DisconnectNamedPipe(hnp), "DisconnectNamedPipe");
}
}
void test_NamedPipe_2(void)
{
HANDLE hnp;
HANDLE serverThread;
HANDLE alarmThread;
DWORD serverThreadId;
DWORD alarmThreadId;
int i;
/* Set up a ten second timeout */
alarmThread = CreateThread(NULL,0,alarmThreadMain,(void *)10000,0,&alarmThreadId);
/* Set up a simple echo server */
hnp = CreateNamedPipeA(PIPENAME,
PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE|PIPE_WAIT,
/* nMaxInstances */ 1,
/* nOutBufSize */ 1024,
/* nInBufSize */ 1024,
/* nDefaultWait */ NMPWAIT_USE_DEFAULT_WAIT,
/* lpSecurityAttrib */ NULL);
ok(hnp != INVALID_HANDLE_VALUE, "CreateNamedPipe failed");
serverThread = CreateThread(NULL,0,serverThreadMain,hnp,0,&serverThreadId);
ok(serverThread != INVALID_HANDLE_VALUE, "CreateThread");
for (i=0; i<3; i++) {
HANDLE hFile;
const char obuf[] = "Bit Bucket";
char ibuf[32];
DWORD written;
DWORD gelesen;
int loop;
for (loop=0; loop<3; loop++) {
msg("Client connecting...\n");
/* Connect to the server */
hFile = CreateFileA(PIPENAME, GENERIC_READ|GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, 0, 0);
if (hFile != INVALID_HANDLE_VALUE) break;
/* must be the second time around the loop, and server hasn't
called ConnectNamedPipe yet */
ok(GetLastError() == ERROR_PIPE_BUSY, "connecting to pipe");
msg("connect failed, retrying\n");
Sleep(10);
}
ok(hFile != INVALID_HANDLE_VALUE, "client opening named pipe");
/* Make sure it can echo */
memset(ibuf, 0, sizeof(ibuf));
msg("Client writing...\n");
ok(WriteFile(hFile, obuf, sizeof(obuf), &written, NULL), "WriteFile");
ok(written == sizeof(obuf), "write file len");
msg("Client reading...\n");
ok(ReadFile(hFile, ibuf, sizeof(obuf), &gelesen, NULL), "ReadFile");
ok(gelesen == sizeof(obuf), "read file len");
ok(memcmp(obuf, ibuf, written) == 0, "content check");
msg("Client closing...\n");
ok(CloseHandle(hFile), "CloseHandle");
}
ok(TerminateThread(alarmThread, 0), "TerminateThread");
ok(TerminateThread(serverThread, 0), "TerminateThread");
ok(WaitForSingleObject(serverThread,5000)==WAIT_OBJECT_0,
"TerminateThread didn't work");
ok(CloseHandle(hnp), "CloseHandle");
msg("test_NamedPipe_2 done\n");
}
START_TEST(pipe)
{
test_NamedPipe_2();
test_CreateNamedPipeA();
}
