|
|
//
// 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;
}
|
