// 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 System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
using System.ComponentModel;
|
using System.Reflection;
|
using System.Xml.Serialization;
|
using System.Threading;
|
|
namespace OpenTap.Plugins.BasicSteps
|
{
|
[Browsable(false)]
|
[Display("Sweep Loop", Groups: new [] { "Flow Control", "Legacy" }, Description: "Loops its child steps while sweeping specified parameters/settings on the child steps.", Collapsed:true)]
|
[AllowAnyChild]
|
public class SweepLoop : LoopTestStep, IDeserializedCallback
|
{
|
|
public enum SweepBehaviour
|
{
|
[Display("Within Run")]
|
Within_Run,
|
[Display("Across Runs")]
|
Across_Runs
|
}
|
|
private SweepBehaviour _CrossPlan;
|
int crossPlanSweepIndex = 0;
|
|
int currentIteration = 0;
|
|
[Output]
|
[Display("Iteration", "Shows the iteration of the loop that is currently running or about to run.", Order: 3)]
|
public string IterationInfo => string.Format("{0} of {1}", Iteration + 1, EnabledRows.Length);
|
|
[Browsable(false)]
|
public bool[] EnabledRows { get; set; } = Array.Empty<bool>();
|
|
internal int Iteration
|
{
|
get => currentIteration;
|
set
|
{
|
if (currentIteration != value)
|
{
|
currentIteration = value;
|
OnPropertyChanged(nameof(IterationInfo));
|
}
|
}
|
}
|
|
#region Settings
|
|
public bool SweepParametersEnabled => sweepParameters.Count > 0;
|
|
List<SweepParam> sweepParameters = new List<SweepParam>();
|
[Unparameterizable]
|
[Unsweepable]
|
[Display("Sweep Values", Order: 2, Description: "Select the ranges of values to sweep.")]
|
[EnabledIf(nameof(SweepParametersEnabled), true)]
|
[DeserializeOrder(1)]
|
public List<SweepParam> SweepParameters
|
{
|
get => sweepParameters;
|
set
|
{
|
crossPlanSweepIndex = 0;
|
Iteration = 0;
|
sweepParameters = value;
|
}
|
}
|
|
int changedid = 0;
|
internal void parametersChanged()
|
{
|
changedid += 1;
|
}
|
|
/// <summary> Quickly check if things has changed. </summary>
|
/// <returns></returns>
|
bool popChanged()
|
{
|
bool ischanged = false;
|
foreach(var param in SweepParameters)
|
{
|
if(param.Step != this)
|
{
|
param.Step = this;
|
ischanged = true;
|
}
|
}
|
if(changedid > 0)
|
{
|
ischanged = true;
|
}
|
if(ischanged)
|
changedid = 0;
|
return ischanged;
|
}
|
|
[XmlIgnore]
|
[Browsable(true)]
|
[Unsweepable]
|
[Display("Sweep Parameters", Order: 1, Description: "Select which child step settings to sweep.")]
|
public IEnumerable<IMemberData> SweepMembers
|
{
|
get => SweepParameters.Select(x => x.Member);
|
set { }
|
}
|
|
/// <summary>
|
/// To ensure that OpenTAP opens the referenced resources.
|
/// </summary>
|
[Browsable(false)]
|
public IEnumerable<IResource> ReferencedResources
|
{
|
get
|
{
|
if (CrossPlan == SweepBehaviour.Across_Runs)
|
return SweepParameters
|
// crossPlanSweepIndex is 0 by default. Even if the number of rows is also 0.
|
.Select(param => param.Values.ElementAtOrDefault(crossPlanSweepIndex))
|
.OfType<IResource>();
|
return SweepParameters
|
.SelectMany(param => param.Values)
|
.OfType<IResource>();
|
}
|
}
|
|
[Display("Sweep Mode", Description: "Loop through the sweep values in a single TestPlan run or change values between runs.", Order:0)]
|
[Unsweepable]
|
public SweepBehaviour CrossPlan
|
{
|
get => _CrossPlan;
|
|
set
|
{
|
|
if (_CrossPlan == value)
|
return;
|
_CrossPlan = value;
|
crossPlanSweepIndex = 0;
|
Iteration = 0;
|
}
|
}
|
#endregion
|
|
public SweepLoop()
|
{
|
SweepParameters = new List<SweepParam>();
|
Rules.Add(() => SweepMembers.Count() != 0, "No parameters selected to sweep", nameof(SweepMembers));
|
Rules.Add(() => string.IsNullOrWhiteSpace(validateSweep()), validateSweep, nameof(SweepParameters));
|
|
ChildTestSteps.ChildStepsChanged += childStepsChanged;
|
PropertyChanged += SweepLoop_PropertyChanged;
|
}
|
|
void SweepLoop_PropertyChanged(object sender, PropertyChangedEventArgs e)
|
{
|
if(e.PropertyName == nameof(ChildTestSteps))
|
ChildTestSteps.ChildStepsChanged += childStepsChanged;
|
}
|
|
void childStepsChanged(TestStepList sender, TestStepList.ChildStepsChangedAction Action, ITestStep Object, int Index)
|
{
|
// Make a copy to stop collection modified exception in TapSerializer.
|
var localSweepParameters = sweepParameters.ToList();
|
localSweepParameters.RemoveIf(s => ValidateChildSteps(s, ChildTestSteps) == null);
|
sweepParameters = localSweepParameters;
|
}
|
|
static List<Exception> setParameterOnChildren(SweepParam sweepParameter, object val, TestStepList childTestSteps)
|
{
|
List<Exception> ex = null;
|
foreach (ITestStep childTestStep in childTestSteps)
|
{
|
ITypeData childType = TypeData.GetTypeData(childTestStep);
|
|
foreach (var prop in sweepParameter.Members)
|
{
|
IMemberData paramProp = childType.GetMember(prop.Name);
|
if (paramProp != null)
|
{
|
try
|
{
|
// Previously only the member name and type was used for this check
|
// this can however give some issue since the GUI groups things with
|
// the same name and group, hence this GetDisplayAttribute has been added
|
// Actually probably direct member comparison should have been done instead,
|
// but lots of test plans code depends on the functionality here, so just
|
// adding a comparison for display attribute is probably the most gentle solution.
|
var d1 = prop.GetDisplayAttribute();
|
var d2 = paramProp.GetDisplayAttribute();
|
if (d1.Name != d2.Name || d1.Group.SequenceEqual(d2.Group) == false)
|
continue;
|
if (Equals(paramProp.TypeDescriptor, sweepParameter.Member.TypeDescriptor) == false)
|
continue;
|
|
var tp = TypeData.GetTypeData(val);
|
if ((tp.DescendsTo(paramProp.TypeDescriptor) || val == null))
|
paramProp.SetValue(childTestStep, val);
|
}
|
catch (TargetInvocationException e)
|
{
|
if (ex == null)
|
ex = new List<Exception>();
|
ex.Add(e.InnerException);
|
}
|
}
|
|
if (false == childType.DescendsTo(typeof(TestPlanReference)))
|
{
|
var e = setParameterOnChildren(sweepParameter, val, childTestStep.ChildTestSteps);
|
if(e != null)
|
{
|
if (ex == null) ex = e;
|
else ex.AddRange(e);
|
}
|
}
|
}
|
}
|
return ex;
|
}
|
|
Dictionary<ITestStep, List<Tuple<IMemberData, object>>> getSweepParameterValues(SweepParam sweepParameter, TestStepList childTestSteps)
|
{
|
var values = new Dictionary<ITestStep, List<Tuple<IMemberData, object>>>();
|
populateChildParameters(values, sweepParameter, childTestSteps);
|
return values;
|
}
|
|
static void populateChildParameters(Dictionary<ITestStep, List<Tuple<IMemberData, object>>> values, SweepParam sweepParameter, TestStepList childTestSteps)
|
{
|
foreach (ITestStep childTestStep in childTestSteps)
|
{
|
ITypeData stepType = TypeData.GetTypeData(childTestStep);
|
foreach (IMemberData property in sweepParameter.Members)
|
{
|
IMemberData paramProp = stepType.GetMember(property.Name);
|
if (object.Equals(paramProp, property))
|
{
|
if (!values.TryGetValue(childTestStep, out _))
|
values[childTestStep] = new List<Tuple<IMemberData, object>>();
|
values[childTestStep].Add(new Tuple<IMemberData, object>(paramProp, paramProp.GetValue(childTestStep)));
|
}
|
}
|
// TODO: do we want this hack??
|
if (false == stepType.DescendsTo(typeof(TestPlanReference)))
|
populateChildParameters(values, sweepParameter, childTestStep.ChildTestSteps);
|
|
}
|
}
|
|
void RunForSweepParamWithIndex(int index, StringBuilder logMessage)
|
{
|
List<Exception> ex = null;
|
foreach (SweepParam sweepParameter in SweepParameters)
|
{
|
if (sweepParameter == null)
|
continue;
|
object paramValue = sweepParameter.Values.GetValue(index);
|
TestStepList childTestSteps = ChildTestSteps;
|
|
var e = setParameterOnChildren(sweepParameter, paramValue, childTestSteps);
|
if(e != null)
|
{
|
if (ex == null) ex = new List<Exception>();
|
ex.AddRange(e);
|
}
|
if (logMessage == null) continue;
|
logMessage.Append(sweepParameter.Member.Name);
|
logMessage.Append(" = ");
|
logMessage.Append(StringConvertProvider.GetString(sweepParameter.Values.GetValue(index)));
|
if (sweepParameter != SweepParameters.Last())
|
logMessage.Append(", ");
|
}
|
if (ex != null)
|
throw new AggregateException(ex);
|
}
|
|
private ResultParameters RegisterAdditionalParams(int Index)
|
{
|
ResultParameters parameters = new ResultParameters();
|
foreach (SweepParam sweepParameter in SweepParameters)
|
{
|
if (sweepParameter == null)
|
continue;
|
|
if (!(sweepParameter.Values.GetValue(Index) is IConvertible))
|
continue;
|
|
string DisplayName = sweepParameter.Name;
|
string group;
|
|
DisplayName = ReflectionHelper.ParseDisplayname(DisplayName, out group);
|
|
ResultParameter p = new ResultParameter(group, DisplayName, (IConvertible)sweepParameter.Values.GetValue(Index));
|
parameters.Add(p);
|
}
|
return parameters;
|
}
|
|
// Check if the test plan is running before validating sweeps.
|
// the validateSweep might have been started before the plan started.
|
// hence we use the validateSweeepMutex to ensure that validation is done before
|
// the plan starts.
|
bool isRunning => GetParent<TestPlan>()?.IsRunning ?? false;
|
Mutex validateSweepMutex = new Mutex();
|
string validateSweep()
|
{ // Mostly copied from Run
|
if (SweepParameters.Count <= 0) return "";
|
if (sweepParameters.All(p => p.Values.Length == 0)) return "No values selected to sweep";
|
if (isRunning) return ""; // Avoid changing the value during run when the gui asks for validation errors.
|
if (!validateSweepMutex.WaitOne(0)) return "";
|
sanitizeSweepParams();
|
var oldParams = SweepParameters.Select(param => getSweepParameterValues(param, ChildTestSteps)).ToList();
|
try
|
{
|
var affectedSteps = oldParams.SelectMany(d => d.Keys).Distinct().ToList();
|
|
StringBuilder sb = new StringBuilder();
|
for (int i = 0; i < SweepParameters[0].Values.Length; i++)
|
{
|
if (false == EnabledRows[i])
|
continue;
|
RunForSweepParamWithIndex(i, null);
|
if (i > 0)
|
sb.AppendLine();
|
bool first = true;
|
foreach (var step in affectedSteps)
|
{
|
if (string.IsNullOrWhiteSpace(step.Error))
|
continue;
|
if (first)
|
first = false;
|
else
|
sb.AppendLine();
|
sb.AppendFormat("Row {2}, Step '{0}' : {1}", step.GetFormattedName(), step.Error, i + 1);
|
}
|
|
}
|
return sb.ToString();
|
}
|
catch(AggregateException e)
|
{
|
return string.Join("\n", e.InnerExceptions.Select(x => x.Message));
|
}
|
finally
|
{
|
for (int i = 0; i < SweepParameters.Count; i++)
|
foreach (var kvp in oldParams[i])
|
{
|
foreach(var i2 in kvp.Value)
|
i2.Item1.SetValue(kvp.Key, i2.Item2);
|
}
|
validateSweepMutex.ReleaseMutex();
|
}
|
}
|
|
public string ValidateChildSteps(SweepParam sweepParameter, TestStepList childTestSteps)
|
{
|
if (sweepParameter.Members == null)
|
return "";
|
|
string iterate_child_steps(TestStepList stepList)
|
{
|
foreach (ITestStep childTestStep in stepList)
|
{
|
if (childTestStep.IsReadOnly == false)
|
{
|
ITypeData stepType = TypeData.GetTypeData(childTestStep);
|
foreach (IMemberData property in sweepParameter.Members)
|
{
|
IMemberData paramProp = stepType.GetMember(property.Name);
|
if (object.Equals(paramProp, property))
|
return paramProp.ToString();
|
}
|
}
|
var param = ValidateChildSteps(sweepParameter, childTestStep.ChildTestSteps);
|
if (param != null)
|
return param;
|
}
|
return null;
|
}
|
|
return iterate_child_steps(childTestSteps);
|
}
|
|
public override void PrePlanRun()
|
{
|
validateSweepMutex.WaitOne();
|
validateSweepMutex.ReleaseMutex();
|
if (sweepParameters == null)
|
sweepParameters = new List<SweepParam>();
|
|
sanitizeSweepParams();
|
|
if (sweepParameters.Count == 0)
|
throw new InvalidOperationException("No parameters selected to sweep");
|
if(EnabledRows.Count(x => x) == 0)
|
throw new InvalidOperationException("No values selected to sweep");
|
}
|
|
void printException(AggregateException ex)
|
{
|
foreach (var e in ex.InnerExceptions)
|
{
|
Log.Error(e.Message);
|
Log.Debug(e);
|
}
|
}
|
|
void acrossRunsGotoEnabledSweepIndex()
|
{
|
if (crossPlanSweepIndex >= EnabledRows.Length)
|
crossPlanSweepIndex = 0;
|
for(int i = 0; i < EnabledRows.Length; i++)
|
{
|
if (EnabledRows[crossPlanSweepIndex])
|
return;
|
crossPlanSweepIndex++;
|
if (crossPlanSweepIndex >= EnabledRows.Length)
|
crossPlanSweepIndex = 0;
|
}
|
throw new InvalidOperationException("No rows enabled!");
|
}
|
|
public override void Run()
|
{
|
base.Run();
|
if (SweepParameters.Count == 0) return;
|
if (EnabledRows.Count(v => v) == 0)
|
return;
|
|
if (CrossPlan == SweepBehaviour.Across_Runs)
|
{
|
var AdditionalParams = RegisterAdditionalParams(crossPlanSweepIndex);
|
|
// loop until the parameters are enabled.
|
acrossRunsGotoEnabledSweepIndex();
|
|
StringBuilder logMessage = new StringBuilder("Setting sweep parameters for next run (");
|
try
|
{
|
RunForSweepParamWithIndex(crossPlanSweepIndex, logMessage);
|
}
|
catch (AggregateException ex)
|
{
|
printException(ex);
|
}
|
logMessage.Append(")");
|
Log.Info(logMessage.ToString());
|
//Fix issue 687: Ensure the latest Sweep params are applied before running any child steps
|
RunChildSteps(AdditionalParams, BreakLoopRequested, throwOnBreak: false);
|
|
crossPlanSweepIndex++;
|
acrossRunsGotoEnabledSweepIndex();
|
|
Iteration = crossPlanSweepIndex;
|
}
|
else
|
{
|
var oldParams = SweepParameters.Select(param => getSweepParameterValues(param, ChildTestSteps)).ToList();
|
var affectedSteps = oldParams.SelectMany(d => d.Keys).Distinct().ToList();
|
for (int i = 0; i < SweepParameters[0].Values.Length; i++)
|
{
|
if (false == EnabledRows[i])
|
continue;
|
Iteration = i;
|
|
StringBuilder logMessage = new StringBuilder("Running child steps with ");
|
try
|
{
|
RunForSweepParamWithIndex(i, logMessage);
|
}
|
catch (AggregateException ex)
|
{
|
printException(ex);
|
}
|
affectedSteps.ForEach(step => step.OnPropertyChanged(""));
|
var AdditionalParams = RegisterAdditionalParams(i);
|
Log.Info(logMessage.ToString());
|
var runs = RunChildSteps(AdditionalParams, BreakLoopRequested, throwOnBreak: false).ToArray();
|
|
if (BreakLoopRequested.IsCancellationRequested) break;
|
runs.ForEach(r => r.WaitForCompletion());
|
if (runs.LastOrDefault()?.BreakConditionsSatisfied() == true)
|
break;
|
}
|
|
Iteration = 0;
|
|
// Restore values from before the run
|
for (int i = 0; i < SweepParameters.Count; i++)
|
foreach (var kvp in oldParams[i])
|
{
|
foreach (var i2 in kvp.Value)
|
i2.Item1.SetValue(kvp.Key, i2.Item2);
|
}
|
affectedSteps.ForEach(step => step.OnPropertyChanged(""));
|
}
|
}
|
|
/// <summary>
|
/// Ensures that the sweep parameters exists within the child test steps and that SweepParam.Property is set.
|
/// </summary>
|
internal void sanitizeSweepParams(bool log = true)
|
{
|
if (popChanged() == false)
|
{
|
return;
|
}
|
var steps = Utils.FlattenHeirarchy(ChildTestSteps, step => step is TestPlanReference ? null : step.ChildTestSteps);
|
var superLookup = steps.Select(x => TypeData.GetTypeData(x)).Distinct()
|
.SelectMany(tp => tp.GetMembers()).Distinct()
|
.ToLookup(x => SweepParam.GetMemberName(x), x => x);
|
|
foreach (var param in SweepParameters)
|
{
|
List<IMemberData> members = new List<IMemberData>();
|
|
foreach (var name in param.MemberNames) {
|
var super = superLookup[name];
|
members.AddRange(super);
|
}
|
param.Members = members.Distinct().ToArray();
|
var prop = param.Members.FirstOrDefault();
|
if (prop != null)
|
{
|
var step = steps.FirstOrDefault(x => TypeData.GetTypeData(x).GetMember(prop.Name) == prop);
|
if (step != null)
|
param.DefaultValue = prop.GetValue(step);
|
}
|
else
|
{
|
Log.Error("Members {0} not found", param.MemberNames);
|
}
|
|
}
|
bool warn = false;
|
int len = sweepParameters.Select(x => x.Values.Length).DefaultIfEmpty(0).Max();
|
|
foreach (var sweepParam in sweepParameters)
|
{ // fix IsEnabled if it is null or have different number of elements than sweepParam.Values.
|
if(sweepParam.Values.Length != len)
|
{
|
sweepParam.Resize(len);
|
warn = true;
|
}
|
}
|
if(EnabledRows.Length != len)
|
{
|
int start = EnabledRows.Length;
|
bool[] enabledrows = EnabledRows;
|
Array.Resize(ref enabledrows, len);
|
for (int i = start; i < len; i++)
|
enabledrows[i] = true;
|
EnabledRows = enabledrows;
|
warn = true;
|
}
|
if (warn && log)
|
{
|
Log.Error("Sweep Loop: Invalid settings detected. Please ensure that the sweep data is correct.");
|
}
|
}
|
|
public void OnDeserialized()
|
{
|
sanitizeSweepParams();
|
}
|
}
|
}
|
