|
|
//
// Tests resize of buffer.
//
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "windows.h"
//
// This program assumes that it is using a loopback connector.
//
#define MAX_CHECK 100000
ULONG CheckValues[MAX_CHECK];ULONG ReadValues[MAX_CHECK];
void main(int argc,char *argv[]) {
HANDLE hFile; COMMPROP mp; DCB MyDcb; ULONG i; ULONG actuallyIoed; ULONG firstReadSize; ULONG secondReadSize; ULONG secondWriteSize; COMMTIMEOUTS cto; char *MyPort = "COM1"; COMSTAT stat; DWORD errors; DWORD increment = 1066; DWORD baudRate = 19200;
cto.ReadIntervalTimeout = (DWORD)~0; cto.ReadTotalTimeoutMultiplier = (DWORD)0; cto.ReadTotalTimeoutConstant = (DWORD)0; cto.WriteTotalTimeoutMultiplier = (DWORD)1; cto.WriteTotalTimeoutConstant = (DWORD)1000;
if (argc > 1) {
MyPort = argv[1];
if (argc > 2) {
sscanf(argv[2],"%d",&increment);
if (argc > 3) {
sscanf(argv[3],"%d",&baudRate);
}
}
}
//
// Put a sequence number in each long. As an extra check
// turn the high bit on.
//
for ( i = 0; i < MAX_CHECK; i++ ) {
CheckValues[i] = i; CheckValues[i] |= 0x80000000;
}
if ((hFile = CreateFile( MyPort, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL )) == ((HANDLE)-1)) {
printf("Couldn't open the port %s\n",MyPort); exit(1);
}
if (!GetCommState( hFile, &MyDcb )) {
printf("We couldn't get the comm state\n"); exit(1);
}
//
// Set the baud to 19200 and the data bits to 8
// (We want 8 so that we don't lose any of our data.)
//
MyDcb.BaudRate = baudRate; MyDcb.ByteSize = 8;
if (!SetCommState( hFile, &MyDcb )) {
printf("Couldn't set the baud/data for port %s\n"); exit(1);
}
//
// All the data should be in memory, we just set a timeout
// so that if we do get hung up, the reads will return.
//
if (!SetCommTimeouts( hFile, &cto )) {
printf("Couldn't set the timeouts.\n"); exit(1);
}
//
// Find out how many bytes are available in the RX buffer.
//
if (!GetCommProperties( hFile, &mp )) {
printf("Couldn't get the properties for port %s\n",MyPort); exit(1);
}
while (mp.dwCurrentRxQueue <= (MAX_CHECK*sizeof(ULONG))) {
printf("RX buffer size: %d\r",mp.dwCurrentRxQueue);
//
// Write out the number of bytes that the RX buffer can
// hold.
//
// The we read in half (approximately) of those bytes. After
// we read the half, we resize the buffer. We then read in
// the rest of those bytes. We then check the values against
// what they "should" be.
//
if (!WriteFile( hFile, &CheckValues[0], mp.dwCurrentRxQueue, &actuallyIoed, NULL )) {
printf("\nDidn't get all of the characters written %d\n",actuallyIoed); exit(1);
}
if (actuallyIoed != mp.dwCurrentRxQueue) {
printf("\nfirst write Timed out with IO of %d\n",actuallyIoed); exit(1);
}
Sleep(2);
//
// Call clear comm error so that we can see how many characters
// are in the typeahead buffer.
//
if (!ClearCommError( hFile, &errors, &stat )) {
printf("\nCouldn't call clear comm status after first write.\n"); exit(1);
}
if (stat.cbInQue != mp.dwCurrentRxQueue) {
printf("\nAfter first write the typeahead buffer is incorrect %d - %x\n", stat.cbInQue,errors); exit(1);
}
firstReadSize = mp.dwCurrentRxQueue / 2; secondReadSize = mp.dwCurrentRxQueue - firstReadSize;
if (!ReadFile( hFile, &ReadValues[0], firstReadSize, &actuallyIoed, NULL )) {
printf("\nDidn't get all of the characters read %d\n",actuallyIoed); exit(1);
}
if (actuallyIoed != firstReadSize) {
printf("\nfirst read Timed out with IO of %d\n",actuallyIoed); exit(1);
}
Sleep(2);
//
// Call clear comm error so that we can see how many characters
// are in the typeahead buffer.
//
if (!ClearCommError( hFile, &errors, &stat )) {
printf("\nCouldn't call clear comm status after first read.\n"); exit(1);
}
if (stat.cbInQue != secondReadSize) {
printf("\nAfter first read the typeahead buffer is incorrect %d\n", stat.cbInQue); exit(1);
}
Sleep(100); mp.dwCurrentRxQueue += increment;
if (!SetupComm( hFile, mp.dwCurrentRxQueue, mp.dwCurrentTxQueue )) {
printf("\nCouldn't resize the buffer to %d\n",mp.dwCurrentRxQueue); exit(1);
}
Sleep(2);
//
// Call clear comm error so that we can see how many characters
// are in the typeahead buffer.
//
if (!ClearCommError( hFile, &errors, &stat )) {
printf("\nCouldn't call clear comm status after resize.\n"); exit(1);
}
if (stat.cbInQue != secondReadSize) {
printf("\nAfter resize the typeahead buffer is incorrect %d\n", stat.cbInQue); exit(1);
}
//
// It's been resized. Fill up the remaining.
//
secondWriteSize = mp.dwCurrentRxQueue - secondReadSize;
if (!WriteFile( hFile, &CheckValues[0], secondWriteSize, &actuallyIoed, NULL )) {
printf("\nDidn't write all of the chars second time %d\n",actuallyIoed); exit(1);
}
if (actuallyIoed != secondWriteSize) {
printf("\nsecond write Timed out with IO of %d\n",actuallyIoed); exit(1);
}
Sleep(2);
//
// Call clear comm error so that we can see how many characters
// are in the typeahead buffer.
//
if (!ClearCommError( hFile, &errors, &stat )) {
printf("\nCouldn't call clear comm status after resize.\n"); exit(1);
}
if (stat.cbInQue != mp.dwCurrentRxQueue) {
printf("\nAfter second write the typeahead buffer is incorrect %d\n", stat.cbInQue); exit(1);
}
//
// We resized the buffer, see if we can get the rest of the
// characters from the first write.
//
if (!ReadFile( hFile, ((PUCHAR)&ReadValues[0])+firstReadSize, secondReadSize, &actuallyIoed, NULL )) {
printf("\nDidn't get all of the characters read(2) %d\n",actuallyIoed); exit(1);
}
if (actuallyIoed != secondReadSize) {
printf("\nsecond read Timed out with IO of %d\n",actuallyIoed); exit(1);
}
Sleep(2);
//
// Call clear comm error so that we can see how many characters
// are in the typeahead buffer.
//
if (!ClearCommError( hFile, &errors, &stat )) {
printf("\nCouldn't call clear comm status after resize.\n"); exit(1);
}
if (stat.cbInQue != secondWriteSize) {
printf("\nAfter second read the typeahead buffer is incorrect %d\n", stat.cbInQue); exit(1);
}
//
// Now check that what we read was what we sent.
//
for ( i = 0; i < (((firstReadSize+secondReadSize)+(sizeof(DWORD)-1)) / sizeof(DWORD)) - 1; i++ ) {
if (ReadValues[i] != CheckValues[i]) {
printf("\nAt index %d - values are read %x - check %x\n", i,ReadValues[i],CheckValues[i]); exit(1);
}
}
//
// Get the chars we wrote on the second write and make
// sure that they are good also.
//
if (!ReadFile( hFile, &ReadValues[0], secondWriteSize, &actuallyIoed, NULL )) {
printf("\nDidn't get all of the characters read(3) %d\n",actuallyIoed); exit(1);
}
if (actuallyIoed != secondWriteSize) {
printf("\nthird read Timed out with IO of %d\n",actuallyIoed); exit(1);
}
Sleep(2);
//
// Call clear comm error so that we can see how many characters
// are in the typeahead buffer.
//
if (!ClearCommError( hFile, &errors, &stat )) {
printf("\nCouldn't call clear comm status after resize.\n"); exit(1);
}
if (stat.cbInQue) {
printf("\nAfter second read the typeahead buffer is incorrect %d\n", stat.cbInQue); exit(1);
}
//
// Now check that what we read was what we sent.
//
for ( i = 0; i < ((secondWriteSize+(sizeof(DWORD)-1)) / sizeof(DWORD)) - 1; i++ ) {
if (ReadValues[i] != CheckValues[i]) {
printf("\nAt on read(3) index %d - values are read %x - check %x\n", i,ReadValues[i],CheckValues[i]); exit(1);
}
} }
}
|
