//
// Test the quick return timeouts
//
// Assume that we are using a loopback connector.
//
// Assume that it isn't running on a stressed machine.
//
#include "windows.h"
#include "stdio.h"
#define FAILURE printf("FAIL: %d\n",__LINE__);exit(1)
int __cdecl main(int argc, char *argv[]) {
CHAR *myPort = "COM1";
DCB myDcb;
DWORD junk;
COMMTIMEOUTS myTimeOuts;
DWORD numberActuallyRead;
DWORD numberActuallyWritten;
UCHAR readBuff[1000];
HANDLE comHandle;
DWORD startingTicks;
OVERLAPPED readOl;
OVERLAPPED writeOl;
UCHAR writeBuff[5] = {0,1,2,3,4};
if (argc > 1) {
myPort = argv[1];
}
if ((comHandle = CreateFile(
myPort,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL
)) == ((HANDLE)-1)) {
FAILURE;
}
if (!(readOl.hEvent = CreateEvent(
NULL,
TRUE,
FALSE,
NULL
))) {
FAILURE;
}
if (!(writeOl.hEvent = CreateEvent(
NULL,
TRUE,
FALSE,
NULL
))) {
FAILURE;
}
if (!GetCommState(
comHandle,
&myDcb
)) {
FAILURE;
}
myDcb.BaudRate = 19200;
myDcb.ByteSize = 8;
myDcb.StopBits = ONESTOPBIT;
myDcb.Parity = NOPARITY;
myDcb.fOutxCtsFlow = FALSE;
myDcb.fOutxDsrFlow = FALSE;
myDcb.fDsrSensitivity = FALSE;
myDcb.fOutX = FALSE;
myDcb.fInX = FALSE;
myDcb.fRtsControl = RTS_CONTROL_ENABLE;
myDcb.fDtrControl = DTR_CONTROL_ENABLE;
if (!SetCommState(
comHandle,
&myDcb
)) {
FAILURE;
}
//
// Test to make sure that all maxdword on read is illegal.
//
myTimeOuts.ReadIntervalTimeout = MAXDWORD;
myTimeOuts.ReadTotalTimeoutMultiplier = MAXDWORD;
myTimeOuts.ReadTotalTimeoutConstant = MAXDWORD;
myTimeOuts.WriteTotalTimeoutMultiplier = MAXDWORD;
myTimeOuts.WriteTotalTimeoutConstant = MAXDWORD;
if (SetCommTimeouts(
comHandle,
&myTimeOuts
)) {
FAILURE;
}
//
// Test that MAXDWORD,0,0 will return immediately with whatever
// is there
//
myTimeOuts.ReadIntervalTimeout = MAXDWORD;
myTimeOuts.ReadTotalTimeoutMultiplier = 0;
myTimeOuts.ReadTotalTimeoutConstant = 0;
myTimeOuts.WriteTotalTimeoutMultiplier = MAXDWORD;
myTimeOuts.WriteTotalTimeoutConstant = MAXDWORD;
if (!SetCommTimeouts(
comHandle,
&myTimeOuts
)) {
FAILURE;
}
startingTicks = GetTickCount();
if (!ReadFile(
comHandle,
&readBuff[0],
1000,
&numberActuallyRead,
&readOl
)) {
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
if (!GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
TRUE
)) {
FAILURE;
}
}
//
// We certainly should have gotten back in less than a
// a half a second.
//
if ((GetTickCount() - startingTicks) > 500) {
FAILURE;
}
if (numberActuallyRead) {
FAILURE;
}
//
// Write out five bytes and make sure that is what we get back
//
if (!WriteFile(
comHandle,
&writeBuff[0],
5,
&numberActuallyWritten,
&writeOl
)) {
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
if (!GetOverlappedResult(
comHandle,
&writeOl,
&numberActuallyWritten,
TRUE
)) {
FAILURE;
}
if (numberActuallyWritten != 5) {
FAILURE;
}
}
//
// Give some time for the chars to get there.
//
Sleep (100);
startingTicks = GetTickCount();
if (!ReadFile(
comHandle,
&readBuff[0],
1000,
&numberActuallyRead,
&readOl
)) {
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
if (!GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
TRUE
)) {
FAILURE;
}
}
//
// We certainly should have gotten back in less than a
// a half a second.
//
if ((GetTickCount() - startingTicks) > 500) {
FAILURE;
}
if (numberActuallyRead != 5) {
FAILURE;
}
//
// Test that the os2 wait for something works.
//
// First test that if there is something in the buffer
// it returns right away.
//
// Then test that if there isn't something, then if we
// put in the amount expected before the timeout expires
// that it returns.
//
// The test that if there isn't something and nothing
// happens before the timeout it returns after the timeout
// with nothing.
//
myTimeOuts.ReadIntervalTimeout = MAXDWORD;
myTimeOuts.ReadTotalTimeoutMultiplier = 0;
myTimeOuts.ReadTotalTimeoutConstant = 5000;
myTimeOuts.WriteTotalTimeoutMultiplier = MAXDWORD;
myTimeOuts.WriteTotalTimeoutConstant = MAXDWORD;
if (!SetCommTimeouts(
comHandle,
&myTimeOuts
)) {
FAILURE;
}
if (!WriteFile(
comHandle,
&writeBuff[0],
5,
&numberActuallyWritten,
&writeOl
)) {
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
if (!GetOverlappedResult(
comHandle,
&writeOl,
&numberActuallyWritten,
TRUE
)) {
FAILURE;
}
if (numberActuallyWritten != 5) {
FAILURE;
}
}
//
// Give some time for the chars to get there.
//
Sleep (100);
startingTicks = GetTickCount();
if (!ReadFile(
comHandle,
&readBuff[0],
1000,
&numberActuallyRead,
&readOl
)) {
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
//
// Give it at most a 1/2 second to finish for
// the irp to complete immediately.
//
Sleep(500);
if (!GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
FALSE
)) {
FAILURE;
}
}
if ((GetTickCount() - startingTicks) > 1000) {
FAILURE;
}
if (numberActuallyRead != 5) {
FAILURE;
}
//
// Do the second os2 test
//
if (ReadFile(
comHandle,
&readBuff[0],
1000,
&numberActuallyRead,
&readOl
)) {
FAILURE;
}
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
//
// Give it a second for the the read to complete
//
//
Sleep(1000);
//
// Call the GetOverlapped and make sure that it returns
// ERROR_IO_INCOMPLETE.
//
if (GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
FALSE
)) {
FAILURE;
}
if (GetLastError() != ERROR_IO_INCOMPLETE) {
FAILURE;
}
//
// Do the write file and make sure that there is enough
// time for the chars to make it.
//
if (!WriteFile(
comHandle,
&writeBuff[0],
5,
&numberActuallyWritten,
&writeOl
)) {
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
if (!GetOverlappedResult(
comHandle,
&writeOl,
&numberActuallyWritten,
TRUE
)) {
FAILURE;
}
if (numberActuallyWritten != 5) {
FAILURE;
}
}
//
// Give some time for the chars to get there.
//
Sleep(100);
//
// Wait for no more than 6 seconds for the IO to complete
//
if (WaitForSingleObject(
readOl.hEvent,
6000
) != WAIT_OBJECT_0) {
FAILURE;
}
//
// Make sure we got everything we wrote
//
if (!GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
FALSE
)) {
FAILURE;
}
if (numberActuallyRead != 5) {
FAILURE;
}
//
// Do the third os2 wait for something test.
//
startingTicks = GetTickCount();
if (ReadFile(
comHandle,
&readBuff[0],
1000,
&numberActuallyRead,
&readOl
)) {
FAILURE;
}
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
//
// Give it a second for the the read to complete
//
//
Sleep(1000);
//
// Call the GetOverlapped and make sure that it returns
// ERROR_IO_INCOMPLETE.
//
if (GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
FALSE
)) {
FAILURE;
}
if (GetLastError() != ERROR_IO_INCOMPLETE) {
FAILURE;
}
//
// Wait for no more than 10 seconds for the IO to complete
//
if (WaitForSingleObject(
readOl.hEvent,
10000
) != WAIT_OBJECT_0) {
FAILURE;
}
//
// It shouldn't be more than 6 seconds for the Io to be done.
//
if ((GetTickCount() - startingTicks) > 6000) {
FAILURE;
}
//
// Make sure we got everything we wrote, which in this case is zero.
//
if (!GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
FALSE
)) {
FAILURE;
}
if (numberActuallyRead) {
FAILURE;
}
//
// Test the graphics mode quick return.
//
// First test that if there is something in the buffer
// it returns right away.
//
// Then test that if there isn't something, then if we
// put in 2 characters it returns right away with one
// and then the other read will return right away with
// 1.
//
// Then test that if there isn't something and nothing
// happens before the timeout it returns after the timeout
// with nothing.
//
myTimeOuts.ReadIntervalTimeout = MAXDWORD;
myTimeOuts.ReadTotalTimeoutMultiplier = MAXDWORD;
myTimeOuts.ReadTotalTimeoutConstant = 5000;
myTimeOuts.WriteTotalTimeoutMultiplier = MAXDWORD;
myTimeOuts.WriteTotalTimeoutConstant = MAXDWORD;
if (!SetCommTimeouts(
comHandle,
&myTimeOuts
)) {
FAILURE;
}
if (!WriteFile(
comHandle,
&writeBuff[0],
5,
&numberActuallyWritten,
&writeOl
)) {
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
if (!GetOverlappedResult(
comHandle,
&writeOl,
&numberActuallyWritten,
TRUE
)) {
FAILURE;
}
if (numberActuallyWritten != 5) {
FAILURE;
}
}
//
// Give some time for the chars to get there.
//
Sleep (100);
startingTicks = GetTickCount();
if (!ReadFile(
comHandle,
&readBuff[0],
1000,
&numberActuallyRead,
&readOl
)) {
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
//
// Give it at most a 1/2 second to finish for
// the irp to complete immediately.
//
Sleep(500);
if (!GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
FALSE
)) {
FAILURE;
}
}
if ((GetTickCount() - startingTicks) > 1000) {
FAILURE;
}
if (numberActuallyRead != 5) {
FAILURE;
}
//
// Do the second graphics wait test.
//
if (ReadFile(
comHandle,
&readBuff[0],
1000,
&numberActuallyRead,
&readOl
)) {
FAILURE;
}
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
//
// Give it a second for the the read to complete
//
//
Sleep(1000);
//
// Call the GetOverlapped and make sure that it returns
// ERROR_IO_INCOMPLETE.
//
if (GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
FALSE
)) {
FAILURE;
}
if (GetLastError() != ERROR_IO_INCOMPLETE) {
FAILURE;
}
//
// Do the write file and make sure that there is enough
// time for the chars to make it.
//
if (!WriteFile(
comHandle,
&writeBuff[0],
5,
&numberActuallyWritten,
&writeOl
)) {
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
if (!GetOverlappedResult(
comHandle,
&writeOl,
&numberActuallyWritten,
TRUE
)) {
FAILURE;
}
if (numberActuallyWritten != 5) {
FAILURE;
}
}
//
// Give some time for the chars to get there.
//
Sleep(100);
//
// Wait for no more than 1 second for the IO to complete
//
if (WaitForSingleObject(
readOl.hEvent,
1000
) != WAIT_OBJECT_0) {
FAILURE;
}
//
// Make sure we got everything we wrote
//
if (!GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
FALSE
)) {
FAILURE;
}
if (numberActuallyRead != 1) {
FAILURE;
}
startingTicks = GetTickCount();
if (!ReadFile(
comHandle,
&readBuff[0],
1000,
&numberActuallyRead,
&readOl
)) {
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
//
// Give it at most a 1/2 second to finish for
// the irp to complete immediately.
//
Sleep(500);
if (!GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
FALSE
)) {
FAILURE;
}
}
if ((GetTickCount() - startingTicks) > 1000) {
FAILURE;
}
if (numberActuallyRead != 4) {
FAILURE;
}
//
// Do the third graphics wait test.
//
startingTicks = GetTickCount();
if (ReadFile(
comHandle,
&readBuff[0],
1000,
&numberActuallyRead,
&readOl
)) {
FAILURE;
}
if (GetLastError() != ERROR_IO_PENDING) {
FAILURE;
}
//
// Give it a second for the the read to complete
//
//
Sleep(1000);
//
// Call the GetOverlapped and make sure that it returns
// ERROR_IO_INCOMPLETE.
//
if (GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
FALSE
)) {
FAILURE;
}
if (GetLastError() != ERROR_IO_INCOMPLETE) {
FAILURE;
}
//
// Wait for no more than 10 seconds for the IO to complete
//
if (WaitForSingleObject(
readOl.hEvent,
10000
) != WAIT_OBJECT_0) {
FAILURE;
}
//
// It shouldn't be more than 6 seconds for the Io to be done.
//
if ((GetTickCount() - startingTicks) > 6000) {
FAILURE;
}
//
// Make sure we got everything we wrote, which in this case is zero.
//
if (!GetOverlappedResult(
comHandle,
&readOl,
&numberActuallyRead,
FALSE
)) {
FAILURE;
}
if (numberActuallyRead) {
FAILURE;
}
return 1;
}