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