// 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;
|
|
namespace OpenTap.Plugins.BasicSteps
|
{
|
[Display("Repeat", Group: "OpenTap",Order:1, Description: "Repeats its child steps a fixed number of times or until the verdict of a child step changes to a specified state.")]
|
[AllowAnyChild]
|
public class RepeatStep : LoopTestStep
|
{
|
public enum RepeatStepAction
|
{
|
[Display("Fixed Count", "Repeat iteration a fixed number of times.")]
|
Fixed_Count,
|
[Display("While", "Repeat while the specified condition is met. This guarantees a minimum of one time.")]
|
While,
|
[Display("Until", "Repeat until the specified condition is met. This guarantees a minimum of one time.")]
|
Until
|
}
|
|
#region Settings
|
[Display("Repeat", Order: 0, Description: "Select if you want to repeat for a fixed number of times or you want to repeat while or until a certain step has a certain verdict.")]
|
public RepeatStepAction Action { get; set; }
|
|
[StepSelector(StepSelectorAttribute.FilterTypes.All)]
|
[EnabledIf(nameof(Action), RepeatStepAction.While, RepeatStepAction.Until, HideIfDisabled = true)]
|
[Display("Verdict Of", Order: 1, Description: "Select the step that you want to validate the verdict of.")]
|
public ITestStep TargetStep { get; set; }
|
|
[EnabledIf("Action", RepeatStepAction.While, RepeatStepAction.Until, HideIfDisabled = true)]
|
[Display("Equals", Order: 2, Description: "Set the verdict you want to validate against.")]
|
public Verdict TargetVerdict { get; set; }
|
|
[EnabledIf("Action",RepeatStepAction.Fixed_Count, HideIfDisabled = true)]
|
[Display("Count", Order: 1, Description: "Set the fixed number of times to repeat.")]
|
public uint Count { get; set; }
|
|
[Display("Retry", Order:3, Description: "Clear the verdict and try again if break conditions were reached for child steps.")]
|
public bool Retry { get; set; }
|
|
[EnabledIf("Action", RepeatStepAction.While, RepeatStepAction.Until, HideIfDisabled = true)]
|
[Display("Clear Verdict", Order:3, Description: "Clear the verdict before each loop iteration. This can be useful for 'repeat until pass' scenarios.")]
|
public bool ClearVerdict { get; set; }
|
|
public Enabled<uint> maxCount = new Enabled<uint> { Value = 3, IsEnabled = false };
|
|
[Display("Max Count", Order: 3, Description: "When enabled the children will only be repeated a maximum number of times.")]
|
[EnabledIf("Action", RepeatStepAction.While, RepeatStepAction.Until, HideIfDisabled = true)]
|
public Enabled<uint> MaxCount
|
{
|
get => maxCount;
|
set => maxCount = value ?? throw new ArgumentNullException(nameof(value), "Cannot assign Max Count a null value.");
|
}
|
|
[Output(OutputAvailability.BeforeRun)]
|
[Display("Iteration", "The current iteration.", Order: 4)]
|
public string IterationInfo
|
{
|
get
|
{
|
|
uint _iteration = iteration;
|
if(GetParent<TestPlan>().IsRunning == false)
|
_iteration = 0;
|
|
if(MaxCount.IsEnabled && Action != RepeatStepAction.Fixed_Count)
|
return $"{_iteration} of {MaxCount.Value}";
|
if(Action == RepeatStepAction.Fixed_Count)
|
return $"{_iteration} of {Count}";
|
return $"{_iteration}";
|
}
|
}
|
|
[Output(OutputAvailability.BeforeRun)]
|
[Display("Iteration", "The current iteration.", Group: "Outputs", Order: 5)]
|
public uint Iteration => iteration;
|
|
#endregion
|
|
public RepeatStep()
|
{
|
TargetVerdict = Verdict.Fail;
|
Action = RepeatStepAction.Fixed_Count;
|
Count = 3;
|
Rules.Add(() => TargetStep != null || Action == RepeatStepAction.Fixed_Count, "No step selected", "TargetStep");
|
}
|
uint iteration;
|
|
Verdict getCurrentVerdict() => TargetStep?.Verdict ?? Verdict.NotSet;
|
private bool retried;
|
|
Verdict iterate()
|
{
|
TapThread.Current.AbortToken.ThrowIfCancellationRequested();
|
if (ClearVerdict)
|
Verdict = Verdict.NotSet;
|
if (retried)
|
{
|
Verdict = Verdict.NotSet;
|
retried = false;
|
}
|
this.iteration += 1;
|
OnPropertyChanged(nameof(IterationInfo));
|
var additionalParams = new List<ResultParameter> { new ResultParameter("", "Iteration", this.iteration) };
|
var runs = RunChildSteps(additionalParams, BreakLoopRequested, throwOnBreak: false);
|
foreach (var r in runs)
|
{
|
r.WaitForCompletion();
|
}
|
|
if (runs.LastOrDefault()?.BreakConditionsSatisfied() == true)
|
{
|
if(!Retry) BreakLoop();
|
retried = true;
|
}
|
|
return getCurrentVerdict();
|
}
|
|
static bool IsChildOfOrSelf(ITestStep step, ITestStep parent)
|
{
|
if (step == parent) return true;
|
step = step.Parent as ITestStep;
|
while(step != null && step != parent)
|
step = step.Parent as ITestStep;
|
return step != null;
|
}
|
|
public override void Run()
|
{
|
base.Run();
|
iteration = 0;
|
|
if (Action != RepeatStepAction.Fixed_Count && TargetStep == null)
|
throw new ArgumentException("Could not locate target test step");
|
|
uint loopCount;
|
if (Action == RepeatStepAction.Fixed_Count)
|
loopCount = Count;
|
else if (MaxCount.IsEnabled)
|
loopCount = MaxCount.Value;
|
else
|
loopCount = uint.MaxValue;
|
|
{ // Special case:
|
// when TargetStep is not a child of this, we need to evaluate the verdict _before_
|
// running the first iteration.
|
|
if (Action != RepeatStepAction.Fixed_Count && !IsChildOfOrSelf(TargetStep, this))
|
{
|
var currentVerdict = getCurrentVerdict();
|
if (currentVerdict != TargetVerdict && Action == RepeatStepAction.While)
|
return;
|
if (currentVerdict == TargetVerdict && Action == RepeatStepAction.Until)
|
return;
|
}
|
}
|
|
|
switch (Action)
|
{
|
case RepeatStepAction.While:
|
{
|
while (iterate() == TargetVerdict && iteration < loopCount && !BreakLoopRequested.IsCancellationRequested) { }
|
|
break;
|
}
|
case RepeatStepAction.Until:
|
{
|
while (iterate() != TargetVerdict && iteration < loopCount && !BreakLoopRequested.IsCancellationRequested) { }
|
|
break;
|
}
|
case RepeatStepAction.Fixed_Count:
|
{
|
while (iteration < loopCount && !BreakLoopRequested.IsCancellationRequested)
|
iterate();
|
break;
|
}
|
default:
|
throw new ArgumentOutOfRangeException();
|
}
|
}
|
}
|
}
|
