// 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.Xml.Serialization;
|
using System.ComponentModel;
|
using System.Diagnostics;
|
using System.Runtime.InteropServices;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Collections.Immutable;
|
using System.Linq;
|
using System.Text;
|
using System.Threading.Tasks;
|
using System.Threading;
|
using System.Runtime.CompilerServices;
|
using System.Runtime.ExceptionServices;
|
using OpenTap.Addin.Annotation;
|
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// All TestSteps that are instances of the TestStep abstract class should override the <see cref="TestStep.Run"/> method.
|
/// Additionally, the <see cref="TestStep.PrePlanRun"/> and <see cref="TestStep.PostPlanRun"/> methods can be overridden.
|
/// </summary>
|
/// <remarks>
|
/// <see cref="ITestStep"/> can also be inherited from instead.
|
/// </remarks>
|
[ComVisible(true)]
|
[Guid("d0b06600-7bac-47fb-9251-f834e420623f")]
|
public abstract class TestStep : ValidatingObject, ITestStep, IBreakConditionProvider, IDescriptionProvider,
|
IDynamicMembersProvider, IInputOutputRelations, IParameterizedMembersCache, IDynamicMemberValue
|
{
|
#region Properties
|
|
protected TestPlan root;
|
[XmlIgnore]
|
public TestPlan Root
|
{
|
get => root;
|
set
|
{
|
root = value;
|
OnRootChanged(value);
|
}
|
}
|
|
protected virtual void OnRootChanged(TestPlan plan)
|
{
|
|
}
|
|
public StepResult Result { get; set; }
|
|
/// <summary>
|
/// Gets or sets the verdict. Only available during test step run.
|
/// The value of this property will be propagated to the TestStepRun when the step run completes.
|
/// </summary>
|
[Browsable(false)]
|
[ColumnDisplayName(Order: -99, IsReadOnly: true)]
|
[XmlIgnore]
|
[Output(OutputAvailability.AfterDefer)]
|
[SettingsIgnore]
|
[MetaData]
|
public Verdict Verdict { get; set; }
|
|
bool enabled = true;
|
/// <summary>
|
/// Gets or sets boolean indicating whether this step is enabled in the TestPlan
|
/// </summary>
|
[ColumnDisplayName("", Order: -101)]
|
[Display("Enabled", "Enabling/Disabling the test step decides if" +
|
" it should be used when the test plan is executed. " +
|
"This value should not be changed during test plan run.", Group: "Common", Order: 20000, Collapsed: true)]
|
[Unsweepable]
|
[NonMetaData]
|
[DefaultValue(true)]
|
public bool Enabled
|
{
|
get => enabled;
|
set
|
{
|
if (enabled == value) return;
|
enabled = value;
|
OnPropertyChanged(nameof(Enabled));
|
}
|
}
|
|
/// <summary>
|
/// Gets or sets boolean indicating whether this step is read-only in the TestPlan.
|
/// This is mostly a declaration of intent, GUIs should respect it, but few things enforces it.
|
/// </summary>
|
[Browsable(false)]
|
[XmlIgnore]
|
[AnnotationIgnore]
|
[SettingsIgnore]
|
public bool IsReadOnly { get; set; }
|
|
private string name;
|
/// <summary>
|
/// Gets or sets the name of the TestStep instance. Not allowed to be null.
|
/// In many cases the name is unique within a test plan, but this should not be assumed, use <see cref="Id"/>for an unique identifier.
|
/// May not be null.
|
/// </summary>
|
[ColumnDisplayName(nameof(Name), Order: -100)]
|
[Display("Step Name", "The name of the test step, this value can be used to identifiy a test step. " +
|
"Test step names are not guaranteed to be unique. " +
|
"Name can include names of a setting of the step, this property will dynamically be " +
|
"replaced with it's current value in some views.", Group: "Common", Order: 20001, Collapsed: true)]
|
[Unsweepable]
|
[MetaData(Frozen = true)]
|
[IgnoreVariable]
|
public string Name
|
{
|
get => name;
|
set
|
{
|
if (value == null)
|
throw new ArgumentNullException(nameof(value), "TestStep.Name cannot be null.");
|
if (value == name) return;
|
name = value;
|
OnPropertyChanged(nameof(Name));
|
}
|
}
|
|
string typeName;
|
/// <summary>
|
/// This TestStep type as a <see cref="string"/>.
|
/// </summary>
|
[ColumnDisplayName("Type", Order: 1)]
|
[Browsable(false)]
|
public string TypeName => typeName ??= TypeData.GetTypeData(this).GetDisplayAttribute().GetFullName();
|
|
TestStepList childTestSteps;
|
|
/// <summary>
|
/// Gets or sets a List of child <see cref="TestStep"/>s. The teststeps in this list will be executed in the
|
/// <see cref="RunChildSteps(System.Collections.Generic.IEnumerable{OpenTap.ResultParameter})"/> method.
|
/// </summary>
|
[Browsable(false)]
|
[AnnotationIgnore]
|
[SettingsIgnore]
|
public TestStepList ChildTestSteps
|
{
|
get => childTestSteps;
|
set
|
{
|
childTestSteps = value;
|
childTestSteps.Parent = this;
|
OnPropertyChanged(nameof(ChildTestSteps));
|
RecursivelyGetChildSteps(TestStepSearch.All).ForEach(step => step.Root = this.Root);
|
}
|
}
|
|
/// <summary>
|
/// The parent of this TestStep. Can be another TestStep or the <see cref="TestPlan"/>.
|
/// </summary>
|
[XmlIgnore]
|
[AnnotationIgnore]
|
[SettingsIgnore]
|
public virtual ITestStepParent Parent { get; set; }
|
|
/// <summary>
|
/// Result proxy that stores TestStep run results until they are propagated to the <see cref="ResultListener"/>.
|
/// </summary>
|
[XmlIgnore]
|
[AnnotationIgnore]
|
[SettingsIgnore]
|
public ResultSource Results { get; internal set; }
|
|
/// <summary>
|
/// The enumeration of all enabled Child Steps.
|
/// </summary>
|
[AnnotationIgnore]
|
[SettingsIgnore]
|
public IEnumerable<ITestStep> EnabledChildSteps => this.GetEnabledChildSteps();
|
|
string CalcVersion()
|
{
|
// sometimes Assembly does not have a well-formatted semantic version.
|
// ins this case we just use Version.ToString(3).
|
var asm = TypeData.GetTypeDataSource(TypeData.GetTypeData(this));
|
if (asm == null) return null;
|
return asm.Version;
|
}
|
|
/// <summary>
|
/// Version of this test step.
|
/// </summary>
|
[XmlIgnore]
|
public string Version
|
{
|
get => CalcVersion();
|
set
|
{
|
var installedVersionStr = CalcVersion();
|
if (installedVersionStr == null)
|
{
|
return;
|
}
|
|
if (installedVersionStr == value)
|
return;
|
|
if (SemanticVersion.TryParse(installedVersionStr, out var installedVersion) && SemanticVersion.TryParse(value, out SemanticVersion createdVersion))
|
{
|
if (createdVersion == null)
|
{
|
Log.Warning("Could not get created version");
|
return;
|
}
|
if (!createdVersion.IsCompatible(installedVersion))
|
{
|
Log.Warning("Test plan file specified version {0} of step '{1}', but version {2} is installed, compatibility issues may occur.", createdVersion, Name, installedVersion);
|
}
|
}
|
}
|
}
|
|
private string description;
|
[Display("ÃèÊö")]
|
[IgnoreVariable]
|
public string Description
|
{
|
get => description;
|
set
|
{
|
description = value;
|
OnPropertyChanged(nameof(Description));
|
}
|
}
|
|
public virtual Verdict GetResult()
|
{
|
return Verdict.NotSet;
|
}
|
|
#endregion
|
/// <summary>
|
/// Recursively collects a completely list of child steps using the specified pattern. Order is depth-first.
|
/// </summary>
|
/// <param name="searchKind">Pattern.</param>
|
/// <returns>Unevaluated IEnumerable of test steps.</returns>
|
public IEnumerable<ITestStep> RecursivelyGetChildSteps(TestStepSearch searchKind)
|
{
|
return (this as ITestStep).RecursivelyGetChildSteps(searchKind);
|
}
|
|
/// <summary>
|
/// Gets children following a specific search patterns. Not recursive.
|
/// </summary>
|
/// <param name="searchKind">Search pattern to use.</param>
|
/// <returns>Unevaluated IEnumerable.</returns>
|
public IEnumerable<ITestStep> GetChildSteps(TestStepSearch searchKind)
|
{
|
return (this as ITestStep).GetChildSteps(searchKind);
|
}
|
|
/// <summary>
|
/// Log used to Log trace messages from TestSteps. These messages will be written with
|
/// "TestStep" as the source.
|
/// </summary>
|
protected static readonly TraceSource Log = OpenTap.Log.CreateSource("TestStep");
|
|
/// <summary>
|
/// Returns a default name for a step type.
|
/// </summary>
|
/// <param name="stepType"></param>
|
/// <returns></returns>
|
public static string[] GenerateDefaultNames(ITypeData stepType)
|
{
|
if (stepType == null)
|
throw new ArgumentNullException(nameof(stepType));
|
var disp = stepType.GetDisplayAttribute();
|
return disp.Group.Append(disp.Name).ToArray();
|
}
|
|
/// <summary> Returns a default name for a step type. </summary>
|
/// <param name="stepType"></param>
|
/// <returns></returns>
|
[Obsolete("Use other overload of GenerateDefaultNames instead.")]
|
public static string[] GenerateDefaultNames(Type stepType) => GenerateDefaultNames(TypeData.FromType(stepType));
|
|
static ConditionalWeakTable<ITypeData, string> defaultNames = new ConditionalWeakTable<ITypeData, string>();
|
|
/// <summary>
|
/// Initializes a new instance of the TestStep base class.
|
/// </summary>
|
public TestStep()
|
{
|
var t = TypeData.GetTypeData(this);
|
name = defaultNames.GetValue(t, type => GenerateDefaultNames(type).Last());
|
|
Enabled = true;
|
IsReadOnly = false;
|
ChildTestSteps = new TestStepList();
|
|
var things = loaderLookup.GetValue(t, loadDefaultResources);
|
foreach (var loader in things)
|
loader(this);
|
Results = null; // this will be set by DoRun just before calling Run()
|
}
|
|
static readonly ConditionalWeakTable<ITypeData, Action<object>[]> loaderLookup = new ConditionalWeakTable<ITypeData, Action<object>[]>();
|
|
static Action<object>[] loadDefaultResources(ITypeData t)
|
{
|
List<Action<object>> loaders = new List<Action<object>>();
|
var props = t.GetMembers();
|
foreach (var prop in props.Where(p => p.Writable))
|
{
|
var propType = (prop.TypeDescriptor as TypeData)?.Load();
|
if (propType == null) continue;
|
if (propType.DescendsTo(typeof(IList)) && propType.IsGenericType)
|
{
|
Type genericType = propType.GetGenericArguments().FirstOrDefault();
|
if (ComponentSettingsList.HasContainer(genericType))
|
{
|
loaders.Add((x) =>
|
{
|
IList values = ComponentSettingsList.GetContainer(genericType);
|
if (values != null)
|
{
|
var interestingValues = values.Cast<object>()
|
.Where(o => o != null && o.GetType().DescendsTo(genericType)).ToList();
|
if (interestingValues.Count > 0)
|
{
|
IList vlist = Activator.CreateInstance(propType) as IList;
|
vlist.Insert(0, interestingValues.First());
|
object value = vlist;
|
try
|
{
|
prop.SetValue(x, value);
|
}
|
catch (Exception ex)
|
{
|
Log.Warning("Caught exception while setting default value on {0}.", prop);
|
Log.Debug(ex);
|
}
|
}
|
}
|
});
|
|
}
|
}
|
else if (ComponentSettingsList.HasContainer(propType))
|
{
|
|
loaders.Add(x =>
|
{
|
try
|
{
|
var currentValue = prop.GetValue(x);
|
if (currentValue != null)
|
return; // if the constructor already set a value, don't overwrite it
|
}
|
catch (Exception ex)
|
{
|
Log.Warning("Caught exception while getting default value on {0}.", prop);
|
Log.Debug(ex);
|
}
|
IList list = ComponentSettingsList.GetContainer(propType);
|
if (list != null)
|
{
|
object value = list.Cast<object>()
|
.FirstOrDefault(o => o != null && o.GetType().DescendsTo(propType));
|
|
try
|
{
|
prop.SetValue(x, value);
|
}
|
catch (Exception ex)
|
{
|
Log.Warning("Caught exception while setting default value on {0}.", prop);
|
Log.Debug(ex);
|
}
|
}
|
});
|
}
|
}
|
if (loaders.Count == 0) return Array.Empty<Action<object>>();
|
return loaders.ToArray();
|
}
|
|
static Dictionary<Type, bool> prePostPlanRunUsedLookup = new Dictionary<Type, bool>();
|
|
static bool preOrPostPlanRunOverridden(Type t)
|
{
|
bool isMethodOverridden(string methodName)
|
{
|
var m1 = typeof(TestStep).GetMethod(methodName).MethodHandle.Value;
|
var m2 = t.GetMethod(methodName).MethodHandle.Value;
|
return m1 != m2;
|
}
|
lock (prePostPlanRunUsedLookup)
|
{
|
if (prePostPlanRunUsedLookup.ContainsKey(t) == false)
|
{
|
prePostPlanRunUsedLookup[t] = isMethodOverridden(nameof(PrePlanRun)) || isMethodOverridden(nameof(PostPlanRun));
|
}
|
return prePostPlanRunUsedLookup[t];
|
}
|
}
|
|
bool? prePostPlanRunUsed;
|
|
/// <summary> True if Pre- or PostPlanRUn has been overridden. </summary>
|
internal bool PrePostPlanRunUsed
|
{
|
get
|
{
|
if (prePostPlanRunUsed.HasValue == false)
|
{
|
prePostPlanRunUsed = preOrPostPlanRunOverridden(GetType());
|
}
|
return prePostPlanRunUsed.Value;
|
}
|
}
|
|
|
|
/// <summary>
|
/// Sets the Verdict if it is not already set to a more serious verdict (for example, a Pass verdict would be upgraded to Fail, which is more serious).
|
/// </summary>
|
/// <param name="verdict">New verdict to set.</param>
|
protected void UpgradeVerdict(Verdict verdict)
|
{
|
if ((int)verdict > (int)this.Verdict)
|
{
|
this.Verdict = verdict;
|
}
|
}
|
|
/// <summary>
|
/// Searches up through the Parent steps and returns the first step of the requested type that it finds.
|
/// </summary>
|
/// <typeparam name="T">The type of TestStep to get.</typeparam>
|
/// <returns>The closest TestStep of the requested type in the hierarchy.</returns>
|
protected T GetParent<T>()
|
{
|
return (this as ITestStep).GetParent<T>();
|
}
|
|
/// <summary>
|
/// Called by TestPlan.Run() for each step in the test plan prior to calling the <see cref="TestStep.Run"/> method of each step.
|
/// </summary>
|
public virtual void PrePlanRun()
|
{
|
|
}
|
|
/// <summary>
|
/// Called by TestPlan.Run() to run each TestStep.
|
/// If this step has children (ChildTestSteps.Count > 0), then these are executed instead.
|
/// </summary>
|
public abstract void Run();
|
|
/// <summary>
|
/// Called by TestPlan.Run() after completing all <see cref="TestStep.Run"/> methods in the <see cref="TestPlan"/>.
|
/// /// </summary>
|
/// <remarks>
|
/// Note that <see cref="TestStep.PostPlanRun"/>run is run in reverse order.
|
/// For example, suppose you had three tests: T1, T2, and T3.
|
/// PrePlanRun would run for T1, T2 and T3 (in that order), and PostPlanRun would run for T3, T2 and T1 (in that order).
|
/// </remarks>
|
|
public virtual void PostPlanRun()
|
{
|
|
}
|
|
/// <summary>
|
/// Raises the <see cref="TestPlan.BreakOffered"/> event on the <see cref="TestPlan"/> object to which this TestStep belongs.
|
/// </summary>
|
/// <remarks> This method allows a user interface implementation to break/pause the execution of the TestPlan at the point at which it is called.</remarks>
|
public void OfferBreak(bool isTestStepStarting = false)
|
{
|
(this as ITestStep).OfferBreak(StepRun, isTestStepStarting);
|
}
|
|
/// <summary>
|
/// Runs all enabled <see cref="TestStep.ChildTestSteps"/> of this TestStep. Upgrades parent verdict to the resulting verdict of the childrens run. Throws an exception if the child step does not belong or isn't enabled.
|
/// </summary>
|
/// <param name="attachedParameters">Parameters that will be stored together with the actual parameters of the steps.</param>
|
protected IEnumerable<TestStepRun> RunChildSteps(IEnumerable<ResultParameter> attachedParameters = null)
|
{
|
return RunChildSteps(attachedParameters, CancellationToken.None);
|
}
|
|
/// <summary>
|
/// Runs all enabled <see cref="TestStep.ChildTestSteps"/> of this TestStep. Upgrades parent verdict to the resulting verdict of the childrens run. Throws an exception if the child step does not belong or isn't enabled.
|
/// </summary>
|
/// <param name="throwOnBreak">Whether an exception will be thrown due to break conditions or if they will be caught. Exceptions are still available on child test steps TestStepRun.Exception. </param>
|
protected IEnumerable<TestStepRun> RunChildSteps(bool throwOnBreak)
|
{
|
return RunChildSteps(null, CancellationToken.None, throwOnBreak);
|
}
|
|
/// <summary>
|
/// Runs all enabled <see cref="TestStep.ChildTestSteps"/> of this TestStep. Upgrades parent verdict to the resulting verdict of the childrens run. Throws an exception if the child step does not belong or isn't enabled.
|
/// </summary>
|
/// <param name="attachedParameters">Parameters that will be stored together with the actual parameters of the steps.</param>
|
/// <param name="cancellationToken">Provides a way to cancel the execution of child steps before all steps are executed.</param>
|
protected IEnumerable<TestStepRun> RunChildSteps(IEnumerable<ResultParameter> attachedParameters, CancellationToken cancellationToken)
|
{
|
return RunChildSteps(attachedParameters, cancellationToken, true);
|
}
|
|
/// <summary>
|
/// Runs all enabled <see cref="TestStep.ChildTestSteps"/> of this TestStep. Upgrades parent verdict to the resulting verdict of the childrens run. Throws an exception if the child step does not belong or isn't enabled.
|
/// </summary>
|
/// <param name="attachedParameters">Parameters that will be stored together with the actual parameters of the steps.</param>
|
/// <param name="cancellationToken">Provides a way to cancel the execution of child steps before all steps are executed.</param>
|
/// <param name="throwOnBreak">Whether an exception will be thrown due to break conditions or if they will be caught. Exceptions are still available on child test steps TestStepRun.Exception. </param>
|
protected IEnumerable<TestStepRun> RunChildSteps(IEnumerable<ResultParameter> attachedParameters, CancellationToken cancellationToken, bool throwOnBreak)
|
{
|
return this.RunChildSteps(PlanRun, StepRun, attachedParameters, cancellationToken, throwOnBreak);
|
}
|
|
/// <summary>
|
/// Runs the specified child step if enabled. Upgrades parent verdict to the resulting verdict of the child run. Throws an exception if childStep does not belong or isn't enabled.
|
/// </summary>
|
/// <param name="childStep">The child step to run.</param>
|
/// <param name="attachedParameters">Parameters that will be stored together with the actual parameters of the step.</param>
|
protected TestStepRun RunChildStep(ITestStep childStep, IEnumerable<ResultParameter> attachedParameters = null)
|
{
|
return this.RunChildStep(childStep, PlanRun, StepRun, attachedParameters);
|
}
|
|
/// <summary>
|
/// Runs the specified child step if enabled. Upgrades parent verdict to the resulting verdict of the child run. Throws an exception if childStep does not belong or isn't enabled.
|
/// </summary>
|
/// <param name="childStep">The child step to run.</param>
|
/// <param name="throwOnBreak"></param>
|
/// <param name="attachedParameters">Parameters that will be stored together with the actual parameters of the step.</param>
|
protected TestStepRun RunChildStep(ITestStep childStep, bool throwOnBreak, IEnumerable<ResultParameter> attachedParameters = null)
|
{
|
return this.RunChildStep(childStep, throwOnBreak, PlanRun, StepRun, attachedParameters);
|
}
|
|
|
/// <summary>
|
/// ÍÛ¿¿Óпӣ¬ÕâÀïÔÀ´ÊÇûÓÐThreadLocalµÄ£¬¸ÄÁËÖ®ºó²»ÖªµÀ»á²»»áÓÐÎÊÌâ
|
/// </summary>
|
[XmlIgnore]
|
private ThreadLocal<TestPlanRun> PlanRunLocal = new ThreadLocal<TestPlanRun>();
|
|
/// <summary>
|
/// Gets or sets the <see cref="TestPlanRun"/>.
|
/// </summary>
|
[Browsable(false)]
|
[XmlIgnore]
|
[AnnotationIgnore]
|
public TestPlanRun PlanRun
|
{
|
get;// => PlanRunLocal.Value;
|
set;
|
//{
|
// PlanRunLocal.Value = value;
|
//}
|
}
|
|
[XmlIgnore]
|
private ThreadLocal<TestStepRun> StepRunLocal = new ThreadLocal<TestStepRun>();
|
|
/// <summary>
|
/// Gets or sets the <see cref="TestStepRun"/>.
|
/// </summary>
|
[Browsable(false)]
|
[XmlIgnore]
|
[AnnotationIgnore]
|
//public TestStepRun StepRun
|
//{
|
// get => StepRunLocal.Value;
|
// set
|
// {
|
// StepRunLocal.Value = value;
|
// }
|
//}
|
public TestStepRun StepRun
|
{
|
get; set;
|
}
|
|
|
/// <summary> Gets or sets the ID used to uniquely identify a test step within a test plan. </summary>
|
[XmlAttribute("Id")]
|
[Browsable(false)]
|
[AnnotationIgnore]
|
[SettingsIgnore]
|
public Guid Id { get; set; } = Guid.NewGuid();
|
|
// Implementing this interface will make setting and getting break conditions faster.
|
BreakCondition IBreakConditionProvider.BreakCondition { get; set; } = BreakCondition.Inherit;
|
// Implementing this interface will make setting and getting descriptions faster.
|
string IDescriptionProvider.Description { get; set; }
|
// Implementing this interface will make setting and getting dynamic members faster.
|
IImmutableDictionary<string, IMemberData> IDynamicMembersProvider.DynamicMembers { get; set; } = ImmutableDictionary<string, IMemberData>.Empty;
|
|
InputOutputRelation[] IInputOutputRelations.Inputs { get; set; }
|
InputOutputRelation[] IInputOutputRelations.Outputs { get; set; }
|
|
ImmutableDictionary<IMemberData, ParameterMemberData> parameterMembers =
|
ImmutableDictionary<IMemberData, ParameterMemberData>.Empty;
|
|
void IParameterizedMembersCache.RegisterParameterizedMember(IMemberData mem, ParameterMemberData memberData)
|
{
|
parameterMembers = parameterMembers.Add(mem, memberData);
|
}
|
|
void IParameterizedMembersCache.UnregisterParameterizedMember(IMemberData mem, ParameterMemberData memberData)
|
{
|
parameterMembers = parameterMembers.Remove(mem);
|
}
|
|
ParameterMemberData IParameterizedMembersCache.GetParameterFor(IMemberData mem)
|
{
|
if (parameterMembers.TryGetValue(mem, out var r))
|
return r;
|
return null;
|
}
|
|
ImmutableDictionary<IMemberData, object> dynamicMemberValues = ImmutableDictionary<IMemberData, object>.Empty;
|
|
|
int IDynamicMemberValue.TypeDataKey { get; set; }
|
|
bool IDynamicMemberValue.TryGetValue(IMemberData member, out object obj)
|
{
|
return dynamicMemberValues.TryGetValue(member, out obj);
|
}
|
|
void IDynamicMemberValue.SetValue(IMemberData member, object value)
|
{
|
while (true)
|
{
|
var initValue = dynamicMemberValues;
|
var newValue = dynamicMemberValues.SetItem(member, value);
|
if (initValue == Interlocked.CompareExchange(ref dynamicMemberValues, newValue, initValue))
|
break;
|
}
|
}
|
|
public virtual void InsertStep(string name, int index, ITestStep testStep)
|
{
|
testStep.Root = this.Root;
|
ChildTestSteps.Insert(index, testStep);
|
}
|
|
public virtual void AddStep(string name, ITestStep testStep)
|
{
|
testStep.Root = this.Root;
|
ChildTestSteps.Add(testStep);
|
}
|
}
|
|
/// <summary>
|
/// An extension class for the ITestStep interface.
|
/// </summary>
|
public static class TestStepExtensions
|
{
|
/// <summary>
|
/// Breaks out of running child steps when used as the suggested next step.
|
/// </summary>
|
public static Guid StartAtParent { get; } = new("62D9FEDD-E63A-48F3-B1A0-0C38C084298F");
|
/// <summary>
|
/// Searches up through the Parent steps and returns the first step of the requested type that it finds.
|
/// </summary>
|
/// <typeparam name="T">The type of TestStep to get.</typeparam>
|
/// <returns>The closest TestStep of the requested type in the hierarchy.</returns>
|
public static T GetParent<T>(this ITestStep step) => GetParent<T>((ITestStepParent)step);
|
|
/// <summary>
|
/// Searches up through the Parent steps and returns the first step of the requested type that it finds.
|
/// </summary>
|
/// <typeparam name="T">The type of TestStep to get.</typeparam>
|
/// <returns>The closest TestStep of the requested type in the hierarchy.</returns>
|
public static T GetParent<T>(this ITestStepParent item)
|
{
|
item = item.Parent;
|
while (item != null)
|
{
|
if (item is T p)
|
return p;
|
item = item.Parent;
|
}
|
return default;
|
}
|
|
/// <summary>
|
/// Raises the <see cref="TestPlan.BreakOffered"/> event on the <see cref="TestPlan"/> object to which this TestStep belongs.
|
/// </summary>
|
/// <remarks> This method allows a user interface implementation to break/pause the execution of the TestPlan at the point at which it is called.</remarks>
|
[Obsolete("Use OfferBreak(TestStepRun stepRun, bool isTestStepStarting = false) instead.")]
|
public static void OfferBreak(this ITestStep Step, bool isTestStepStarting = false)
|
{
|
OfferBreak(Step, Step.StepRun, isTestStepStarting);
|
}
|
/// <summary>
|
/// Raises the <see cref="TestPlan.BreakOffered"/> event on the <see cref="TestPlan"/> object to which this TestStep belongs.
|
/// </summary>
|
/// <remarks> This method allows a user interface implementation to break/pause the execution of the TestPlan at the point at which it is called.</remarks>
|
public static void OfferBreak(this ITestStep Step, TestStepRun stepRun, bool isTestStepStarting = false)
|
{
|
var plan = Step.GetParent<TestPlan>();
|
|
if (plan != null)
|
{
|
BreakOfferedEventArgs args = new BreakOfferedEventArgs(stepRun, isTestStepStarting);
|
plan.OnBreakOffered(args);
|
|
// stepRun.SuggestedNextStep might have been set by something else.
|
if (args.JumpToStep != null)
|
stepRun.SuggestedNextStep = args.JumpToStep;
|
}
|
}
|
/// <summary>
|
/// Gets all the enabled Child Steps.
|
/// </summary>
|
public static IEnumerable<ITestStep> GetEnabledChildSteps(this ITestStep Step)
|
{
|
return Step.GetChildSteps(TestStepSearch.EnabledOnly);
|
}
|
/// <summary>
|
/// Gets children following a specific search patterns. Not recursive.
|
/// </summary>
|
/// <param name="Step"></param>
|
/// <param name="searchKind">Search pattern to use.</param>
|
/// <returns>Unevaluated IEnumerable.</returns>
|
public static IEnumerable<ITestStep> GetChildSteps(this ITestStep Step, TestStepSearch searchKind)
|
{
|
return Step.ChildTestSteps
|
.Where(step => searchKind == TestStepSearch.All || ((searchKind == TestStepSearch.EnabledOnly) == step.Enabled));
|
}
|
/// <summary>
|
/// Recursively collects a complete list of child steps using the specified pattern. Order is depth-first.
|
/// </summary>
|
/// <param name="Step"></param>
|
/// <param name="searchKind">Pattern.</param>
|
/// <returns>Unevaluated IEnumerable of test steps.</returns>
|
public static IEnumerable<ITestStep> RecursivelyGetChildSteps(this ITestStep Step, TestStepSearch searchKind)
|
{
|
var childSteps = Step.GetChildSteps(searchKind).ToList();
|
return childSteps
|
.Concat(childSteps
|
.SelectMany(step => step.RecursivelyGetChildSteps(searchKind)));
|
}
|
|
/// <summary>
|
/// Runs all enabled <see cref="TestStep.ChildTestSteps"/> of this TestStep. Upgrades parent verdict to the resulting verdict of the childrens run. Throws an exception if the child step does not belong or isn't enabled.
|
/// </summary>
|
/// <param name="step"></param>
|
/// <param name="currentPlanRun">The current TestPlanRun.</param>
|
/// <param name="currentStepRun">The current TestStepRun.</param>
|
/// <param name="attachedParameters">Parameters that will be stored together with the actual parameters of the steps.</param>
|
public static IEnumerable<TestStepRun> RunChildSteps(this ITestStep step, TestPlanRun currentPlanRun, TestStepRun currentStepRun, IEnumerable<ResultParameter> attachedParameters = null)
|
{
|
return RunChildSteps(step, currentPlanRun, currentStepRun, attachedParameters, CancellationToken.None);
|
}
|
|
/// <summary>
|
/// Runs all enabled <see cref="TestStep.ChildTestSteps"/> of this TestStep. Upgrades parent verdict to the resulting verdict of the childrens run. Throws an exception if the child step does not belong or isn't enabled.
|
/// </summary>
|
/// <param name="step"></param>
|
/// <param name="currentPlanRun">The current TestPlanRun.</param>
|
/// <param name="currentStepRun">The current TestStepRun.</param>
|
/// <param name="attachedParameters">Parameters that will be stored together with the actual parameters of the steps.</param>
|
/// <param name="cancellationToken">Provides a way to cancel the execution of child steps before all steps are executed.</param>
|
public static IEnumerable<TestStepRun> RunChildSteps(this ITestStep step, TestPlanRun currentPlanRun,
|
TestStepRun currentStepRun,
|
IEnumerable<ResultParameter> attachedParameters, CancellationToken cancellationToken)
|
{
|
return step.RunChildSteps(currentPlanRun, currentStepRun, attachedParameters, cancellationToken, true);
|
}
|
|
|
/// <summary>
|
/// Runs all enabled <see cref="TestStep.ChildTestSteps"/> of this TestStep. Upgrades parent verdict to the resulting verdict of the childrens run. Throws an exception if the child step does not belong or isn't enabled.
|
/// </summary>
|
/// <param name="step"></param>
|
/// <param name="currentPlanRun">The current TestPlanRun.</param>
|
/// <param name="currentStepRun">The current TestStepRun.</param>
|
/// <param name="attachedParameters">Parameters that will be stored together with the actual parameters of the steps.</param>
|
/// <param name="cancellationToken">Provides a way to cancel the execution of child steps before all steps are executed.</param>
|
/// <param name="throwOnBreak">Whether an exception will be thrown due to break conditions or if they will be caught. Exceptions are still available on child test steps TestStepRun.Exception. </param>
|
public static IEnumerable<TestStepRun> RunChildSteps(this ITestStep step, TestPlanRun currentPlanRun, TestStepRun currentStepRun,
|
IEnumerable<ResultParameter> attachedParameters, CancellationToken cancellationToken, bool throwOnBreak)
|
{
|
if (currentPlanRun == null)
|
throw new ArgumentNullException(nameof(currentPlanRun));
|
if (currentStepRun == null)
|
throw new ArgumentNullException(nameof(currentStepRun));
|
if (step == null)
|
throw new ArgumentNullException(nameof(step));
|
if (step.StepRun == null)
|
throw new Exception("Cannot run child steps outside the Run method.");
|
|
step.StepRun.SupportsJumpTo = true;
|
|
var steps = step.ChildTestSteps;
|
if (steps.Count == 0) return Array.Empty<TestStepRun>();
|
List<TestStepRun> runs = new List<TestStepRun>(steps.Count);
|
try
|
{
|
for (int i = 0; i < steps.Count; i++)
|
{
|
var stepI = steps[i];
|
if (stepI.Enabled == false) continue;
|
|
TestStepRun run = stepI.DoRun(currentPlanRun, currentStepRun, attachedParameters);
|
|
if (!run.Skipped)
|
runs.Add(run);
|
|
if (cancellationToken.IsCancellationRequested) break;
|
|
// note: The following is slightly modified from something inside TestPlanExecution.cs
|
if (run.SuggestedNextStep is Guid id)
|
{
|
if (id == step.Id)
|
{
|
// If suggested next step is the parent step, skip executing child steps.
|
break;
|
}
|
if (id == StartAtParent)
|
{
|
currentStepRun.SuggestedNextStep = step.Id;
|
break;
|
}
|
|
var stepidx = steps.IndexWhen(x => x.Id == id);
|
if (stepidx >= 0)
|
i = stepidx - 1; // next iteration will be that one.
|
else
|
{
|
var seek = step.Parent;
|
while (seek != null)
|
{
|
if (seek is ITestStep step2 && id == step2.Id)
|
{
|
currentStepRun.SuggestedNextStep = id;
|
return runs;
|
}
|
seek = seek.Parent;
|
}
|
}
|
// if skip to next step, don't add it to the wait queue.
|
}
|
if (run.BreakConditionsSatisfied())
|
{
|
run.LogBreakCondition();
|
if (throwOnBreak)
|
{
|
if (run.Exception != null)
|
ExceptionDispatchInfo.Capture(run.Exception).Throw();
|
run.ThrowDueToBreakConditions();
|
}
|
else break;
|
}
|
|
TapThread.ThrowIfAborted();
|
}
|
}
|
finally
|
{
|
|
if (runs.Count > 0) // Avoid deferring if there is nothing to do.
|
{
|
void processRuns()
|
{
|
foreach (var run in runs)
|
{
|
run.WaitForCompletion();
|
step.UpgradeVerdict(run.Verdict);
|
}
|
}
|
if (step is TestStep testStep && runs.Any(x => x.WasDeferred))
|
{
|
testStep.Results.DeferNoCheck(processRuns);
|
}
|
else
|
{
|
processRuns();
|
}
|
}
|
}
|
|
return runs;
|
}
|
|
/// <summary>
|
/// Runs the specified child step if enabled. Upgrades parent verdict to the resulting verdict of the child run. Throws an exception if childStep does not belong or isn't enabled.
|
/// </summary>
|
/// <param name="step"></param>
|
/// <param name="childStep">The child step to run.</param>
|
/// <param name="currentPlanRun">The current TestPlanRun.</param>
|
/// <param name="currentStepRun">The current TestStepRun.</param>
|
/// <param name="attachedParameters">Parameters that will be stored together with the actual parameters of the step.</param>
|
public static TestStepRun RunChildStep(this ITestStep step, ITestStep childStep,
|
TestPlanRun currentPlanRun, TestStepRun currentStepRun,
|
IEnumerable<ResultParameter> attachedParameters = null)
|
{
|
return step.RunChildStep(childStep, true, currentPlanRun, currentStepRun, attachedParameters);
|
}
|
|
|
/// <summary>
|
/// Runs the specified child step if enabled. Upgrades parent verdict to the resulting verdict of the child run. Throws an exception if childStep does not belong or isn't enabled.
|
/// </summary>
|
/// <param name="step"></param>
|
/// <param name="childStep">The child step to run.</param>
|
/// <param name="throwOnBreak">Whether an exception will be thrown due to break conditions or if they will be caught. Exceptions are still available on child test steps TestStepRun.Exception. </param>
|
/// <param name="currentPlanRun">The current TestPlanRun.</param>
|
/// <param name="currentStepRun">The current TestStepRun.</param>
|
/// <param name="attachedParameters">Parameters that will be stored together with the actual parameters of the step.</param>
|
public static TestStepRun RunChildStep(this ITestStep step, ITestStep childStep, bool throwOnBreak, TestPlanRun currentPlanRun, TestStepRun currentStepRun, IEnumerable<ResultParameter> attachedParameters = null)
|
{
|
if (childStep == null)
|
throw new ArgumentNullException(nameof(childStep));
|
if (currentPlanRun == null)
|
throw new ArgumentNullException(nameof(currentPlanRun));
|
if (currentStepRun == null)
|
throw new ArgumentNullException(nameof(currentStepRun));
|
if (step.StepRun == null)
|
throw new Exception("Can only run child step during own step run.");
|
if (childStep.Parent != step)
|
throw new ArgumentException("childStep must be a child step of Step", nameof(childStep));
|
if (childStep.Enabled == false)
|
throw new ArgumentException("childStep must be enabled.", nameof(childStep));
|
|
var run = childStep.DoRun(currentPlanRun, currentStepRun, attachedParameters);
|
if (step is TestStep testStep && run.WasDeferred)
|
{
|
testStep.Results.DeferNoCheck(() =>
|
{
|
run.WaitForCompletion();
|
step.UpgradeVerdict(run.Verdict);
|
});
|
}
|
else
|
{
|
if (run.WasDeferred)
|
run.WaitForCompletion();
|
step.UpgradeVerdict(run.Verdict);
|
}
|
|
if (run.BreakConditionsSatisfied())
|
{
|
run.LogBreakCondition();
|
if (run.Verdict == Verdict.Error && throwOnBreak)
|
run.ThrowDueToBreakConditions();
|
}
|
return run;
|
}
|
|
internal static void LogBreakCondition(this TestStepRun run)
|
{
|
Log.CreateSource("TestStep").Debug($"Break issued from '{run.TestStepName}' due to verdict {run.Verdict}. See Break Conditions settings.");
|
}
|
|
internal static string GetStepPath(this ITestStep Step)
|
{
|
var name = Step.GetFormattedName();
|
|
StringBuilder sb = StringBuilderCache.GetStringBuilder();
|
sb.Append('"');
|
|
void getParentNames(ITestStep step)
|
{
|
if (step.Parent is ITestStep parent2)
|
getParentNames(parent2);
|
|
sb.Append(step.GetFormattedName());
|
sb.Append(" \\ ");
|
}
|
|
if (Step.Parent is ITestStep parent)
|
getParentNames(parent);
|
sb.Append(name);
|
sb.Append('"');
|
return sb.ToString();
|
}
|
|
static readonly object upgradeVerdictLock = new object();
|
internal static void UpgradeVerdict(this ITestStep step, Verdict newVerdict)
|
{
|
if (step.Verdict < newVerdict)
|
{
|
var lockObj = step.StepRun?.upgradeVerdictLock ?? upgradeVerdictLock;
|
|
lock (lockObj)
|
{
|
if (step.Verdict < newVerdict)
|
step.Verdict = newVerdict;
|
}
|
}
|
}
|
|
/// <summary> This is the currently executing test step or null, used to detect deadlock when a step is waiting for its parent. </summary>
|
[ThreadStatic]
|
internal static ITestStep currentlyExecutingTestStep = null;
|
|
internal static TestStepRun DoRun(this ITestStep Step, TestPlanRun planRun, TestRun parentRun, IEnumerable<ResultParameter> attachedParameters = null)
|
{
|
{
|
// in case the previous action was not completed yet.
|
// this is a problem because StepRun might be set to null later
|
// if its not already the case.
|
Step.StepRun?.WaitForCompletion();
|
Debug.Assert(Step.StepRun == null);
|
}
|
Step.PlanRun = planRun;
|
Step.Verdict = Verdict.NotSet;
|
|
TapThread.ThrowIfAborted();
|
if (!Step.Enabled)
|
throw new Exception("Test step not enabled."); // Do not run step if it has been disabled
|
|
Exception readInputsError = null;
|
try
|
{
|
InputOutputRelation.UpdateInputs(Step);
|
}
|
catch (Exception e)
|
{
|
readInputsError = e;
|
}
|
|
var stepRun = Step.StepRun = new TestStepRun(Step, parentRun, attachedParameters, planRun)
|
{
|
TestStepPath = Step.GetStepPath()
|
};
|
|
// evaluate pre run mixins
|
var prerun = TestStepPreRunEvent.Invoke(Step);
|
var skipStep = prerun.SkipStep;
|
|
planRun.ThrottleResultPropagation();
|
|
var previouslyExecutingTestStep = currentlyExecutingTestStep;
|
currentlyExecutingTestStep = Step;
|
|
//Raise an event prior to starting the actual run of the TestStep.
|
Step.OfferBreak(stepRun, true);
|
skipStep |= stepRun.SuggestedNextStep != null;
|
if (skipStep)
|
{
|
Step.StepRun = null;
|
stepRun.Skipped = true;
|
return stepRun;
|
}
|
|
TapThread.ThrowIfAborted(); // if an OfferBreak handler called TestPlan.Abort, abort now.
|
|
if (prerun.AnyPrerunsInvoked)
|
{
|
// Update parameters after running prerun mixins. This is needed to reflect updated properties.
|
// Note that this does not handle the edge case where e.g. a PreRun mixin caused
|
// the removal of a member sourced from some TypeData, but it is impossible to distinguish a TypeData parameter
|
// from a manually added 'steprun.Parameters["foo"] = "bar" - style parameter.
|
stepRun.UpdateParams();
|
}
|
|
// To properly support single stepping stopwatch has to be below offerBreak
|
// since OfferBreak requires a TestStepRun, this has to be re-instantiated.
|
var swatch = Stopwatch.StartNew();
|
try
|
{
|
try
|
{
|
// tell result listeners the step started.
|
Step.PlanRun.ResourceManager.BeginStep(Step.PlanRun, Step, TestPlanExecutionStage.Run,
|
TapThread.Current.AbortToken);
|
try
|
{
|
if (readInputsError != null)
|
ExceptionDispatchInfo.Capture(readInputsError).Throw();
|
|
if (Step is TestStep _step)
|
_step.Results = new ResultSource(stepRun, Step.PlanRun);
|
TestPlan.Log.Info("{0} started.", stepRun.TestStepPath);
|
stepRun.StartStepRun(); // set verdict to running, set Timestamp.
|
parentRun.ChildStarted(stepRun);
|
planRun.AddTestStepRunStart(stepRun);
|
try
|
{
|
// exception set by pre-run mixin?
|
if (stepRun.Exception == null)
|
Step.Run();
|
}
|
catch (Exception ex)
|
{
|
stepRun.Exception = ex;
|
}
|
|
// Evaluate post run mixins.
|
// Allow running these even if an exception was thrown in the test step.
|
// This needs to be done before 'AfterRun' as that waits for defer and publishes results
|
// which the mixins must be able to affect.
|
TestStepPostRunEvent.Invoke(Step);
|
|
stepRun.AfterRun(Step);
|
|
if (stepRun.Exception is { } ex2)
|
// rethrow the exception.
|
// include the original stack trace in the exception.
|
ExceptionDispatchInfo.Capture(ex2).Throw();
|
|
TapThread.ThrowIfAborted();
|
}
|
finally
|
{
|
planRun.AddTestStepStateUpdate(stepRun.TestStepId, stepRun, StepState.Deferred);
|
currentlyExecutingTestStep = previouslyExecutingTestStep;
|
}
|
}
|
finally
|
{
|
planRun.ResourceManager.EndStep(Step, TestPlanExecutionStage.Run);
|
}
|
}
|
catch (TestStepBreakException e)
|
{
|
TestPlan.Log.Info(e.Message);
|
Step.UpgradeVerdict(e.Verdict);
|
stepRun.Exception = e;
|
}
|
catch (Exception e)
|
{
|
|
if (e is ThreadAbortException || (e is OperationCanceledException && TapThread.Current.AbortToken.IsCancellationRequested))
|
{
|
Step.Verdict = Verdict.Aborted;
|
if (e.Message == new OperationCanceledException().Message)
|
TestPlan.Log.Warning("Test step {0} was canceled.", stepRun.TestStepPath);
|
else
|
TestPlan.Log.Warning("Test step {0} was canceled with message '{1}'.", stepRun.TestStepPath, e.Message);
|
}
|
else
|
{
|
Step.Verdict = Verdict.Error;
|
TestPlan.Log.Error("Error running {0}: {1}.", stepRun.TestStepPath, e.Message);
|
}
|
TestPlan.Log.Debug(e);
|
stepRun.Exception = e;
|
}
|
finally
|
{
|
|
// if it was a ThreadAbortException we need 'finally'.
|
void completeAction(Task runTask)
|
{
|
try
|
{
|
runTask.Wait();
|
}
|
catch (Exception e)
|
{
|
// Tasks wrap exceptions in AggregateExceptions with a single exception
|
while (e is AggregateException aex && aex.InnerExceptions.Count == 1)
|
e = aex.InnerException;
|
|
if (e is ThreadAbortException || (e is OperationCanceledException && TapThread.Current.AbortToken.IsCancellationRequested))
|
{
|
if (TapThread.Current.AbortToken.IsCancellationRequested && Step.Verdict < Verdict.Aborted)
|
Step.Verdict = Verdict.Aborted;
|
if (e.Message == new OperationCanceledException().Message)
|
TestPlan.Log.Warning("Test step {0} was canceled.", stepRun.TestStepPath);
|
else
|
TestPlan.Log.Warning("Test step {0} was canceled with message '{1}'.", stepRun.TestStepPath, e.Message);
|
}
|
else if (e is TestStepBreakException brk)
|
{
|
TestPlan.Log.Info(brk.Message);
|
Step.UpgradeVerdict(brk.Verdict);
|
}
|
else
|
{
|
Step.Verdict = Verdict.Error;
|
TestPlan.Log.Error("Error running {0}: {1}.", stepRun.TestStepPath, e.Message);
|
}
|
TestPlan.Log.Debug(e);
|
stepRun.Exception = e;
|
}
|
finally
|
{
|
lock (Step)
|
{
|
if (Step.StepRun == stepRun)
|
{
|
Step.StepRun = null;
|
}
|
}
|
TimeSpan time = swatch.Elapsed;
|
|
stepRun.CompleteStepRun(planRun, Step, time);
|
if (Step.Verdict == Verdict.NotSet)
|
{
|
TestPlan.Log.Info(time, "{0} completed.", stepRun.TestStepPath);
|
}
|
else
|
{
|
TestPlan.Log.Info(time, "{0} completed with verdict '{1}'.", stepRun.TestStepPath, Step.Verdict);
|
}
|
|
planRun.AddTestStepRunCompleted(stepRun);
|
stepRun.SignalCompleted();
|
}
|
}
|
|
if (stepRun.ResultSource != null)
|
stepRun.ResultSource.Finally(completeAction);
|
else
|
completeAction(Task.FromResult(0));
|
}
|
|
return stepRun;
|
}
|
|
|
|
|
internal static void CheckResources(this ITestStep Step)
|
{
|
// collect null members into a set. Any null member here is an error.
|
var nullMembers = new HashSet<IMemberData>();
|
GetObjectSettings<IResource, ITestStep, IMemberData>(Step, true, (x, mem) => x == null ? mem : null, nullMembers);
|
foreach (var res in nullMembers)
|
{
|
throw new Exception(String.Format("Resource setting {1} not set on step {0}. Please configure or disable step.", Step.Name, res.GetDisplayAttribute().GetFullName()));
|
}
|
foreach (var step in Step.ChildTestSteps)
|
{
|
if (step.Enabled)
|
step.CheckResources();
|
}
|
}
|
|
// this dictionary may be accessed by multiple threads, so it is best to use ConcurrentDictionary.
|
static readonly Cache<(TypeData target, ITypeData source), (IMemberData, bool hasEnabledAttribute)[]>
|
membersLookup = new Cache<(TypeData target, ITypeData source), (IMemberData, bool hasEnabledAttribute)[]>(() => PluginManager.CacheState);
|
|
static (IMemberData, bool hasEnabledAttribute)[] GetSettingsLookup(TypeData targetType, ITypeData sourceType)
|
{
|
if (membersLookup.TryGetValue((targetType, sourceType), out var value))
|
return value;
|
var propertyInfos = sourceType.GetMembers();
|
// if the target type is 'object' we accept any type as a value.
|
bool anyType = Equals(TypeData.FromType(typeof(object)), targetType);
|
|
List<(IMemberData, bool)> result = null;
|
foreach (var prop in propertyInfos)
|
{
|
// Ignore prop if it is an IParameterMemberData because it should be managed by the object that owns it
|
if (prop is IParameterMemberData) continue;
|
if (prop.Readable == false) continue;
|
var td2 = prop.TypeDescriptor.AsTypeData();
|
if (td2 == null) continue;
|
if (!anyType)
|
{
|
if (td2.IsValueType && targetType.IsValueType == false) continue;
|
if (td2.IsString && targetType.IsString == false) continue;
|
}
|
|
bool hasEnabled = prop.HasAttribute<EnabledIfAttribute>();
|
if (td2.DescendsTo(targetType) || td2.ElementType.DescendsTo(targetType) || td2.DescendsTo(typeof(IEnabled)))
|
{
|
if (prop.HasAttribute<SettingsIgnoreAttribute>()) continue;
|
if (result == null) result = new List<(IMemberData, bool)>();
|
result.Add((prop, hasEnabled));
|
}
|
}
|
|
return membersLookup.AddValue((targetType, sourceType), (result?.ToArray() ?? Array.Empty<(IMemberData, bool)>()));
|
}
|
|
|
/// <summary>
|
/// Returns the properties of a specific type from a number of objects. This will traverse IEnumerable and optionally IEnabled properties.
|
/// </summary>
|
/// <param name="item">The object to get properties from.</param>
|
/// <param name="onlyEnabled">If true, Enabled and EnabledIf properties are only traversed into if they are enabled.</param>
|
/// <param name="transform">This transform function is called on each object, and being passed the corresponding PropertyInfo instance from the parent object.</param>
|
/// <param name="itemSet">The set of items to populate</param>
|
/// <param name="targetType">The TypeData of the target type (Optional).</param>
|
/// <returns></returns>
|
internal static void GetObjectSettings<T, T2, T3>(T2 item, bool onlyEnabled, Func<T, IMemberData, T3> transform, HashSet<T3> itemSet, TypeData targetType = null)
|
{
|
if (transform == null) transform = (t, data) => (T3)(object)t;
|
if (targetType == null) targetType = TypeData.FromType(typeof(T));
|
var enabledAttributes = new List<EnabledIfAttribute>();
|
|
var properties = GetSettingsLookup(targetType, TypeData.GetTypeData(item));
|
foreach (var (prop, hasEnabled) in properties)
|
{
|
if (onlyEnabled && hasEnabled)
|
{
|
enabledAttributes.Clear();
|
prop.GetAttributes<EnabledIfAttribute>(enabledAttributes);
|
bool nextProperty = false;
|
foreach (var attr in enabledAttributes)
|
{
|
bool isEnabled = EnabledIfAttribute.IsEnabled(attr, item);
|
if (isEnabled == false)
|
{
|
nextProperty = true;
|
break;
|
}
|
}
|
|
if (nextProperty) continue;
|
}
|
|
object value;
|
try
|
{
|
value = prop.GetValue(item);
|
}
|
catch
|
{
|
continue;
|
}
|
|
if (value is IEnabled e)
|
{
|
if (e.IsEnabled == false && onlyEnabled)
|
continue;
|
GetObjectSettings(value, onlyEnabled, transform, itemSet, targetType);
|
continue;
|
}
|
|
if (value is T t2)
|
{
|
itemSet.AddExceptNull(transform(t2, prop));
|
}
|
else if (value is string)
|
continue;
|
else if (value == null && prop.TypeDescriptor.DescendsTo(targetType))
|
{
|
itemSet.AddExceptNull(transform((T)value, prop));
|
}
|
else if (value is IEnumerable seq)
|
{
|
if (seq is IList lst)
|
{
|
for (int i = 0; i < lst.Count; i++)
|
{
|
var value2 = lst[i];
|
if (value2 is T x)
|
itemSet.AddExceptNull(transform(x, prop));
|
}
|
}
|
else
|
{
|
if (value is IEnumerable<T> seq2)
|
{
|
foreach (var x in seq2.ToArray())
|
itemSet.AddExceptNull(transform(x, prop));
|
}
|
else
|
{
|
foreach (var x in seq.OfType<T>().ToArray())
|
itemSet.AddExceptNull(transform(x, prop));
|
}
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// Returns the properties of a specific type from a number of objects. This will traverse IEnumerable and optionally IEnabled properties.
|
/// </summary>
|
/// <param name="objects">The objects to return properties from.</param>
|
/// <param name="onlyEnabled">If true, Enabled and EnabledIf properties are only traversed into if they are enabled.</param>
|
/// <param name="transform">This transform function is called on each object, and being passed the corresponding PropertyInfo instance from the parent object.</param>
|
/// <param name="itemSet"> The set of elements being populated. </param>
|
/// <returns></returns>
|
internal static void GetObjectSettings<T, T2, T3>(IEnumerable<T2> objects, bool onlyEnabled, Func<T, IMemberData, T3> transform, HashSet<T3> itemSet)
|
{
|
if (transform == null)
|
transform = (x, prop) => (T3)(object)x;
|
var targetType = TypeData.FromType(typeof(T));
|
foreach (var item in objects)
|
GetObjectSettings(item, onlyEnabled, transform, itemSet, targetType);
|
}
|
|
|
struct Replace
|
{
|
public int StartIndex;
|
public int EndIndex;
|
public string Content;
|
}
|
|
/// <summary> Cache for quickly getting the display names of members used to generate the formatted name. </summary>
|
static readonly ConditionalWeakTable<ITypeData, Dictionary<string, IMemberData>> formatterLutCache
|
= new ConditionalWeakTable<ITypeData, Dictionary<string, IMemberData>>();
|
|
/// <summary> Takes the name of step and replaces {} tokens with the value of properties. </summary>
|
public static string GetFormattedName(this ITestStep step)
|
{
|
string name;
|
|
if (step is IFormatName _fmt)
|
name = _fmt.GetFormattedName();
|
else
|
name = step?.Name;
|
|
if (name == null) return string.Empty;
|
if (name.Contains('{') == false || name.Contains('}') == false)
|
return name;
|
|
var type = TypeData.GetTypeData(step);
|
if (formatterLutCache.TryGetValue(type, out var props) == false)
|
{
|
// GetProperties potentially slow. GetFormattedName is in test plan exec thread, so the outcome is cached.
|
|
props = new Dictionary<string, IMemberData>();
|
foreach (var item in type.GetMembers())
|
{
|
var browsable = item.GetAttribute<BrowsableAttribute>();
|
if (browsable != null && browsable.Browsable == false) continue;
|
if (item.Readable == false)
|
continue;
|
var s = item.GetDisplayAttribute();
|
if ((s.Group != null) && (s.Group.Length > 0))
|
{
|
// GroupName [space] DisplayName
|
var fullFormat = $"{string.Join(" ", s.Group.Select(g => g.Trim()))} {s.Name.Trim()}";
|
props[fullFormat.ToLower()] = item;
|
// just DisplayName
|
var shortFormat = s.Name.Trim().ToLower();
|
if (!props.ContainsKey(shortFormat))
|
props[shortFormat.ToLower()] = item;
|
}
|
else
|
{
|
props[s.Name.ToLower()] = item;
|
}
|
}
|
|
formatterLutCache.GetValue(type, _ => props);
|
}
|
|
int offset = 0;
|
int seek = 0;
|
|
List<Replace> replaces = new List<Replace>();
|
|
while ((seek = name.IndexOf('{', offset)) >= 0)
|
{
|
if (seek == name.Length - 1) break;
|
if (name[seek + 1] == '{')
|
{ // take inner '{' if multiple {'s.
|
offset = seek + 1;
|
continue;
|
}
|
|
int seek2 = name.IndexOf('}', offset);
|
if (seek2 == -1) break;
|
var prop = name.Substring(seek + 1, seek2 - seek - 1);
|
prop = prop.Trim().ToLower();
|
while (prop.Contains(" "))
|
prop = prop.Replace(" ", " ");
|
|
if (props.TryGetValue(prop, out var property))
|
{
|
var value = property.GetValue(step);
|
var unitattr = property.GetAttribute<UnitAttribute>();
|
string valueString = null;
|
bool isCollection = value is IEnumerable && false == value is string;
|
|
if (value == null)
|
valueString = "Not Set";
|
else if (unitattr != null && !isCollection)
|
{
|
var fmt = new NumberFormatter(System.Globalization.CultureInfo.CurrentCulture, unitattr);
|
valueString = fmt.FormatNumber(value);
|
}
|
else if (isCollection)
|
{
|
if (value.GetType().GetEnumerableElementType().IsNumeric())
|
{ // if IEnumerable<NumericType> use number formatter.
|
var fmt = new NumberFormatter(System.Globalization.CultureInfo.CurrentCulture, unitattr);
|
valueString = fmt.FormatRange(value as IEnumerable);
|
}
|
else
|
{ // else use ToString.
|
valueString = string.Join(System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberGroupSeparator + " ", ((IEnumerable)value).Cast<object>().Select(o => o ?? "NULL"));
|
}
|
}
|
else if (value is Enum e)
|
valueString = Utils.EnumToReadableString(e);
|
else
|
{
|
valueString = value.ToString();
|
}
|
replaces.Add(new Replace { StartIndex = seek, EndIndex = seek2, Content = valueString });
|
}
|
offset = seek2 + 1;
|
}
|
|
StringBuilder outName = new StringBuilder(name);
|
|
for (int i = replaces.Count - 1; i >= 0; i--)
|
{
|
var rep = replaces[i];
|
outName.Remove(rep.StartIndex, rep.EndIndex - rep.StartIndex + 1);
|
outName.Insert(rep.StartIndex, rep.Content);
|
}
|
return outName.ToString().TrimEnd();
|
}
|
}
|
|
/// <summary>
|
/// Marks a property as not a setting. This is a performance optimization for when finding resources throughout the test plan.
|
/// </summary>
|
internal class SettingsIgnoreAttribute : Attribute
|
{ }
|
}
|
