// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using OpenTap.Addin;
|
using System;
|
using System.Collections.Generic;
|
using System.Collections.ObjectModel;
|
using System.ComponentModel;
|
using System.Diagnostics;
|
using System.Linq;
|
using System.Threading;
|
using System.Threading.Tasks;
|
using System.Xml.Serialization;
|
|
namespace OpenTap
|
{
|
partial class TestPlan
|
{
|
bool runPrePlanRunMethods(IList<ITestStep> steps, TestPlanRun planRun)
|
{
|
Stopwatch preTimer = Stopwatch.StartNew(); // try to avoid calling Stopwatch.StartNew too often.
|
TimeSpan elaps = preTimer.Elapsed;
|
foreach (ITestStep step in steps)
|
{
|
if (step.Enabled == false)
|
continue;
|
bool runPre = true;
|
if (step is TestStep s)
|
{
|
runPre = s.PrePostPlanRunUsed;
|
}
|
planRun.StepsWithPrePlanRun.Add(step);
|
try
|
{
|
if (runPre)
|
{
|
planRun.AddTestStepStateUpdate(step.Id, null, StepState.PrePlanRun);
|
try
|
{
|
step.PlanRun = planRun;
|
planRun.ResourceManager.BeginStep(planRun, step, TestPlanExecutionStage.PrePlanRun, TapThread.Current.AbortToken);
|
try
|
{
|
step.PrePlanRun();
|
}
|
finally
|
{
|
planRun.ResourceManager.EndStep(step, TestPlanExecutionStage.PrePlanRun);
|
step.PlanRun = null;
|
}
|
}
|
finally
|
{
|
planRun.AddTestStepStateUpdate(step.Id, null, StepState.Idle);
|
}
|
}
|
|
if (!runPrePlanRunMethods(step.ChildTestSteps, planRun))
|
{
|
return false;
|
}
|
}
|
catch (Exception ex)
|
{
|
Log.Error(String.Format("PrePlanRun of '{0}' failed with message '{1}'.",
|
step.Name, ex.Message));
|
Log.Debug(ex);
|
Log.Error("Aborting TestPlan.");
|
return false;
|
}
|
finally
|
{
|
if (runPre)
|
{
|
var newelaps = preTimer.Elapsed;
|
|
Log.Debug(newelaps - elaps, "{0} PrePlanRun completed.", step.GetStepPath());
|
elaps = newelaps;
|
|
}
|
}
|
}
|
return true;
|
}
|
#region Nested Types
|
|
enum failState
|
{
|
Ok,
|
StartFail,
|
ExecFail
|
}
|
|
#endregion
|
|
internal static void PrintWaitingMessage(IEnumerable<IResource> resources)
|
{
|
// Save disconnected ressources to avoid race conditions.
|
var waitingRessources = resources.Where(r => !r.IsConnected).ToArray();
|
if (waitingRessources.Length == 0)
|
{
|
return;
|
}
|
|
Log.Info("Waiting for resources to open:");
|
foreach (var resource in waitingRessources)
|
{
|
Log.Info(" - {0}", resource);
|
}
|
}
|
|
failState execTestPlan(TestPlanRun execStage, IList<ITestStep> steps)
|
{
|
WaitHandle.WaitAny(new[] { execStage.PromptWaitHandle, TapThread.Current.AbortToken.WaitHandle });
|
bool resultListenerError = false;
|
execStage.ScheduleInResultProcessingThread<IResultListener>(resultListener =>
|
{
|
try
|
{
|
using (TimeoutOperation.Create(() => PrintWaitingMessage(new List<IResource>() { resultListener })))
|
execStage.ResourceManager.WaitUntilResourcesOpened(TapThread.Current.AbortToken, resultListener);
|
try
|
{
|
// some resources might set metadata in the Open methods.
|
// this information needs to be propagated to result listeners as well.
|
// this returns quickly if its a lazy resource manager.
|
using (TimeoutOperation.Create(
|
() => PrintWaitingMessage(new List<IResource>() { resultListener })))
|
execStage.ResourceManager.WaitUntilAllResourcesOpened(TapThread.Current.AbortToken);
|
}
|
catch
|
{
|
// this error will also be handled somewhere else.
|
}
|
|
execStage.WaitForSerialization();
|
foreach (var res in execStage.PromptedResources)
|
execStage.Parameters.AddRange(ResultParameters.GetMetadataFromObject(res));
|
resultListener.OnTestPlanRunStart(execStage);
|
}
|
catch (OperationCanceledException) when (execStage.MainThread.AbortToken.IsCancellationRequested)
|
{
|
// test plan thread was aborted, this is OK.
|
}
|
catch (Exception ex)
|
{
|
Log.Error("Error in OnTestPlanRunStart for '{0}': '{1}'", resultListener, ex.Message);
|
Log.Debug(ex);
|
resultListenerError = true;
|
}
|
|
}, true);
|
|
if (resultListenerError)
|
return failState.StartFail;
|
|
var sw = Stopwatch.StartNew();
|
try
|
{
|
execStage.StepsWithPrePlanRun.Clear();
|
|
// Invoke test plan pre run event mixins.
|
TestPlanPreRunEvent.Invoke(this);
|
|
if (!runPrePlanRunMethods(steps, execStage))
|
{
|
return failState.StartFail;
|
}
|
}
|
catch (Exception e)
|
{
|
Log.Error(e.GetInnerMostExceptionMessage());
|
Log.Debug(e);
|
return failState.StartFail;
|
}
|
finally
|
{
|
{
|
Log.Debug(sw, "PrePlanRun Methods completed");
|
}
|
}
|
|
Stopwatch planRunOnlyTimer = Stopwatch.StartNew();
|
var runs = new List<TestStepRun>();
|
|
bool didBreak = false;
|
void addBreakResult(TestStepRun run)
|
{
|
if (didBreak) return;
|
didBreak = true;
|
execStage.Parameters.Add(new ResultParameter(TestPlanRun.SpecialParameterNames.BreakIssuedFrom, run.Id.ToString()));
|
}
|
|
TestStepRun getBreakingRun(TestStepRun first)
|
{
|
while ((first.Exception as TestStepBreakException)?.Run is { } inner)
|
first = inner;
|
return first;
|
}
|
|
try
|
{
|
for (int i = 0; i < steps.Count; i++)
|
{
|
var step = steps[i];
|
if (step.Enabled == false) continue;
|
var run = step.DoRun(execStage, execStage);
|
if (!run.Skipped)
|
runs.Add(run);
|
if (run.BreakConditionsSatisfied())
|
{
|
var breakingRun = getBreakingRun(run);
|
addBreakResult(breakingRun);
|
run.LogBreakCondition();
|
break;
|
}
|
|
// note: The following is copied inside TestStep.cs
|
if (run.SuggestedNextStep is Guid id)
|
{
|
int nextindex = steps.IndexWhen(x => x.Id == id);
|
if (nextindex >= 0)
|
i = nextindex - 1;
|
// if skip to next step, dont add it to the wait queue.
|
}
|
}
|
}
|
catch (TestStepBreakException breakEx)
|
{
|
var breakingRun = getBreakingRun(breakEx.Run);
|
addBreakResult(breakingRun);
|
Log.Info("{0}", breakEx.Message);
|
}
|
finally
|
{
|
// Now wait for them to actually complete. They might defer internally.
|
foreach (var run in runs)
|
{
|
run.WaitForCompletion();
|
execStage.UpgradeVerdict(run.Verdict);
|
}
|
}
|
|
Log.Debug(planRunOnlyTimer, "Test step runs finished.");
|
|
return failState.Ok;
|
}
|
|
void finishTestPlanRun(TestPlanRun run, Stopwatch testPlanTimer, failState runWentOk, TraceListener Logger, HybridStream logStream)
|
{
|
try
|
{
|
if (run != null)
|
{
|
if (runWentOk == failState.StartFail)
|
{
|
if (PrintTestPlanRunSummary)
|
summaryListener.OnTestPlanRunStart(run); // Call this to ensure that the correct planrun is being summarized
|
|
if (run.Verdict < Verdict.Aborted)
|
run.Verdict = Verdict.Error;
|
}
|
|
for (int i = run.StepsWithPrePlanRun.Count - 1; i >= 0; i--)
|
{
|
Stopwatch postTimer = Stopwatch.StartNew();
|
String stepPath = string.Empty;
|
try
|
{
|
ITestStep step = run.StepsWithPrePlanRun[i];
|
|
if ((step as TestStep)?.PrePostPlanRunUsed ?? true)
|
{
|
stepPath = step.GetStepPath();
|
run.AddTestStepStateUpdate(step.Id, null, StepState.PostPlanRun);
|
try
|
{
|
run.ResourceManager.BeginStep(run, step, TestPlanExecutionStage.PostPlanRun, TapThread.Current.AbortToken);
|
step.PlanRun = run;
|
try
|
{
|
step.PostPlanRun();
|
}
|
finally
|
{
|
run.ResourceManager.EndStep(step, TestPlanExecutionStage.PostPlanRun);
|
step.PlanRun = null;
|
}
|
}
|
finally
|
{
|
run.AddTestStepStateUpdate(step.Id, null, StepState.Idle);
|
}
|
Log.Debug(postTimer, "{0} PostPlanRun completed.", stepPath);
|
}
|
}
|
catch (Exception ex)
|
{
|
Log.Warning("Error during post plan run of {0}.", stepPath);
|
Log.Debug(ex);
|
}
|
}
|
run.Duration = testPlanTimer.Elapsed;
|
}
|
|
if (run != null)
|
{
|
|
try
|
{
|
// The open resource threads might throw exceptions. If they do we must
|
// Wait() for them to catch the exception.
|
// If the run was aborted after the open resource threads were started but
|
// before we wait for them (e.g. by an error in PrePlanRun), then we do it
|
// here.
|
run.ResourceManager.WaitUntilAllResourcesOpened(TapThread.Current.AbortToken);
|
}
|
catch (OperationCanceledException)
|
{
|
// Ignore this because this typically means that the wait was cancelled before.
|
// Just to be sure also upgrade verdict to aborted.
|
run.UpgradeVerdict(Verdict.Aborted);
|
}
|
catch (Exception e)
|
{
|
Log.Error("Failed to open resource ({0})", e.GetInnerMostExceptionMessage());
|
Log.Debug(e);
|
}
|
|
if (PrintTestPlanRunSummary)
|
{
|
// wait for the summaryListener so the summary appears in the log file.
|
run.WaitForResultListener(summaryListener);
|
summaryListener.PrintSummary();
|
}
|
|
OpenTap.Log.Flush();
|
Logger.Flush();
|
logStream.Flush();
|
|
run.AddTestPlanCompleted(logStream, runWentOk != failState.StartFail);
|
|
if (PrintTestPlanRunSummary)
|
summaryListener.PrintArtifactsSummary();
|
run.ResourceManager.EndStep(this, TestPlanExecutionStage.Execute);
|
|
if (!run.IsCompositeRun)
|
run.ResourceManager.EndStep(this, TestPlanExecutionStage.Open);
|
}
|
}
|
finally
|
{
|
if (monitors != null)
|
foreach (var item in monitors)
|
item.ExitTestPlanRun(run);
|
}
|
}
|
/// <summary> When true, prints the test plan run summary at the end of a run. </summary>
|
[XmlIgnore]
|
[AnnotationIgnore]
|
public bool PrintTestPlanRunSummary { get; set; }
|
|
/// <summary>
|
/// FileGlobals±äÁ¿
|
/// </summary>
|
public ObservableCollection<TestVariable> ParameterVariables { get; set; } = new ObservableCollection<TestVariable>();
|
public ObservableCollection<TestVariable> Variables { get; set; } = new ObservableCollection<TestVariable>();
|
|
/// <summary>
|
/// Calls the PromptForDutMetadata delegate for all referenced DUTs.
|
/// </summary>
|
internal void StartResourcePromptAsync(TestPlanRun planRun, IEnumerable<IResource> _resources)
|
{
|
var resources = _resources.Where(x => x != null).ToArray();
|
|
var componentSettingsWithMetaData = new List<ITypeData>();
|
var componentSettings = TypeData.GetDerivedTypes<ComponentSettings>()
|
.Where(type => type.CanCreateInstance);
|
bool anyMetaData = false;
|
planRun.PromptWaitHandle.Reset();
|
|
try
|
{
|
foreach (var setting in componentSettings)
|
{
|
foreach (var member in setting.GetMembers())
|
{
|
var attr = member.GetAttribute<MetaDataAttribute>();
|
if (attr != null && attr.PromptUser)
|
{
|
anyMetaData = true;
|
componentSettingsWithMetaData.Add(setting);
|
break; // avoid adding this multiple times.
|
}
|
}
|
}
|
|
foreach (var resource in resources)
|
{
|
if (anyMetaData) break;
|
var type = TypeData.GetTypeData(resource);
|
foreach (var prop in type.GetMembers())
|
{
|
var attr = prop.GetAttribute<MetaDataAttribute>();
|
if (attr != null && attr.PromptUser)
|
{
|
anyMetaData = true;
|
break;
|
}
|
}
|
}
|
}
|
catch
|
{
|
// this is just a defensive catch to make sure that the WaitHandle is not left unset (and we risk waiting for it indefinitely)
|
planRun.PromptWaitHandle.Set();
|
throw;
|
}
|
|
if (anyMetaData && EngineSettings.Current.PromptForMetaData)
|
{
|
TapThread.Start(() =>
|
{
|
try
|
{
|
List<object> objects = new List<object>();
|
objects.AddRange(componentSettingsWithMetaData.Select(ComponentSettings.GetCurrent));
|
objects.AddRange(resources);
|
objects.RemoveIf<object>(x => x == null); //ComponentSettings.GetCurrent can return null for abstract types.
|
|
planRun.PromptedResources = resources;
|
var obj = new MetadataPromptObject { Resources = objects };
|
UserInput.Request(obj, false);
|
if (obj.Response == MetadataPromptObject.PromptResponse.Abort)
|
planRun.MainThread.Abort();
|
}
|
catch (Exception e)
|
{
|
Log.Debug(e);
|
planRun.MainThread.Abort("Error occured while executing platform requests. Metadata prompt can be disabled from the Engine settings menu.");
|
}
|
finally
|
{
|
planRun.PromptWaitHandle.Set();
|
}
|
}, name: "Request Metadata");
|
}
|
else
|
{
|
planRun.PromptWaitHandle.Set();
|
}
|
}
|
|
/// <summary>
|
/// Blocking Execute TestPlan. Uses ResultListeners from ResultSettings.Current.
|
/// </summary>
|
/// <returns>Result of test plan run as a TestPlanRun object.</returns>
|
public TestPlanRun Execute()
|
{
|
return Execute(ResultSettings.Current, null);
|
}
|
|
/// <summary>Executes the test plan asynchronously </summary>
|
/// <returns>A task returning the test plan run.</returns>
|
public Task<TestPlanRun> ExecuteAsync()
|
{
|
return ExecuteAsync(ResultSettings.Current, null, null, TapThread.Current.AbortToken);
|
}
|
|
/// <summary>
|
/// Executes the test plan asynchronously.
|
/// </summary>
|
/// <param name="abortToken">This abort token can be used to abort the operation.</param>
|
/// <returns>A task returning the test plan run.</returns>
|
public Task<TestPlanRun> ExecuteAsync(CancellationToken abortToken)
|
{
|
return ExecuteAsync(ResultSettings.Current, null, null, abortToken);
|
}
|
|
readonly TestPlanRunSummaryListener summaryListener = new TestPlanRunSummaryListener();
|
/// <summary>
|
/// Execute the TestPlan as specified.
|
/// </summary>
|
/// <param name="resultListeners">ResultListeners for result outputs.</param>
|
/// <param name="metaDataParameters">Optional metadata parameters.</param>
|
/// <param name="stepsOverride">Sub-section of test plan to be executed. Note this might include child steps of disabled parent steps.</param>
|
/// <param name="cancellationToken">Cancellation token to abort the testplan</param>
|
/// <returns>TestPlanRun results, no StepResults.</returns>
|
public Task<TestPlanRun> ExecuteAsync(IEnumerable<IResultListener> resultListeners, IEnumerable<ResultParameter> metaDataParameters, HashSet<ITestStep> stepsOverride, CancellationToken cancellationToken)
|
{
|
var tcs = new TaskCompletionSource<TestPlanRun>();
|
TapThread.Start(() =>
|
{
|
try
|
{
|
cancellationToken.Register(TapThread.Current.Abort);
|
var testPlanRun = Execute(resultListeners, metaDataParameters, stepsOverride);
|
tcs.SetResult(testPlanRun);
|
}
|
catch (Exception e)
|
{
|
tcs.SetException(e);
|
}
|
}, "Plan Thread");
|
return tcs.Task;
|
}
|
|
internal static ThreadHierarchyLocal<TestPlanRun> executingPlanRun = new ThreadHierarchyLocal<TestPlanRun>();
|
|
/// <summary>
|
/// Execute the TestPlan as specified. Blocking.
|
/// </summary>
|
/// <param name="resultListeners">ResultListeners for result outputs.</param>
|
/// <param name="metaDataParameters">Optional metadata parameters.</param>
|
/// <param name="stepsOverride">Sub-section of test plan to be executed. Note this might include child steps of disabled parent steps.</param>
|
/// <param name="variableContainer"></param>
|
/// <returns>TestPlanRun results, no StepResults.</returns>
|
public TestPlanRun Execute(IEnumerable<IResultListener> resultListeners,
|
IEnumerable<ResultParameter> metaDataParameters = null,
|
HashSet<ITestStep> stepsOverride = null,
|
VariableContainer variableContainer = null)
|
{
|
return executeInContext(resultListeners, metaDataParameters, stepsOverride,
|
variableContainer, MAIN_SEQ_NAME);
|
}
|
|
public TestPlanRun Execute(string sequenceName, IEnumerable<IResultListener> resultListeners,
|
IEnumerable<ResultParameter> metaDataParameters = null,
|
HashSet<ITestStep> stepsOverride = null,
|
VariableContainer variableContainer = null)
|
{
|
return executeInContext(resultListeners, metaDataParameters, stepsOverride,
|
variableContainer, sequenceName);
|
}
|
|
TestPlanRun executeInContext(IEnumerable<IResultListener> resultListeners,
|
IEnumerable<ResultParameter> metaDataParameters, HashSet<ITestStep> stepsOverride,
|
VariableContainer variableContainer,
|
string sequenceName)
|
{
|
using (TapThread.UsingThreadContext())
|
{
|
return ExecuteByName(resultListeners, metaDataParameters, stepsOverride, sequenceName, variableContainer);
|
}
|
}
|
|
/// <summary>
|
/// °´Ãû³ÆÖ´ÐвâÊԼƻ®
|
/// </summary>
|
/// <param name="resultListeners"></param>
|
/// <param name="metaDataParameters"></param>
|
/// <param name="stepsOverride"></param>
|
/// <param name="variableContainer"></param>
|
/// <returns></returns>
|
/// <exception cref="ArgumentNullException"></exception>
|
/// <exception cref="ArgumentException"></exception>
|
private TestPlanRun ExecuteByName(IEnumerable<IResultListener> resultListeners,
|
IEnumerable<ResultParameter> metaDataParameters,
|
HashSet<ITestStep> stepsOverride, string sequenceName, VariableContainer variableContainer = null)
|
{
|
if (resultListeners == null)
|
throw new ArgumentNullException(nameof(resultListeners));
|
|
ResultParameters.ParameterCache.LoadCache();
|
|
if (PrintTestPlanRunSummary && !resultListeners.Contains(summaryListener))
|
resultListeners = resultListeners.Concat(new IResultListener[] { summaryListener });
|
resultListeners = resultListeners.Where(r => r is IEnabledResource ? ((IEnabledResource)r).IsEnabled : true);
|
IList<ITestStep> steps;
|
TestStepList list;
|
|
if (stepsOverride == null)
|
{
|
list = GetStepsByName(sequenceName);
|
steps = list;
|
}
|
else
|
{
|
var tempStep = GetStepsByName(sequenceName);
|
if (tempStep == null)
|
{
|
throw new ArgumentException("No Name");
|
}
|
list = tempStep;
|
|
// Remove steps that are already included via their parent steps.
|
foreach (var step in stepsOverride)
|
{
|
if (step == null)
|
throw new ArgumentException("stepsOverride may not contain null", nameof(stepsOverride));
|
|
var p = step.GetParent<ITestStep>();
|
while (p != null)
|
{
|
if (stepsOverride.Contains(p))
|
throw new ArgumentException("stepsOverride may not contain steps and their parents.", nameof(stepsOverride));
|
p = p.GetParent<ITestStep>();
|
}
|
}
|
steps = Utils.FlattenHeirarchy(tempStep, step => step.ChildTestSteps).Where(stepsOverride.Contains).ToList();
|
}
|
|
long initTimeStamp = Stopwatch.GetTimestamp();
|
var initTime = DateTime.Now;
|
|
Log.Info("-----------------------------------------------------------------");
|
|
|
var logStream = new HybridStream();
|
|
var planRunLog = new FileTraceListener(logStream) { IsRelative = true };
|
OpenTap.Log.AddListener(planRunLog);
|
|
var allSteps = Utils.FlattenHeirarchy(steps, step => step.ChildTestSteps);
|
var allEnabledSteps = Utils.FlattenHeirarchy(steps.Where(x => x.Enabled), step => step.GetEnabledChildSteps());
|
|
var enabledSinks = new HashSet<IResultSink>();
|
TestStepExtensions.GetObjectSettings<IResultSink, ITestStep, IResultSink>(allEnabledSteps, true, null, enabledSinks);
|
if (enabledSinks.Count > 0)
|
{
|
var sinkListener = new ResultSinkListener(enabledSinks);
|
resultListeners = resultListeners.Append(sinkListener);
|
}
|
|
Log.Info("Starting TestPlan '{0}' on {1}, {2} of {3} TestSteps enabled.", Name, initTime, allEnabledSteps.Count, allSteps.Count);
|
|
// Reset step verdict.
|
foreach (var step in allSteps)
|
{
|
if (step.Verdict != Verdict.NotSet)
|
{
|
step.Verdict = Verdict.NotSet;
|
step.OnPropertyChanged("Verdict");
|
}
|
}
|
|
if (currentExecutionState != null)
|
{
|
currentExecutionState.ResultListenersSealed = false;
|
// load result listeners that are _not_ used in the previous runs.
|
// otherwise they wont get opened later.
|
foreach (var rl in resultListeners)
|
{
|
currentExecutionState.AddResultListener(rl);
|
}
|
}
|
|
TestPlanRun execStage;
|
bool continuedExecutionState = false;
|
if (currentExecutionState != null)
|
{
|
execStage = new TestPlanRun(currentExecutionState, initTime, initTimeStamp, variableContainer);
|
continuedExecutionState = true;
|
}
|
else
|
{
|
execStage = new TestPlanRun(this, resultListeners.ToList(), initTime, initTimeStamp, variableContainer);
|
if (stepsOverride != null)
|
{
|
var overrides = stepsOverride.Select(o => o.Id.ToString()).ToArray();
|
// The order of the guids does not really matter.
|
// Only that the order is the same across runs
|
Array.Sort(overrides);
|
execStage.Parameters.Add(new ResultParameter(TestPlanRun.SpecialParameterNames.StepOverrideList, string.Join(",", overrides)));
|
}
|
|
execStage.Start();
|
|
execStage.Parameters.AddRange(PluginManager.GetPluginVersions(allEnabledSteps));
|
execStage.ResourceManager.ResourceOpened += r =>
|
{
|
execStage.Parameters.AddRange(PluginManager.GetPluginVersions(new List<object> { r }));
|
};
|
}
|
execStage.LocalsRuntime = VariableContext.FromTestVariables(list.Variables);
|
|
|
if (metaDataParameters != null)
|
execStage.Parameters.AddRange(metaDataParameters);
|
|
var prevExecutingPlanRun = executingPlanRun.LocalValue;
|
executingPlanRun.LocalValue = execStage;
|
CurrentRun = execStage;
|
|
failState runWentOk = failState.StartFail;
|
// ûɶÓúÃÏñ
|
// ³õʼ»¯ÔËÐÐʱ±äÁ¿³Ø
|
//FileGlobalContext.Add(execStage, execStage.runtimeVariablePool);
|
|
// ReSharper disable once InconsistentNaming
|
var preRun_Run_PostRunTimer = Stopwatch.StartNew();
|
try
|
{
|
execStage.FailedToStart = true; // Set it here in case OpenInternal throws an exception. Could happen if a step is missing an instrument
|
|
OpenInternal(execStage, continuedExecutionState, allEnabledSteps, Array.Empty<IResource>());
|
|
execStage.WaitForSerialization();
|
execStage.ResourceManager.BeginStep(execStage, this, TestPlanExecutionStage.Execute, TapThread.Current.AbortToken);
|
|
if (continuedExecutionState)
|
{ // Since resources are not opened, getting metadata cannot be done in the wait for resources continuation
|
// like shown in TestPlanRun. Instead we do it here.
|
foreach (var res in execStage.ResourceManager.Resources)
|
execStage.Parameters.AddRange(ResultParameters.GetMetadataFromObject(res));
|
}
|
|
runWentOk = failState.ExecFail; //important if test plan is aborted and runWentOk is never returned.
|
runWentOk = execTestPlan(execStage, steps);
|
}
|
catch (Exception e)
|
{
|
if (e is OperationCanceledException && execStage.MainThread.AbortToken.IsCancellationRequested)
|
{
|
|
Log.Warning(String.Format("TestPlan aborted. ({0})", e.Message));
|
execStage.UpgradeVerdict(Verdict.Aborted);
|
}
|
else if (e is ThreadAbortException)
|
{
|
// It seems this actually never happens.
|
Log.Warning("TestPlan aborted.");
|
execStage.UpgradeVerdict(Verdict.Aborted);
|
//Avoid entering the finally clause.
|
Thread.Sleep(500);
|
}
|
else if (e is System.ComponentModel.LicenseException)
|
{
|
execStage.Exception = e;
|
Log.Error(e.Message);
|
execStage.UpgradeVerdict(Verdict.Error);
|
}
|
else
|
{
|
execStage.Exception = e;
|
Log.Warning("TestPlan aborted.");
|
Log.Error(e.Message);
|
Log.Debug(e);
|
execStage.UpgradeVerdict(Verdict.Error);
|
}
|
}
|
finally
|
{
|
execStage.FailedToStart = (runWentOk == failState.StartFail);
|
|
try
|
{
|
finishTestPlanRun(execStage, preRun_Run_PostRunTimer, runWentOk, planRunLog, logStream);
|
}
|
catch (Exception ex)
|
{
|
Log.Error("Error while finishing TestPlan.");
|
Log.Debug(ex);
|
}
|
|
OpenTap.Log.RemoveListener(planRunLog);
|
planRunLog.Dispose();
|
|
logStream.Dispose();
|
|
// Clean all test steps StepRun, otherwise the next test plan execution will be stuck at TestStep.DoRun at steps that does not have a cleared StepRun.
|
foreach (var step in allSteps)
|
step.StepRun = null;
|
|
executingPlanRun.LocalValue = prevExecutingPlanRun;
|
CurrentRun = prevExecutingPlanRun;
|
}
|
return execStage;
|
}
|
|
private TestPlanRun DoExecute(IEnumerable<IResultListener> resultListeners, IEnumerable<ResultParameter> metaDataParameters, HashSet<ITestStep> stepsOverride, VariableContainer variableContainer = null)
|
{
|
return ExecuteByName(resultListeners, metaDataParameters, stepsOverride, MAIN_SEQ_NAME, variableContainer);
|
}
|
|
/// <summary>
|
/// Execute the TestPlan as specified. Blocking.
|
/// </summary>
|
/// <param name="resultListeners">ResultListeners for result outputs.</param>
|
/// <param name="metaDataParameters">Metadata parameters.</param>
|
/// <returns>TestPlanRun results, no StepResults.</returns>
|
public TestPlanRun Execute(IEnumerable<IResultListener> resultListeners, IEnumerable<ResultParameter> metaDataParameters)
|
{
|
return Execute(resultListeners, metaDataParameters, null);
|
}
|
|
TestPlanRun currentExecutionState = null;
|
|
/// <summary> true if the plan is in its open state. </summary>
|
[AnnotationIgnore]
|
public bool IsOpen { get { return currentExecutionState != null; } }
|
|
/// <summary>
|
/// Opens all resources referenced in this TestPlan (Instruments/DUTs/ResultListeners).
|
/// This can be called before <see cref="TestPlan.Execute()"/> to manually control the opening/closing of the resources.
|
/// </summary>
|
public void Open()
|
{
|
Open(ResultSettings.Current);
|
}
|
|
/// <summary>
|
/// Opens all resources referenced in this TestPlan (Instruments/DUTs/ResultListeners).
|
/// This can be called before <see cref="TestPlan.Execute()"/> to manually control the opening/closing of the resources.
|
/// </summary>
|
/// <param name="listeners">Result listeners used in connection with the test plan.</param>
|
public void Open(IEnumerable<IResultListener> listeners)
|
{
|
Open(listeners, Array.Empty<IResource>());
|
}
|
|
/// <summary>
|
/// Opens all resources referenced in this TestPlan (Instruments/DUTs/ResultListeners).
|
/// This can be called before <see cref="TestPlan.Execute()"/> to manually control the opening/closing of the resources.
|
/// It can also be called multiple times to add more resources.
|
/// </summary>
|
/// <param name="additionalResources">Additional resources added as 'static' resources.</param>
|
public void Open(IEnumerable<IResource> additionalResources)
|
{
|
Open(ResultSettings.Current, additionalResources);
|
}
|
|
/// <summary>
|
/// Opens all resources referenced in this TestPlan (Instruments/DUTs/ResultListeners).
|
/// This can be called before <see cref="TestPlan.Execute()"/> to manually control the opening/closing of the resources.
|
/// It can also be called multiple times to add more resources.
|
/// </summary>
|
/// <param name="listeners">Result listeners used in connection with the test plan.</param>
|
/// <param name="additionalResources">Additional resources added as 'static' resources.</param>
|
public void Open(IEnumerable<IResultListener> listeners, IEnumerable<IResource> additionalResources)
|
{
|
if (listeners == null)
|
throw new ArgumentNullException(nameof(listeners));
|
if (PrintTestPlanRunSummary)
|
listeners = listeners.Concat(new IResultListener[] { summaryListener });
|
|
if (IsRunning)
|
throw new InvalidOperationException("This TestPlan is already running.");
|
|
try
|
{
|
var allSteps = Utils.FlattenHeirarchy(Steps.Where(x => x.Enabled), step => step.GetEnabledChildSteps()).ToList();
|
|
Stopwatch timer = Stopwatch.StartNew();
|
if (currentExecutionState == null)
|
{
|
currentExecutionState = new TestPlanRun(this, listeners.ToList(), DateTime.Now, Stopwatch.GetTimestamp(), null, true);
|
currentExecutionState.Start();
|
}
|
OpenInternal(currentExecutionState, false, allSteps, additionalResources);
|
|
try
|
{
|
currentExecutionState.ResourceManager.WaitUntilAllResourcesOpened(TapThread.Current.AbortToken);
|
}
|
catch (Exception ex)
|
{
|
Log.Warning("Caught error while opening resources! See error message for details.");
|
ex.RethrowInner();
|
}
|
|
Log.Debug(timer, "TestPlan opened.");
|
}
|
catch
|
{
|
// If there is an error, reset the state to allow calling open again later
|
// when the user has fixed the error.
|
if (currentExecutionState != null)
|
currentExecutionState.ResourceManager.EndStep(this, TestPlanExecutionStage.Open);
|
|
if (monitors != null)
|
foreach (var item in monitors)
|
item.ExitTestPlanRun(currentExecutionState);
|
|
currentExecutionState = null;
|
throw;
|
}
|
}
|
|
private void OpenInternal(TestPlanRun run, bool isOpen, List<ITestStep> steps, IEnumerable<IResource> additionalResources)
|
{
|
monitors = TestPlanRunMonitors.GetCurrent();
|
|
// Enter monitors
|
foreach (var item in monitors)
|
item.EnterTestPlanRun(run);
|
|
run.ResourceManager.EnabledSteps = steps;
|
run.ResourceManager.StaticResources = run.ResultListeners.Concat(additionalResources).ToArray();
|
run.ResultListenersSealed = true;
|
if (!isOpen)
|
run.ResourceManager.BeginStep(run, this, TestPlanExecutionStage.Open, TapThread.Current.AbortToken);
|
}
|
|
/// <summary>
|
/// Closes all resources referenced in this TestPlan (Instruments/DUTs/ResultListeners).
|
/// This should be called if <see cref="TestPlan.Open()"/> was called earlier to manually close the resources again.
|
/// </summary>
|
public void Close()
|
{
|
if (IsRunning)
|
throw new InvalidOperationException("Cannot close TestPlan while it is running.");
|
if (currentExecutionState == null)
|
throw new InvalidOperationException("Call open first.");
|
|
Stopwatch timer = Stopwatch.StartNew();
|
currentExecutionState.ResourceManager.EndStep(this, TestPlanExecutionStage.Open);
|
|
// If we locked the setup earlier, unlock it now that all recourses has been closed:
|
foreach (var item in monitors)
|
item.ExitTestPlanRun(currentExecutionState);
|
|
currentExecutionState = null;
|
Log.Debug(timer, "TestPlan closed.");
|
|
}
|
}
|
|
// This object has a special data annotator that embeds metadata properties
|
// from Resources into it.
|
class MetadataPromptObject
|
{
|
public string Name { get; private set; } = "Please enter test plan metadata.";
|
[Browsable(false)]
|
public IEnumerable<object> Resources { get; set; }
|
|
public enum PromptResponse
|
{
|
OK,
|
Abort
|
}
|
|
[Layout(LayoutMode.FloatBottom | LayoutMode.FullRow)]
|
[Submit]
|
public PromptResponse Response { get; set; }
|
|
}
|
}
|
