public void Thread_In_ErrorEvent()
{
using (SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName))
using (SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName))
{
ErrorEventHandler errorEventHandler = new ErrorEventHandler(com1, false, true);
Debug.WriteLine("Verifying that if a thread is blocked in a ErrorEvent handler the port can still be closed");
com1.Open();
com2.Open();
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
com1.ErrorReceived += errorEventHandler.HandleEvent;
//This should cause ErrorEvent to be fired with a parity error since the
//8th bit on com1 is the parity bit, com1 one expest this bit to be 1(Mark),
//and com2 is writing 0 for this bit
com1.DataBits = 7;
com1.Parity = Parity.Mark;
com2.BaseStream.Write(new byte[1], 0, 1);
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
if (!errorEventHandler.WaitForEvent(MAX_TIME_WAIT, 1))
{
Fail("Err_215887ajeid Expected 1 ErrorEvents to be fired and only {0} occured", errorEventHandler.NumEventsHandled);
}
Task task = Task.Run(() => com1.Close());
Thread.Sleep(5000);
errorEventHandler.ResumeHandleEvent();
TCSupport.WaitForTaskCompletion(task);
}
}
/*
* public bool ErrorEvent_TXFull()
* {
* SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName);
* SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName);
* ErrorEventHandler errEventHandler = new ErrorEventHandler(com1);
* bool retValue = true;
* int elapsedTime;
*
* Console.WriteLine("Verifying TXFull event");
*
* com1.Handshake = Handshake.RequestToSend;
* com1.Open();
* com2.Open();
*
* com1.ErrorEvent += new SerialErrorEventHandler(errEventHandler.HandleEvent);
* com1.BaseStream.BeginWrite(new byte[32767], 0, 32767, null, null);
* elapsedTime = 0;
*
* while(1 > errEventHandler.NumEventsHandled && elapsedTime < MAX_TIME_WAIT) {
* System.Threading.Thread.Sleep(ITERATION_TIME_WAIT);
* elapsedTime += ITERATION_TIME_WAIT;
* }
*
* retValue &= errEventHandler.Validate(SerialErrors.TxFull, com1.ReceivedBytesThreshold, 0);
*
* if(!retValue) {
* Console.WriteLine("Err_001!!! Verifying TXFull event FAILED");
* }
*
* if(com1.IsOpen)
* com1.Close();
*
* if(com2.IsOpen)
* com2.Close();
*
* return retValue;
* }
*/
public bool ErrorEvent_RxOver()
{
SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName);
SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName);
ErrorEventHandler errEventHandler = new ErrorEventHandler(com1);
bool retValue = true;
Console.WriteLine("Verifying RxOver event");
com1.Handshake = Handshake.RequestToSend;
com1.BaudRate = 115200;
com2.BaudRate = 115200;
com1.Open();
com2.Open();
//This might not be necessary but it will clear the RTS pin when the buffer is too full
com1.Handshake = Handshake.RequestToSend;
com1.ErrorReceived += new SerialErrorReceivedEventHandler(errEventHandler.HandleEvent);
//This is overkill should find a more reasonable ammount of bytes to write
com2.BaseStream.Write(new byte[32767], 0, 32767);
if (!errEventHandler.WaitForEvent(MAX_TIME_WAIT, 1))
{
Console.WriteLine("Err_298292haid Event never occured");
retValue = false;
}
while (0 < errEventHandler.NumEventsHandled)
{
if (!errEventHandler.Validate(SerialError.RXOver, -1))
{
Console.WriteLine("Err_2929ajidz!!! Expected all errors to be RXOver but at least one is:{0}", errEventHandler.EventType[0]);
retValue = false;
}
}
if (!retValue)
{
Console.WriteLine("Err_002!!! Verifying RxOver event FAILED");
}
lock (com1)
{
if (com1.IsOpen)
{
com1.Close();
}
}
if (com2.IsOpen)
{
com2.Close();
}
return(retValue);
}
/*
* public bool ErrorEvent_Overrun()
* {
* SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName);
* SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName);
* ErrorEventHandler errEventHandler = new ErrorEventHandler(com1);
* bool retValue = true;
* int elapsedTime;
*
* Console.WriteLine("Verifying Overrun event");
*
* com1.Handshake = Handshake.RequestToSend;
* com1.BaudRate = 115200;
* com2.BaudRate = 115200;
* com1.Open();
* com2.Open();
*
* com1.ErrorEvent += new SerialErrorEventHandler(errEventHandler.HandleEvent);
* com2.BaseStream.Write(new byte[32767], 0, 32767);
*
* elapsedTime = 0;
*
* while(1 > errEventHandler.NumEventsHandled && elapsedTime < MAX_TIME_WAIT) {
* System.Threading.Thread.Sleep(ITERATION_TIME_WAIT);
* elapsedTime += ITERATION_TIME_WAIT;
* }
*
* retValue &= errEventHandler.Validate(SerialErrors.Overrun, com1.ReceivedBytesThreshold, 0);
*
* if(!retValue) {
* Console.WriteLine("Err_003!!! Verifying Overrun event FAILED");
* }
*
* if(com1.IsOpen)
* com1.Close();
*
* if(com2.IsOpen)
* com2.Close();
*
* return retValue;
* }
*/
public bool ErrorEvent_RxParity()
{
SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName);
SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName);
ErrorEventHandler errEventHandler = new ErrorEventHandler(com1);
bool retValue = true;
Console.WriteLine("Verifying RxParity event");
com1.DataBits = 7;
com1.Parity = Parity.Mark;
com1.Open();
com2.Open();
com1.ErrorReceived += new SerialErrorReceivedEventHandler(errEventHandler.HandleEvent);
for (int i = 0; i < NUM_TRYS; i++)
{
Console.WriteLine("Verifying RxParity event try: {0}", i);
com2.BaseStream.Write(new byte[8], 0, 8);
errEventHandler.WaitForEvent(MAX_TIME_WAIT, 1);
while (0 < errEventHandler.NumEventsHandled)
{
if (!errEventHandler.Validate(SerialError.RXParity, -1))
{
Console.WriteLine("Err_2929ajidz!!! Expected all errors to be RXParity but at least one is:{0}", errEventHandler.EventType[0]);
retValue = false;
}
}
}
if (!retValue)
{
Console.WriteLine("Err_004!!! Verifying RxParity event FAILED");
}
lock (com1)
{
if (com1.IsOpen)
{
com1.Close();
}
}
if (com2.IsOpen)
{
com2.Close();
}
return(retValue);
}
public void ErrorEvent_Frame()
{
using (SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName))
using (SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName))
{
ErrorEventHandler errEventHandler = new ErrorEventHandler(com1);
byte[] frameErrorBytes = new byte[1];
Random rndGen = new Random();
Debug.WriteLine("Verifying Frame event");
com1.DataBits = 7;
//com1.StopBits = StopBits.Two;
com1.Open();
com2.Open();
com1.ErrorReceived += errEventHandler.HandleEvent;
for (int i = 0; i < frameErrorBytes.Length; i++)
{
frameErrorBytes[i] = (byte)rndGen.Next(0, 256);
}
//This should cause a frame error since the 8th bit is not set
//and com1 is set to 7 data bits ao the 8th bit will +12v where
//com1 expects the stop bit at the 8th bit to be -12v
frameErrorBytes[0] = 0x01;
for (int i = 0; i < NUM_TRYS; i++)
{
Debug.WriteLine("Verifying Frame event try: {0}", i);
com2.BaseStream.Write(frameErrorBytes, 0, 1);
errEventHandler.WaitForEvent(MAX_TIME_WAIT, 1);
while (0 < errEventHandler.NumEventsHandled)
{
errEventHandler.Validate(SerialError.Frame, -1);
}
}
lock (com1)
{
if (com1.IsOpen)
{
com1.Close();
}
}
}
}
public bool Thread_In_ErrorEvent()
{
SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName);
SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName);
ErrorEventHandler errorEventHandler = new ErrorEventHandler(com1, false, true);
Thread closeThread = new Thread(delegate() { com1.Close(); });
bool retValue = true;
Console.WriteLine("Verifying that if a thread is blocked in a ErrorEvent handler the port can still be closed");
com1.Open();
com2.Open();
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
com1.ErrorReceived += new SerialErrorReceivedEventHandler(errorEventHandler.HandleEvent);
//This should cause ErrorEvent to be fired with a parity error since the
//8th bit on com1 is the parity bit, com1 one expest this bit to be 1(Mark),
//and com2 is writing 0 for this bit
com1.DataBits = 7;
com1.Parity = Parity.Mark;
com2.BaseStream.Write(new byte[1], 0, 1);
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
if (!errorEventHandler.WaitForEvent(MAX_TIME_WAIT, 1))
{
Console.WriteLine("Err_215887ajeid Expected 1 ErrorEvents to be fired and only {0} occured", errorEventHandler.NumEventsHandled);
retValue = false;
}
closeThread.Start();
Thread.Sleep(5000);
errorEventHandler.ResumeHandleEvent();
closeThread.Join();
if (com1.IsOpen)
{
com1.Close();
}
if (com2.IsOpen)
{
com2.Close();
}
return(retValue);
}
public void ErrorEvent_RxOver()
{
using (SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName))
using (SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName))
{
ErrorEventHandler errEventHandler = new ErrorEventHandler(com1);
Debug.WriteLine("Verifying RxOver event");
com1.Handshake = Handshake.RequestToSend;
com1.BaudRate = 115200;
com2.BaudRate = 115200;
com1.Open();
com2.Open();
//This might not be necessary but it will clear the RTS pin when the buffer is too full
com1.Handshake = Handshake.RequestToSend;
com1.ErrorReceived += errEventHandler.HandleEvent;
//This is overkill should find a more reasonable amount of bytes to write
com2.BaseStream.Write(new byte[32767], 0, 32767);
Assert.True(errEventHandler.WaitForEvent(MAX_TIME_WAIT, 1), "Event never occurred");
while (0 < errEventHandler.NumEventsHandled)
{
errEventHandler.Validate(SerialError.RXOver, -1);
}
lock (com1)
{
if (com1.IsOpen)
{
com1.Close();
}
}
}
}
public void ErrorEvent_RxParity()
{
using (SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName))
using (SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName))
{
ErrorEventHandler errEventHandler = new ErrorEventHandler(com1);
Debug.WriteLine("Verifying RxParity event");
com1.DataBits = 7;
com1.Parity = Parity.Mark;
com1.Open();
com2.Open();
com1.ErrorReceived += errEventHandler.HandleEvent;
for (int i = 0; i < NUM_TRYS; i++)
{
Debug.WriteLine("Verifying RxParity event try: {0}", i);
com2.BaseStream.Write(new byte[8], 0, 8);
Assert.True(errEventHandler.WaitForEvent(MAX_TIME_WAIT, 1));
while (0 < errEventHandler.NumEventsHandled)
{
errEventHandler.Validate(SerialError.RXParity, -1);
}
}
lock (com1)
{
if (com1.IsOpen)
{
com1.Close();
}
}
}
}
public void EventHandlers_CalledSerially()
{
using (SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName))
using (SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName))
{
PinChangedEventHandler pinChangedEventHandler = new PinChangedEventHandler(com1, false, true);
ReceivedEventHandler receivedEventHandler = new ReceivedEventHandler(com1, false, true);
ErrorEventHandler errorEventHandler = new ErrorEventHandler(com1, false, true);
int numPinChangedEvents = 0, numErrorEvents = 0, numReceivedEvents = 0;
int iterationWaitTime = 100;
/***************************************************************
* Scenario Description: All of the event handlers should be called sequentially never
* at the same time on multiple thread. Basically we will block each event handler caller thread and verify
* that no other thread is in another event handler
*
***************************************************************/
Debug.WriteLine("Verifying that event handlers are called serially");
com1.WriteTimeout = 5000;
com2.WriteTimeout = 5000;
com1.Open();
com2.Open();
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
com1.PinChanged += pinChangedEventHandler.HandleEvent;
com1.DataReceived += receivedEventHandler.HandleEvent;
com1.ErrorReceived += errorEventHandler.HandleEvent;
//This should cause ErrorEvent to be fired with a parity error since the
//8th bit on com1 is the parity bit, com1 one expest this bit to be 1(Mark),
//and com2 is writing 0 for this bit
com1.DataBits = 7;
com1.Parity = Parity.Mark;
com2.BaseStream.Write(new byte[1], 0, 1);
Debug.Print("ERROREvent Triggered");
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause PinChangedEvent to be fired with SerialPinChanges.DsrChanged
//since we are setting DtrEnable to true
com2.DtrEnable = true;
Debug.WriteLine("PinChange Triggered");
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause ReceivedEvent to be fired with ReceivedChars
//since we are writing some bytes
com1.DataBits = 8;
com1.Parity = Parity.None;
com2.BaseStream.Write(new byte[] { 40 }, 0, 1);
Debug.WriteLine("RxEvent Triggered");
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause a frame error since the 8th bit is not set,
//and com1 is set to 7 data bits so the 8th bit will +12v where
//com1 expects the stop bit at the 8th bit to be -12v
com1.DataBits = 7;
com1.Parity = Parity.None;
com2.BaseStream.Write(new byte[] { 0x01 }, 0, 1);
Debug.WriteLine("FrameError Triggered");
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause PinChangedEvent to be fired with SerialPinChanges.CtsChanged
//since we are setting RtsEnable to true
com2.RtsEnable = true;
Debug.WriteLine("PinChange Triggered");
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause ReceivedEvent to be fired with EofReceived
//since we are writing the EOF char
com1.DataBits = 8;
com1.Parity = Parity.None;
com2.BaseStream.Write(new byte[] { 26 }, 0, 1);
Debug.WriteLine("RxEOF Triggered");
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause PinChangedEvent to be fired with SerialPinChanges.Break
//since we are setting BreakState to true
com2.BreakState = true;
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
bool threadFound = true;
Stopwatch sw = Stopwatch.StartNew();
while (threadFound && sw.ElapsedMilliseconds < MAX_TIME_WAIT)
{
threadFound = false;
for (int i = 0; i < MAX_TIME_WAIT / iterationWaitTime; ++i)
{
Debug.WriteLine("Event counts: PinChange {0}, Rx {1}, error {2}", numPinChangedEvents, numReceivedEvents, numErrorEvents);
Debug.WriteLine("Waiting for pinchange event {0}ms", iterationWaitTime);
if (pinChangedEventHandler.WaitForEvent(iterationWaitTime, numPinChangedEvents + 1))
{
// A thread is in PinChangedEvent: verify that it is not in any other handler at the same time
if (receivedEventHandler.NumEventsHandled != numReceivedEvents)
{
Fail("Err_191818ahied A thread is in PinChangedEvent and ReceivedEvent");
}
if (errorEventHandler.NumEventsHandled != numErrorEvents)
{
Fail("Err_198119hjaheid A thread is in PinChangedEvent and ErrorEvent");
}
++numPinChangedEvents;
pinChangedEventHandler.ResumeHandleEvent();
threadFound = true;
break;
}
Debug.WriteLine("Waiting for rx event {0}ms", iterationWaitTime);
if (receivedEventHandler.WaitForEvent(iterationWaitTime, numReceivedEvents + 1))
{
// A thread is in ReceivedEvent: verify that it is not in any other handler at the same time
if (pinChangedEventHandler.NumEventsHandled != numPinChangedEvents)
{
Fail("Err_2288ajed A thread is in ReceivedEvent and PinChangedEvent");
}
if (errorEventHandler.NumEventsHandled != numErrorEvents)
{
Fail("Err_25158ajeiod A thread is in ReceivedEvent and ErrorEvent");
}
++numReceivedEvents;
receivedEventHandler.ResumeHandleEvent();
threadFound = true;
break;
}
Debug.WriteLine("Waiting for error event {0}ms", iterationWaitTime);
if (errorEventHandler.WaitForEvent(iterationWaitTime, numErrorEvents + 1))
{
// A thread is in ErrorEvent: verify that it is not in any other handler at the same time
if (pinChangedEventHandler.NumEventsHandled != numPinChangedEvents)
{
Fail("Err_01208akiehd A thread is in ErrorEvent and PinChangedEvent");
}
if (receivedEventHandler.NumEventsHandled != numReceivedEvents)
{
Fail("Err_1254847ajied A thread is in ErrorEvent and ReceivedEvent");
}
++numErrorEvents;
errorEventHandler.ResumeHandleEvent();
threadFound = true;
break;
}
}
}
if (!pinChangedEventHandler.WaitForEvent(MAX_TIME_WAIT, 3))
{
Fail("Err_2288ajied Expected 3 PinChangedEvents to be fired and only {0} occured",
pinChangedEventHandler.NumEventsHandled);
}
if (!receivedEventHandler.WaitForEvent(MAX_TIME_WAIT, 2))
{
Fail("Err_122808aoeid Expected 2 ReceivedEvents to be fired and only {0} occured",
receivedEventHandler.NumEventsHandled);
}
if (!errorEventHandler.WaitForEvent(MAX_TIME_WAIT, 2))
{
Fail("Err_215887ajeid Expected 3 ErrorEvents to be fired and only {0} occured",
errorEventHandler.NumEventsHandled);
}
//[] Verify all PinChangedEvents should have occured
pinChangedEventHandler.Validate(SerialPinChange.DsrChanged, 0);
pinChangedEventHandler.Validate(SerialPinChange.CtsChanged, 0);
pinChangedEventHandler.Validate(SerialPinChange.Break, 0);
//[] Verify all ReceivedEvent should have occured
receivedEventHandler.Validate(SerialData.Chars, 0);
receivedEventHandler.Validate(SerialData.Eof, 0);
//[] Verify all ErrorEvents should have occured
errorEventHandler.Validate(SerialError.RXParity, 0);
errorEventHandler.Validate(SerialError.Frame, 0);
// It's important that we close com1 BEFORE com2 (the using() block would do this the other way around normally)
// This is because we have our special blocking event handlers hooked onto com1, and closing com2 is likely to
// cause a pin-change event which then hangs and prevents com1 from closing.
// An alternative approach would be to unhook all the event-handlers before leaving the using() block.
com1.Close();
}
}
public void EventHandler_ThrowsException()
{
using (SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName))
using (SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName))
{
PinChangedEventHandler pinChangedEventHandler = new PinChangedEventHandler(com1, true);
ReceivedEventHandler receivedEventHandler = new ReceivedEventHandler(com1, true);
ErrorEventHandler errorEventHandler = new ErrorEventHandler(com1, true);
/***************************************************************
* Scenario Description: All of the event handler are going to throw and we are
* going to verify that the event handler will still get called.
*
* We want to verify that throwing does not cause the thread calling the event
* handlers to die.
***************************************************************/
Debug.WriteLine("Verifying where the event handlers throws");
com1.Open();
com2.Open();
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
com1.PinChanged += pinChangedEventHandler.HandleEvent;
com1.DataReceived += receivedEventHandler.HandleEvent;
com1.ErrorReceived += errorEventHandler.HandleEvent;
//This should cause ErrorEvent to be fired with a parity error since the
//8th bit on com1 is the parity bit, com1 one expest this bit to be 1(Mark),
//and com2 is writing 0 for this bit
com1.DataBits = 7;
com1.Parity = Parity.Mark;
com2.BaseStream.Write(new byte[1], 0, 1);
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause PinChangedEvent to be fired with SerialPinChanges.DsrChanged
//since we are setting DtrEnable to true
com2.DtrEnable = true;
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause ReceivedEvent to be fired with ReceivedChars
//since we are writing some bytes
com1.DataBits = 8;
com1.Parity = Parity.None;
com2.BaseStream.Write(new byte[] { 40 }, 0, 1);
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause a fame error since the 8th bit is not set,
//and com1 is set to 7 data bits so the 8th bit will +12v where
//com1 expects the stop bit at the 8th bit to be -12v
com1.DataBits = 7;
com1.Parity = Parity.None;
com2.BaseStream.Write(new byte[] { 0x01 }, 0, 1);
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause PinChangedEvent to be fired with SerialPinChanges.CtsChanged
//since we are setting RtsEnable to true
com2.RtsEnable = true;
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause ReceivedEvent to be fired with EofReceived
//since we are writing the EOF char
com1.DataBits = 8;
com1.Parity = Parity.None;
com2.BaseStream.Write(new byte[] { 26 }, 0, 1);
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause PinChangedEvent to be fired with SerialPinChanges.Break
//since we are setting BreakState to true
com2.BreakState = true;
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
if (!pinChangedEventHandler.WaitForEvent(MAX_TIME_WAIT, 3))
{
Fail("Err_28282haied Expected 3 PinChangedEvents to be fired and only {0} occured",
pinChangedEventHandler.NumEventsHandled);
}
if (!receivedEventHandler.WaitForEvent(MAX_TIME_WAIT, 2))
{
Fail("Err_2912hsie Expected 2 ReceivedEvents to be fired and only {0} occured",
receivedEventHandler.NumEventsHandled);
}
if (!errorEventHandler.WaitForEvent(MAX_TIME_WAIT, 2))
{
Fail("Err_191291jaied Expected 3 ErrorEvents to be fired and only {0} occured",
errorEventHandler.NumEventsHandled);
}
//[] Verify all PinChangedEvents should have occured
if (!pinChangedEventHandler.Validate(SerialPinChange.DsrChanged, 0))
{
Fail("Err_24597aqqoo!!! PinChangedEvent DsrChanged event not fired");
}
if (!pinChangedEventHandler.Validate(SerialPinChange.CtsChanged, 0))
{
Fail("Err_144754ajied!!! PinChangedEvent CtsChanged event not fired");
}
if (!pinChangedEventHandler.Validate(SerialPinChange.Break, 0))
{
Fail("Err_15488ahied!!! PinChangedEvent Break event not fired");
}
//[] Verify all ReceivedEvent should have occured
if (!receivedEventHandler.Validate(SerialData.Chars, 0))
{
Fail("Err_54552aheied!!! ReceivedEvent ReceivedChars event not fired");
}
if (!receivedEventHandler.Validate(SerialData.Eof, 0))
{
Fail("Err_4588ajeod!!! ReceivedEvent EofReceived event not fired");
}
//[] Verify all ErrorEvents should have occured
if (!errorEventHandler.Validate(SerialError.RXParity, 0))
{
Fail("Err_1051ajheid!!! ErrorEvent RxParity event not fired");
}
if (!errorEventHandler.Validate(SerialError.Frame, 0))
{
Fail("Err_61805aheud!!! ErrorEvent Frame event not fired");
}
}
}
public bool EventHandlers_CalledSerially()
{
SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName);
SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName);
PinChangedEventHandler pinChangedEventHandler = new PinChangedEventHandler(com1, false, true);
ReceivedEventHandler receivedEventHandler = new ReceivedEventHandler(com1, false, true);
ErrorEventHandler errorEventHandler = new ErrorEventHandler(com1, false, true);
bool retValue = true;
int numPinChangedEvents = 0, numErrorEvents = 0, numReceivedEvents = 0;
int iterationWaitTime = 100;
bool threadFound;
/***************************************************************
* Scenario Description: All of the event handlers should be called sequentiall never
* at the same time on multiple thread. Basically we will block a thread and verify
* that no other thread is in another event handler
*
***************************************************************/
Console.WriteLine("Verifying where the event handlers are called serially");
com1.Open();
com2.Open();
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
com1.PinChanged += new SerialPinChangedEventHandler(pinChangedEventHandler.HandleEvent);
com1.DataReceived += new SerialDataReceivedEventHandler(receivedEventHandler.HandleEvent);
com1.ErrorReceived += new SerialErrorReceivedEventHandler(errorEventHandler.HandleEvent);
//This should cause ErrorEvent to be fired with a parity error since the
//8th bit on com1 is the parity bit, com1 one expest this bit to be 1(Mark),
//and com2 is writing 0 for this bit
com1.DataBits = 7;
com1.Parity = Parity.Mark;
com2.BaseStream.Write(new byte[1], 0, 1);
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause PinChangedEvent to be fired with SerialPinChanges.DsrChanged
//since we are setting DtrEnable to true
com2.DtrEnable = true;
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause ReceivedEvent to be fired with ReceivedChars
//since we are writing some bytes
com1.DataBits = 8;
com1.Parity = Parity.None;
com2.BaseStream.Write(new byte[] { 40 }, 0, 1);
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause a fame error since the 8th bit is not set,
//and com1 is set to 7 data bits so the 8th bit will +12v where
//com1 expects the stop bit at the 8th bit to be -12v
com1.DataBits = 7;
com1.Parity = Parity.None;
com2.BaseStream.Write(new byte[] { 0x01 }, 0, 1);
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause PinChangedEvent to be fired with SerialPinChanges.CtsChanged
//since we are setting RtsEnable to true
com2.RtsEnable = true;
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause ReceivedEvent to be fired with EofReceived
//since we are writing the EOF char
com1.DataBits = 8;
com1.Parity = Parity.None;
com2.BaseStream.Write(new byte[] { 26 }, 0, 1);
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
//This should cause PinChangedEvent to be fired with SerialPinChanges.Break
//since we are setting BreakState to true
com2.BreakState = true;
Thread.Sleep(TRIGERING_EVENTS_WAIT_TIME);
threadFound = true;
while (threadFound)
{
threadFound = false;
for (int i = 0; i < MAX_TIME_WAIT / iterationWaitTime; ++i)
{
if (pinChangedEventHandler.WaitForEvent(iterationWaitTime, numPinChangedEvents + 1))
{//A thread is in PinChangedEvent verify that it is not in any other
if (receivedEventHandler.NumEventsHandled != numReceivedEvents)
{
Console.WriteLine("Err_191818ahied A thread is in PinChangedEvent and ReceivedEvent");
retValue = false;
}
if (errorEventHandler.NumEventsHandled != numErrorEvents)
{
Console.WriteLine("Err_198119hjaheid A thread is in PinChangedEvent and ErrorEvent");
retValue = false;
}
++numPinChangedEvents;
pinChangedEventHandler.ResumeHandleEvent();
threadFound = true;
break;
}
if (receivedEventHandler.WaitForEvent(iterationWaitTime, numReceivedEvents + 1))
{//A thread is in ReceivedEvent verify that it is not in any other
if (pinChangedEventHandler.NumEventsHandled != numPinChangedEvents)
{
Console.WriteLine("Err_2288ajed A thread is in ReceivedEvent and PinChangedEvent");
retValue = false;
}
if (errorEventHandler.NumEventsHandled != numErrorEvents)
{
Console.WriteLine("Err_25158ajeiod A thread is in ReceivedEvent and ErrorEvent");
retValue = false;
}
++numReceivedEvents;
receivedEventHandler.ResumeHandleEvent();
threadFound = true;
break;
}
if (errorEventHandler.WaitForEvent(iterationWaitTime, numErrorEvents + 1))
{//A thread is in ErrorEvent verify that it is not in any other
if (pinChangedEventHandler.NumEventsHandled != numPinChangedEvents)
{
Console.WriteLine("Err_01208akiehd A thread is in ErrorEvent and PinChangedEvent");
retValue = false;
}
if (receivedEventHandler.NumEventsHandled != numReceivedEvents)
{
Console.WriteLine("Err_1254847ajied A thread is in ErrorEvent and ReceivedEvent");
retValue = false;
}
++numErrorEvents;
errorEventHandler.ResumeHandleEvent();
threadFound = true;
break;
}
}
}
if (!pinChangedEventHandler.WaitForEvent(MAX_TIME_WAIT, 3))
{
Console.WriteLine("Err_2288ajied Expected 3 PinChangedEvents to be fired and only {0} occured", pinChangedEventHandler.NumEventsHandled);
retValue = false;
}
if (!receivedEventHandler.WaitForEvent(MAX_TIME_WAIT, 2))
{
Console.WriteLine("Err_122808aoeid Expected 2 ReceivedEvents to be fired and only {0} occured", receivedEventHandler.NumEventsHandled);
retValue = false;
}
if (!errorEventHandler.WaitForEvent(MAX_TIME_WAIT, 2))
{
Console.WriteLine("Err_215887ajeid Expected 3 ErrorEvents to be fired and only {0} occured", errorEventHandler.NumEventsHandled);
retValue = false;
}
//[] Verify all PinChangedEvents should have occured
if (!pinChangedEventHandler.Validate(SerialPinChange.DsrChanged, 0))
{
Console.WriteLine("Err_258087aieid!!! PinChangedEvent DsrChanged event not fired");
retValue = false;
}
if (!pinChangedEventHandler.Validate(SerialPinChange.CtsChanged, 0))
{
Console.WriteLine("Err_5548ajhied!!! PinChangedEvent CtsChanged event not fired");
retValue = false;
}
if (!pinChangedEventHandler.Validate(SerialPinChange.Break, 0))
{
Console.WriteLine("Err_25848ajiied!!! PinChangedEvent Break event not fired");
retValue = false;
}
//[] Verify all ReceivedEvent should have occured
if (!receivedEventHandler.Validate(SerialData.Chars, 0))
{
Console.WriteLine("Err_0211558ajoied!!! ReceivedEvent ReceivedChars event not fired");
retValue = false;
}
if (!receivedEventHandler.Validate(SerialData.Eof, 0))
{
Console.WriteLine("Err_215588zahid!!! ReceivedEvent EofReceived event not fired");
retValue = false;
}
//[] Verify all ErrorEvents should have occured
if (!errorEventHandler.Validate(SerialError.RXParity, 0))
{
Console.WriteLine("Err_515188ahjid!!! ErrorEvent RxParity event not fired");
retValue = false;
}
if (!errorEventHandler.Validate(SerialError.Frame, 0))
{
Console.WriteLine("Err_55874884ajie!!! ErrorEvent Frame event not fired");
retValue = false;
}
if (com1.IsOpen)
{
com1.Close();
}
if (com2.IsOpen)
{
com2.Close();
}
return(retValue);
}
public bool ErrorEvent_Frame()
{
SerialPort com1 = new SerialPort(TCSupport.LocalMachineSerialInfo.FirstAvailablePortName);
SerialPort com2 = new SerialPort(TCSupport.LocalMachineSerialInfo.SecondAvailablePortName);
ErrorEventHandler errEventHandler = new ErrorEventHandler(com1);
bool retValue = true;
byte[] frameErrorBytes = new byte[1];
Random rndGen = new Random();
Console.WriteLine("Verifying Frame event");
com1.DataBits = 7;
//com1.StopBits = StopBits.Two;
com1.Open();
com2.Open();
com1.ErrorReceived += new SerialErrorReceivedEventHandler(errEventHandler.HandleEvent);
for (int i = 0; i < frameErrorBytes.Length; i++)
{
frameErrorBytes[i] = (byte)rndGen.Next(0, 256);
}
//This should cause a fame error since the 8th bit is not set
//and com1 is set to 7 data bits ao the 8th bit will +12v where
//com1 expects the stop bit at the 8th bit to be -12v
frameErrorBytes[0] = 0x01;
for (int i = 0; i < NUM_TRYS; i++)
{
Console.WriteLine("Verifying Frame event try: {0}", i);
com2.BaseStream.Write(frameErrorBytes, 0, 1);
errEventHandler.WaitForEvent(MAX_TIME_WAIT, 1);
while (0 < errEventHandler.NumEventsHandled)
{
if (!errEventHandler.Validate(SerialError.Frame, -1))
{
Console.WriteLine("Err_25097qpaua!!! Expected all errors to be Frame but at least one is:{0}", errEventHandler.EventType[0]);
retValue = false;
}
}
}
if (!retValue)
{
Console.WriteLine("Err_005!!! Verifying Frame event FAILED");
}
lock (com1)
{
if (com1.IsOpen)
{
com1.Close();
}
}
if (com2.IsOpen)
{
com2.Close();
}
return(retValue);
}
