public void Add(int id, ETestResult result)
{
if (!_scenarioData.ContainsKey(id))
{
_scenarioData.Add(id, result);
}
}
public void Add(int id, ETestResult result)
{
if (!_scenarioData.ContainsKey(id))
{
_scenarioData.Add(id, result);
}
}
/**
* <summary> Main function of the receive thread </summary>
*/
private void ReceiveThreadMain()
{
try
{
int completedCount = 0;
for (int i = 0; i < m_packetCount; i++)
{
byte[] packet = m_socket.Receive(ref m_fpgaEndPoint);
SetPacketsReceived(i + 1);
//Check Size
if (packet.Length != m_packetSize)
{
m_testResult = ETestResult.WrongSize;
break;
}
//Check Content
if (m_checkContent)
{
byte[] expectedArray;
if (!m_packetFifo.TryDequeue(out expectedArray))
{
throw new Exception("Received more Packets than sent");
}
if (!expectedArray.ArraysEqual(packet))
{
m_testResult = ETestResult.WrongData;
break;
}
}
//Release one more token for send side
m_openPacketsSemaphore.Release(1);
completedCount = i + 1;
}
//Release all tokens not yet released
if (m_packetCount - completedCount > 0)
{
m_openPacketsSemaphore.Release(m_packetCount - completedCount);
}
m_testResult = ETestResult.Success;
}
//Socket exception occurs on close in timeout case
catch (Exception ex)
{
if (ex is SocketException || ex is ObjectDisposedException)
{
m_testResult = ETestResult.TimeOut;
}
else
{
throw ex;
}
}
}
/// <summary>
/// Run all methods set RollbackScenario attribute from minimum to maximum.
/// RollbackScenario ID is as same as Scenario ID which need roll back.
/// </summary>
private void Rollback(Type type, Object instance, IDictionary <int, MethodInfo> dictRollbackScenario, int sidNeedRollback)
{
try
{
if (dictRollbackScenario.Count > 0 && dictRollbackScenario.ContainsKey(sidNeedRollback))
{
try
{
_reporter.LogDebug("---------------------------------------------------");
_reporter.LogDebug("Rollback Scenario: [{0}] - {1} START.", sidNeedRollback, dictRollbackScenario[sidNeedRollback].Name);
var result = type.InvokeMember(dictRollbackScenario[sidNeedRollback].Name, BindingFlags.InvokeMethod, null, instance, new object[0]);
if (result == null)
{
_reporter.LogInfo("Rollback Scenario [{0}] - DONE", sidNeedRollback);
}
if (result is ETestResult)
{
ETestResult returnResult = (ETestResult)result;
if (returnResult == ETestResult.Fail || returnResult == ETestResult.Blocked)
{
_reporter.LogWarning("Rollback Scenario [{0}] - [{1}]", sidNeedRollback, returnResult);
}
else
{
_reporter.LogInfo("Rollback Scenario [{0}] - [{1}]", sidNeedRollback, returnResult);
}
_reporter.LogInfo("Rollback Scenario [{0}] - DONE", sidNeedRollback);
}
else
{
_reporter.LogInfo("Rollback Scenarios [{0}] returned value: {1}", sidNeedRollback, result);
}
}
catch (Exception rollScErr)
{
if (rollScErr.InnerException != null)
{
_reporter.LogError("RollbackScenario [{0}] thrown an exception - {1}", sidNeedRollback, rollScErr.InnerException.Message);
}
else
{
_reporter.LogError("RollbackScenario [{0}] thrown an exception - {1}", sidNeedRollback, rollScErr.Message);
}
}
}
}
catch (Exception rollErr)
{
_reporter.LogWarning(rollErr.Message);
}
}
/****************************************************************************************/
/* Private Methods */
/****************************************************************************************/
/**
* <summary> Test thread main function </summary>
*/
private void TestThreadMain()
{
//Create test infrastructure
m_socket = new UdpClient(m_localPort);
m_socket.Connect(m_fpgaEndPoint);
m_sendThread = new Thread(SendThreadMain);
m_receiveThread = new Thread(ReceiveThreadMain);
//Execute test
m_openPacketsSemaphore = new Semaphore(10, 1000000000);
m_packetFifo = new ConcurrentQueue <byte[]>();
SetPacketsSent(0);
SetPacketsReceived(0);
SetTestState("Test running", Color.Yellow);
m_receiveThread.Start();
m_sendThread.Start();
m_sendThread.Join();
if (!m_receiveThread.Join(m_timeoutMs))
{
m_testResult = ETestResult.TimeOut;
}
m_socket.Close();
//GUI Update
switch (m_testResult)
{
case ETestResult.Success:
SetTestState("Test successful", Color.LightGreen);
break;
case ETestResult.TimeOut:
SetTestState("Test timed out", Color.Red);
break;
case ETestResult.WrongSize:
SetTestState("Received wrong packet size", Color.Red);
break;
case ETestResult.WrongData:
SetTestState("Received wrong packet data", Color.Red);
break;
}
SetTestSettingsEnabled(true);
}
private void LogEndScenario(int sID, ETestResult testResult)
{
switch (testResult)
{
case ETestResult.Warning:
case ETestResult.Skipped:
case ETestResult.NotRun:
_reporter.LogWarning("End Scenario: [{0}] Test result: [{1}]", sID, testResult.ToString().ToUpper());
break;
case ETestResult.Pass:
_reporter.LogInfo("End Scenario: [{0}] Test result: [{1}]", sID, testResult.ToString().ToUpper());
break;
case ETestResult.Blocked:
case ETestResult.Fail:
_reporter.LogError("End Scenario: [{0}] Test result: [{1}]", sID, testResult.ToString().ToUpper());
break;
}
}
private void InvokeSteps(Type type, Object instance)
{
MethodInfo[] mInfos = type.GetMethods();
IScenarioData scenarioData = new ScenarioData();
List <MethodInfo> listMI = new List <MethodInfo>();
IDictionary <int, MethodInfo> dictRollbackScenario = new Dictionary <int, MethodInfo>();
Type scenraioAttrType = typeof(ScenarioAttribute);
Type rollbackAttrType = typeof(RollbackScenarioAttribute);
ScenarioAttribute lastRunScenario = null;
List <ScenarioAttribute> rollBackScenariosCompareList = new List <ScenarioAttribute>();
#region Get all methods set ScenarioAttribute and RollbackScenario
foreach (MethodInfo mi in mInfos)
{
foreach (ScenarioAttribute sa in mi.GetCustomAttributes(typeof(ScenarioAttribute), true))
{
if (sa.Enabled)
{
listMI.Add(mi);
}
scenarioData.Add(sa.SID, ETestResult.NotRun);
}
foreach (RollbackScenarioAttribute rbsa in mi.GetCustomAttributes(typeof(RollbackScenarioAttribute), true))
{
if (rbsa.Enabled)
{
dictRollbackScenario.Add(rbsa.SID, mi);
}
}
}
if (type.GetProperty(ETestUsage.ScenarioData.ToString()) != null)
{
type.InvokeMember(ETestUsage.ScenarioData.ToString(), BindingFlags.SetProperty, null, instance, new object[] { scenarioData });
}
#endregion
try
{
#region Invoke Init()
InvokeTestInitialize(type, instance);
#endregion
#region Invoke enabled scenario methods and rollback methods if failed or bloced
if (listMI.Count > 0)
{
listMI.Sort(
delegate(MethodInfo m1, MethodInfo m2)
{
return(((ScenarioAttribute)(m1.GetCustomAttributes(scenraioAttrType, true))[0]).SID.CompareTo(((ScenarioAttribute)(m2.GetCustomAttributes(scenraioAttrType, true))[0]).SID));
}
);
foreach (MethodInfo m in listMI)
{
ScenarioAttribute scenarioAttr = (ScenarioAttribute)m.GetCustomAttributes(true)[0];
if (scenarioAttr.Enabled)
{
_reporter.BeginScenario(scenarioAttr.SID, string.IsNullOrEmpty(scenarioAttr.Description) ? m.Name : scenarioAttr.Description);
ETestResult retVal = ETestResult.Fail;
try
{
var result = type.InvokeMember(m.Name, BindingFlags.InvokeMethod, null, instance, new Object[0]);
if (result == null)
{
_reporter.LogWarning("Scenario [{0}] returned void .", scenarioAttr.SID);
LogEndScenario(scenarioAttr.SID, ETestResult.Warning);
continue;
}
else if (result is ETestResult)
{
retVal = (ETestResult)result;
scenarioData[scenarioAttr.SID] = retVal;
LogEndScenario(scenarioAttr.SID, retVal);
if (retVal == ETestResult.Skipped || retVal == ETestResult.NotRun)
{
continue;
}
if (retVal == ETestResult.Fail)
{
lastRunScenario = scenarioAttr;
throw new TestFailException(scenarioAttr.SID);
}
if (retVal == ETestResult.Blocked)
{
lastRunScenario = scenarioAttr;
throw new TestBlockedException(scenarioAttr.SID);
}
}
else
{
_reporter.LogWarning("Scenario [{0}] retuned value was not 'ETestResult' type.", scenarioAttr.SID);
LogEndScenario(scenarioAttr.SID, ETestResult.Warning);
}
lastRunScenario = scenarioAttr;
}
catch (TestFailException failEx)
{
_reporter.LogError("{0}", failEx);
Rollback(type, instance, dictRollbackScenario, lastRunScenario.SID);
throw failEx;
}
catch (TestBlockedException blockedEx)
{
_reporter.LogError("{0}", blockedEx);
Rollback(type, instance, dictRollbackScenario, lastRunScenario.SID);
throw blockedEx;
}
catch (Exception e)
{
_reporter.LogError("{0}", e);
if (e.InnerException != null)
{
_reporter.LogError("{0}", e.InnerException);
if (e.InnerException.InnerException != null)
{
_reporter.LogError("{0}", e.InnerException.InnerException);
}
}
LogEndScenario(scenarioAttr.SID, ETestResult.Fail);
scenarioData[scenarioAttr.SID] = ETestResult.Fail;
Rollback(type, instance, dictRollbackScenario, scenarioAttr.SID);
throw e;
}
#region Rollback required scenarios when all test scenario has executed.
finally
{
ScenarioAttribute lastExpectedScenario = (ScenarioAttribute)listMI.Last().GetCustomAttributes(true)[0];
if (null != lastRunScenario && lastRunScenario.SID.Equals(lastExpectedScenario.SID))
{
Rollback(type, instance, dictRollbackScenario, lastExpectedScenario.SID);
}
}
#endregion
}
else
{
_reporter.LogDisabledScenario(scenarioAttr.SID);
LogEndScenario(scenarioAttr.SID, ETestResult.Skipped);
}
}
}
#endregion
}
finally
{
#region Invoke End()
InvokeTestCleanup(type, instance);
#endregion
}
}
public Test(IWebDriver driver)
{
Driver = driver;
Result = ETestResult.Failed;
}
private void LogEndScenario(int sID, ETestResult testResult)
{
switch (testResult)
{
case ETestResult.Warning:
case ETestResult.Skipped:
case ETestResult.NotRun:
_reporter.LogWarning("End Scenario: [{0}] Test result: [{1}]", sID, testResult.ToString().ToUpper());
break;
case ETestResult.Pass:
_reporter.LogInfo("End Scenario: [{0}] Test result: [{1}]", sID, testResult.ToString().ToUpper());
break;
case ETestResult.Blocked:
case ETestResult.Fail:
_reporter.LogError("End Scenario: [{0}] Test result: [{1}]", sID, testResult.ToString().ToUpper());
break;
}
}
