using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// Marks a setting that can be enabled/disabled by the user. UIs are expected to render a checkbox in front of the actual value.
|
/// Settings of type <see cref="Enabled{T}"/> gets annotated with an annotation that implements this.
|
/// </summary>
|
public interface IEnabledValueAnnotation : IAnnotation
|
{
|
/// <summary>
|
/// Indicates whether this setting is enabled.
|
/// </summary>
|
AnnotationCollection IsEnabled { get; }
|
|
/// <summary>
|
/// Annotations describing the actual value.
|
/// </summary>
|
AnnotationCollection Value { get; }
|
}
|
|
internal class BreakConditionsAnnotation : IEnabledValueAnnotation, IOwnedAnnotation, IMembersAnnotation
|
{
|
internal class BreakConditionValueAnnotation : IStringReadOnlyValueAnnotation, IValueDescriptionAnnotation, IAccessAnnotation
|
{
|
static BreakCondition[] conditions = Enum.GetValues(typeof(BreakCondition)).OfType<BreakCondition>().ToArray();
|
|
static BreakCondition[] breakConditions =
|
conditions.Where(x => x.ToString().Contains("Break")).ToArray();
|
static string getEnumString(BreakCondition value)
|
{
|
if (value == 0) return "None";
|
var sb = new StringBuilder();
|
var breakFlags = breakConditions.Where(x => value.HasFlag(x));
|
if (breakFlags.Any())
|
{
|
sb.AppendFormat("Break on {0}", breakFlags.First().ToString().Substring("BreakOn".Length));
|
var breakFlags2 = breakFlags.Skip(1);
|
foreach (var x in breakFlags2)
|
{
|
sb.AppendFormat(" or {0}", x.ToString().Substring("BreakOn".Length));
|
}
|
}
|
return sb.ToString();
|
}
|
|
static BreakCondition convertAbortCondition(EngineSettings.AbortTestPlanType abortType)
|
{
|
return ((abortType.HasFlag(EngineSettings.AbortTestPlanType.Step_Fail)) ? BreakCondition.BreakOnFail : 0)
|
| (abortType.HasFlag(EngineSettings.AbortTestPlanType.Step_Error) ? BreakCondition.BreakOnError : 0)
|
| (abortType.HasFlag(EngineSettings.AbortTestPlanType.Step_Inconclusive) ? BreakCondition.BreakOnInconclusive : 0)
|
| (abortType.HasFlag(EngineSettings.AbortTestPlanType.Step_Pass) ? BreakCondition.BreakOnPass : 0);
|
}
|
|
private static (BreakCondition Condition, string InheritKind, bool MultiselectDifference) getInheritedVerdict(ITestStepParent _step)
|
{
|
ITestStepParent src = _step;
|
src = src.Parent;
|
while (src != null)
|
{
|
var cond = BreakConditionProperty.GetBreakCondition(src);
|
if (cond.HasFlag(BreakCondition.Inherit) == false)
|
{
|
if (src is TestPlan)
|
return (cond, $"test plan", false);
|
return (cond, $"parent step '{((ITestStep)src).GetFormattedName()}'", false);
|
}
|
|
src = src.Parent;
|
}
|
|
return (convertAbortCondition(EngineSettings.Current.AbortTestPlan), "engine settings", false);
|
}
|
|
public (BreakCondition Condition, string InheritKind, bool MultiselectDifference) GetCondition()
|
{
|
if (annotation.Conditions.HasFlag(BreakCondition.Inherit))
|
{
|
if(annotation.annotation.Source is ITestStepParent step)
|
return getInheritedVerdict(step);
|
if (annotation.annotation.Source is IEnumerable<ITestStepParent> stepList)
|
{
|
return getInheritedVerdict(stepList.First());
|
}
|
}
|
|
if (valueAnnotation.Get<IObjectValueAnnotation>().Value == null)
|
{
|
var valuemem = (BreakCondition)0;
|
return (valuemem, null, true);
|
}
|
else
|
{
|
var valuemem = (BreakCondition)valueAnnotation.Get<IObjectValueAnnotation>().Value;
|
return (valuemem, null, false);
|
}
|
}
|
|
public string Value
|
{
|
get
|
{
|
var (condition, _, multiselectDifference) = GetCondition();
|
if (multiselectDifference)
|
return "";
|
return getEnumString(condition);
|
}
|
}
|
|
public bool IsReadOnly => annotation.Conditions.HasFlag(BreakCondition.Inherit);
|
|
public bool IsVisible => true;
|
|
readonly BreakConditionsAnnotation annotation;
|
public AnnotationCollection valueAnnotation;
|
|
public string Describe()
|
{
|
var (condition, kind, multiselectDifference) = GetCondition();
|
if (multiselectDifference)
|
return "Selected Test Steps has different values for this setting.";
|
var str = getEnumString(condition);
|
if (kind == null) return str;
|
return $"{str} (inherited from {kind}).";
|
}
|
|
public BreakConditionValueAnnotation(BreakConditionsAnnotation annotation)
|
{
|
this.annotation = annotation;
|
}
|
}
|
|
[Flags]
|
public enum Values
|
{
|
/// <summary> If a step completes with verdict 'Error', stop execution of any subsequent steps at this level, and return control to the parent step. </summary>
|
[Display("On Error", "If a step completes with verdict 'Error', stop execution of any subsequent steps at this level, and return control to the parent step.")]
|
BreakOnError = 2,
|
/// <summary> If a step completes with verdict 'Fail', stop execution of any subsequent steps at this level, and return control to the parent step. </summary>
|
[Display("On Fail", "If a step completes with verdict 'Fail', stop execution of any subsequent steps at this level, and return control to the parent step.")]
|
BreakOnFail = 4,
|
/// <summary> If a step completes with verdict 'Inclusive' the step should break execution.</summary>
|
[Display("On Inconclusive", "If a step completes with verdict 'inconclusive', stop execution of any subsequent steps at this level, and return control to the parent step.")]
|
BreakOnInconclusive = 8,
|
/// <summary> If a step completes with verdict 'Pass' the step should break execution.</summary>
|
[Display("On Pass", "If a step completes with verdict 'pass', stop execution of any subsequent steps at this level, and return control to the parent step.")]
|
BreakOnPass = 16,
|
}
|
|
AnnotationCollection createEnabledAnnotation()
|
{
|
bool isEnabled = !Conditions.HasFlag(BreakCondition.Inherit);
|
var sub = annotation.AnnotateSub(TypeData.GetTypeData(isEnabled), isEnabled);
|
sub.Add(new AnnotationCollection.MemberAnnotation(TypeData.FromType(typeof(IEnabled)).GetMember(nameof(IEnabledValue.IsEnabled)))); // for compatibility with 9.8 UIs, emulate that this is a IsEnabled member from a Enabled<T> class
|
return sub;
|
}
|
AnnotationCollection enabledAnnotation;
|
public AnnotationCollection IsEnabled => (enabledAnnotation ?? (enabledAnnotation = createEnabledAnnotation()));
|
|
BreakConditionValueAnnotation str;
|
AnnotationCollection createValueAnnotation()
|
{
|
var _value = (Values)(int)Conditions;
|
var sub = annotation.AnnotateSub(TypeData.GetTypeData(_value), _value);
|
sub.Add(new AnnotationCollection.MemberAnnotation(TypeData.FromType(typeof(Enabled<Values>)).GetMember("Value"))); // for compatibility with 9.8 UIs, emulate that this is a Value member from a Enabled<T> class
|
sub.Add(str = new BreakConditionValueAnnotation(this) { valueAnnotation = sub });
|
return sub;
|
}
|
AnnotationCollection subannotations;
|
public AnnotationCollection Value => (subannotations ?? (subannotations = createValueAnnotation()));
|
|
internal BreakCondition Conditions
|
{
|
get => (BreakCondition) annotation.Get<IObjectValueAnnotation>().Value;
|
set { annotation.Get<IObjectValueAnnotation>().Value = value; }
|
}
|
|
public IEnumerable<AnnotationCollection> Members => new[] { IsEnabled, Value }; // IMembersAnnotationthis is implemented here for compatablility with 9.8 UIs
|
|
AnnotationCollection annotation;
|
internal BreakConditionsAnnotation(AnnotationCollection annotation)
|
{
|
this.annotation = annotation;
|
}
|
|
public void Read(object source)
|
{
|
if (subannotations != null)
|
{
|
Value.Get<IObjectValueAnnotation>().Value = (Values)(int)Conditions;
|
Value.Read();
|
}
|
|
if (enabledAnnotation != null)
|
{
|
IsEnabled.Get<IObjectValueAnnotation>().Value = false == Conditions.HasFlag(BreakCondition.Inherit);
|
IsEnabled.Read();
|
}
|
}
|
|
public void Write(object source)
|
{
|
if (subannotations == null && enabledAnnotation == null) return;
|
Value?.Write();
|
var cond = (BreakCondition)(int)subannotations.Get<IObjectValueAnnotation>().Value;
|
var dontInherit = (bool)(enabledAnnotation?.Get<IObjectValueAnnotation>().Value ?? false);
|
|
if (dontInherit && cond.HasFlag(BreakCondition.Inherit))
|
{
|
var cond2 = str.GetCondition();
|
cond = cond2.Condition;
|
}
|
else if (dontInherit == false)
|
{
|
cond = BreakCondition.Inherit;
|
}
|
|
cond = cond.SetFlag(BreakCondition.Inherit, !dontInherit);
|
Conditions = cond;
|
annotation.Get<IObjectValueAnnotation>().Value = cond;
|
Read(source);
|
}
|
}
|
}
|
