// 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.ComponentModel;
|
using NUnit.Framework;
|
using OpenTap.Plugins.BasicSteps;
|
using OpenTap.Engine.UnitTests.TestTestSteps;
|
using OpenTap.EngineUnitTestUtils;
|
using OpenTap.UnitTests;
|
|
namespace OpenTap.Engine.UnitTests
|
{
|
namespace SubSpace
|
{
|
public class TestStepTest : TestStep
|
{
|
public List<TestPoint> TestPoints { get; set; }
|
public class TestPoint
|
{
|
public int Channel;
|
}
|
/// <summary>
|
/// Initializes a new instance of the TestStepTest class.
|
/// </summary>
|
public TestStepTest()
|
{
|
TestPoints = new List<TestPoint>();
|
}
|
public override void Run()
|
{
|
}
|
}
|
}
|
public class TestStepTest : TestStep
|
{
|
public List<TestPoint> TestPoints { get; set; }
|
public class TestPoint
|
{
|
public int Channel { get; set; }
|
}
|
public class NestedStep : TestStep
|
{
|
public override void Run() { }
|
}
|
public string PublishArtifact;
|
/// <summary>
|
/// Initializes a new instance of the TestStepTest class.
|
/// </summary>
|
public TestStepTest()
|
{
|
TestPoints = new List<TestPoint>();
|
}
|
public override void Run()
|
{
|
Results.Publish("UnitTest", new List<string>() { "Channel", "Power [dBm]" }, 27, 1.11, 2, 0);
|
Verdict = Verdict.Pass;
|
if (string.IsNullOrEmpty(PublishArtifact) == false)
|
{
|
StepRun.PublishArtifact(PublishArtifact);
|
}
|
}
|
|
public static TestPlan CreateGenericTestPlan()
|
{
|
TestPlan plan = new TestPlan();
|
plan.Steps.Add(new TestStepTest());
|
plan.Steps.Add(new SubSpace.TestStepTest());
|
plan.Steps.Add(new TestStepTest2());
|
return plan;
|
}
|
|
}
|
public class TestStepTest2 : TestStep
|
{
|
public List<TestPoint> TestPoints { get; set; }
|
public class TestPoint
|
{
|
public int Channel { get; set; }
|
}
|
public class NestedStep : TestStep
|
{
|
public override void Run() { }
|
}
|
public class SomeObject
|
{
|
public int Channel { get; set; }
|
}
|
public SomeObject ObjectProperty { get; set; }
|
|
/// <summary>
|
/// Initializes a new instance of the TestStepTest2 class.
|
/// </summary>
|
public TestStepTest2()
|
{
|
TestPoints = new List<TestPoint>();
|
}
|
public override void Run()
|
{
|
}
|
}
|
|
[AllowAsChildIn(typeof(RecursiveTestStep))]
|
public class TestStepTest3 : TestStep
|
{
|
public List<TestPoint> TestPoints { get; set; }
|
|
|
public class TestPoint
|
{
|
public int Channel { get; set; }
|
}
|
public class SomeObject
|
{
|
public int Channel { get; set; }
|
}
|
public SomeObject ObjectProperty { get; set; }
|
|
/// <summary>
|
/// Initializes a new instance of the TestStepTest2 class.
|
/// </summary>
|
public TestStepTest3()
|
{
|
TestPoints = new List<TestPoint>();
|
}
|
public override void Run()
|
{
|
}
|
}
|
public class RecursiveTestStep : TestStep
|
{
|
public int SomeInt { get; set; }
|
public RecursiveTestStep()
|
{
|
SomeInt = 5;
|
}
|
public override void Run()
|
{
|
|
}
|
}
|
|
public class OpenCrash : Instrument
|
{
|
|
public override void Open()
|
{
|
base.Open();
|
throw new Exception("intended");
|
}
|
}
|
|
public class CloseCrash : Instrument
|
{
|
public override void Close()
|
{
|
base.Close();
|
throw new Exception("intended");
|
}
|
}
|
|
public class CreateCrash : Instrument
|
{
|
public CreateCrash()
|
{
|
throw new Exception("Intended");
|
}
|
}
|
|
public class testInstr : TestStep
|
{
|
public IInstrument Inst { get; set; }
|
public override void Run()
|
{
|
|
}
|
}
|
|
|
[System.ComponentModel.DisplayName(" Close Every Thing")]
|
public class closeEveryThing : TestStep
|
{
|
|
public override void PrePlanRun()
|
{
|
base.PrePlanRun();
|
Run();
|
}
|
|
public override void Run()
|
{
|
InstrumentSettings.Current
|
.Concat<IResource>(ResultSettings.Current)
|
.Concat(DutSettings.Current)
|
.ToList()
|
.ForEach(r => r.Close());
|
}
|
|
}
|
|
public class IsOpenTestStep : TestStep
|
{
|
public IResource Resource { get; set; }
|
|
public override void Run()
|
{
|
Assert.IsTrue(Resource.IsConnected);
|
}
|
}
|
|
public class DummyDut : Dut
|
{
|
[MetaData]
|
[Browsable(false)]
|
public string Serial { get; set; }
|
|
public override void Open()
|
{
|
base.Open();
|
Serial = SerialNumber;
|
}
|
public override void Close()
|
{
|
base.Close();
|
Serial = null;
|
}
|
|
public static string SerialNumber = "123456";
|
|
}
|
|
public class DummyInstrument : Instrument
|
{
|
|
}
|
|
public class DummyReferencingInstrument : Instrument
|
{
|
public Instrument Other { get; set; }
|
}
|
|
[DisplayName("Test\\UnitTest resultListener2")]
|
public class resultListener2 : ResultListener
|
{
|
public resultListener2()
|
{
|
Name = "resultListener2";
|
}
|
}
|
|
/*public*/
|
class ThrowExceptionSetting : ComponentSettings
|
{
|
public int exceptionTest
|
{
|
get
|
{
|
throw new Exception("Intended");
|
}
|
set
|
{
|
throw new Exception("Intended");
|
}
|
|
}
|
}
|
|
[Display("Enabled Check Boxes")]
|
public class EnabledFormattedNameTest : TestStep
|
{
|
[Display("Checked Bool")]
|
public Enabled<bool> CheckedBool { get; set; }
|
[Display("Checked Bool Array")]
|
public Enabled<bool[]> CheckedBoolArray { get; set; }
|
[Display("Checked Double")]
|
public Enabled<double> CheckedDouble { get; set; }
|
[Display("Checked Double Array")]
|
public Enabled<double[]> CheckedDoubleArray { get; set; }
|
[Display("Checked String")]
|
public Enabled<string> CheckedString { get; set; }
|
[Display("Checked String Array")]
|
public Enabled<string[]> CheckedStringArray { get; set; }
|
[Display("Checked String List")]
|
public Enabled<List<string>> CheckedStringList { get; set; }
|
[Display("Checked Instrument")]
|
public Enabled<Instrument> CheckedInstrument { get; set; }
|
|
public EnabledFormattedNameTest()
|
{
|
CheckedBool = new Enabled<bool>() { IsEnabled = true, Value = false };
|
CheckedBoolArray = new Enabled<bool[]>() { IsEnabled = true, Value = new bool[] { false, true } };
|
CheckedDouble = new Enabled<double>() { IsEnabled = true, Value = 3.21 };
|
CheckedDoubleArray = new Enabled<double[]>() { IsEnabled = true, Value = new double[] { 3.33, 45.6, 88.8 } };
|
CheckedString = new Enabled<string>() { IsEnabled = true, Value = "Some comment" };
|
CheckedStringArray = new Enabled<string[]>() { IsEnabled = true, Value = new string[] { "abc", "DEF", "GhI" } };
|
CheckedStringList = new Enabled<List<string>>() { IsEnabled = true, Value = new List<string> { "One", "Two", "Three" } };
|
CheckedInstrument = new Enabled<Instrument>() { IsEnabled = true };
|
}
|
|
public override void Run()
|
{
|
throw new NotImplementedException();
|
}
|
}
|
|
public class NullArrayTest : TestStep
|
{
|
public int[] TestArray { get; set; }
|
public override void Run()
|
{
|
throw new NotImplementedException();
|
}
|
}
|
|
public class NullArrayInstrument : Instrument
|
{
|
public int[] TestArray { get; set; }
|
}
|
|
public class ResultStressTest : TestStep
|
{
|
public int Iterations { get; set; }
|
public ResultStressTest()
|
{
|
Iterations = 100;
|
}
|
public override void Run()
|
{
|
for (double i = 0; i < Iterations; i++)
|
{
|
Results.Publish("UnitTest", new List<string>() { "Channel", "Power [dBm]" }, i, Math.Sin(i), 2, 0);
|
}
|
Verdict = Verdict.Pass;
|
}
|
}
|
|
public class Result1DTest : TestStep
|
{
|
public int NResults { get; set; }
|
public double Duration { get; set; }
|
public Result1DTest()
|
{
|
NResults = 100;
|
}
|
public override void Run()
|
{
|
TapThread.Sleep((int)(1000 * Duration));
|
for (double i = 0; i < NResults; i++)
|
{
|
Results.Publish("UnitTest", new List<string> { "Channel", "Power [dBm]" }, Math.Sin(i)/*,Math.Cos(i)*/);
|
}
|
Verdict = Verdict.Pass;
|
}
|
}
|
|
public class SomeClass { }
|
|
public class NullPropertyTest : TestStep
|
{
|
public SomeClass Property { get; set; }
|
|
|
public override void Run()
|
{
|
for (double i = 0; i < 5; i++)
|
{
|
Results.Publish("UnitTest", new List<string> { "Channel", "Power [dBm]" }, Math.Sin(i), Math.Cos(i));
|
}
|
}
|
}
|
|
public class GetParamsSub : Resource
|
{
|
[MetaData]
|
public int Index { get; set; }
|
public int Index2 { get; set; }
|
public GetParamsSub()
|
{
|
Index = 10;
|
}
|
}
|
|
public class GetParameters : TestStep
|
{
|
public double Param1 { get; set; }
|
public GetParamsSub sub { get; set; }
|
public GetParameters()
|
{
|
sub = new GetParamsSub();
|
}
|
public override void Run()
|
{
|
|
Param1 = 5;
|
var param = ResultParameters.GetParams(this);
|
var dict = param.ToDictionary();
|
Assert.IsTrue((double)dict["Param1"] == Param1);
|
Assert.IsTrue(dict.ContainsKey("sub/Index"));
|
Assert.IsTrue(dict.ContainsKey("sub/Index2") == false);
|
Console.WriteLine(param);
|
}
|
}
|
|
public class ReadOnlyTests
|
{
|
public class ReadOnlyParams
|
{
|
[Browsable(true)] public int X => GetHashCode();
|
public string Message => X + " example"; // immutable value.
|
|
public int Value { get; set; } // this value is mutable.
|
}
|
|
public class ReadOnlyListTest : TestStep
|
{
|
List<ReadOnlyParams> elements = new List<ReadOnlyParams>
|
{
|
new ReadOnlyParams(), new ReadOnlyParams(), new ReadOnlyParams(),
|
};
|
public IReadOnlyList<ReadOnlyParams> Elements
|
{
|
get => elements.AsReadOnly();
|
set { elements = value.ToList(); }
|
}
|
public override void Run() { }
|
}
|
|
[Test]
|
public void TestReadOnlyList()
|
{
|
var plan = new TestPlan();
|
var step1 = new ReadOnlyListTest();
|
step1.Elements = Enumerable.Range(0, 5).Select(i => new ReadOnlyParams() {Value = i}).ToList();
|
Assert.AreEqual(5, step1.Elements.Count);
|
plan.Steps.Add(step1);
|
|
var listener = new TestTraceListener();
|
Log.AddListener(listener);
|
var xml = plan.SerializeToString();
|
var plan2 = Utils.DeserializeFromString<TestPlan>(xml);
|
Log.RemoveListener(listener);
|
listener.AssertErrors(new List<string>());
|
|
var step2 = (ReadOnlyListTest) plan2.Steps[0];
|
Assert.AreEqual(step1.Elements.Count, step2.Elements.Count);
|
bool allEqualValues = step1.Elements
|
.Zip(step2.Elements, (x, y) => x.Value == y.Value)
|
.All(x => x);
|
Assert.IsTrue(allEqualValues);
|
}
|
}
|
|
[TestFixture]
|
public class TestStepTestFixture
|
{
|
[Test]
|
public void SetStepNameToNullThrows()
|
{
|
Assert.Throws<ArgumentNullException>(() => new DelayStep { Name = null });
|
}
|
}
|
|
[TestFixture]
|
public class BasicTestStepTests
|
{
|
public class FunkyArrayStep : TestStep
|
{
|
public object[] Array { get; set; }
|
public override void Run()
|
{
|
throw new NotImplementedException();
|
}
|
public FunkyArrayStep()
|
{
|
Array = new object[] { new object(), null, 5.0, "Test" };
|
}
|
}
|
[Test]
|
public void TestNameFormat()
|
{
|
var culture = System.Threading.Thread.CurrentThread.CurrentCulture;
|
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
|
try
|
{
|
DelayStep delay = new DelayStep();
|
delay.DelaySecs = 1.0;
|
delay.Name = "Delay of {Time Delay} and {Time Delay}";
|
var result = delay.GetFormattedName();
|
Assert.AreEqual(result, "Delay of 1 s and 1 s");
|
|
delay.Name = "Delay of {} and {Time Delay2}";
|
result = delay.GetFormattedName();
|
Assert.AreEqual(result, delay.Name);
|
delay.Name = "Delay of {{}} and {{Time Delay2}}";
|
result = delay.GetFormattedName();
|
Assert.AreEqual(result, delay.Name);
|
delay.Name = "Delay of {{}} and {{Time Delay}}";
|
result = delay.GetFormattedName();
|
Assert.AreEqual(result, "Delay of {{}} and {1 s}");
|
DialogStep diag = new DialogStep();
|
diag.Name = "Timeout of {Timeout Timeout}";
|
diag.Timeout = 2;
|
var result2 = diag.GetFormattedName();
|
Assert.AreEqual(result2, "Timeout of 2 s");
|
|
SCPIRegexStep scpiRegex = new SCPIRegexStep();
|
scpiRegex.RegularExpressionPattern = new Enabled<string> { Value = "asd", IsEnabled = true };
|
scpiRegex.Name = "|{Set Verdict Regular Expression}|";
|
var result3 = scpiRegex.GetFormattedName();
|
Assert.AreEqual(result3, "|asd|");
|
|
scpiRegex.Instrument = null;
|
scpiRegex.Name = "|{Instrument}|";
|
var result4 = scpiRegex.GetFormattedName();
|
Assert.AreEqual(result4, "|Not Set|");
|
|
scpiRegex.Name = "|{asdwasd}|";
|
var result5 = scpiRegex.GetFormattedName();
|
Assert.AreEqual(result5, scpiRegex.Name);
|
|
var arrayStep = new NullArrayTest() { TestArray = new int[] { 1, 3 } };
|
arrayStep.Name = "{TestArray}";
|
var result6 = arrayStep.GetFormattedName();
|
Assert.AreEqual(result6, "1, 3");
|
|
var funkyArray = new FunkyArrayStep();
|
funkyArray.Name = "{Array}";
|
var result7 = funkyArray.GetFormattedName();
|
Assert.AreEqual(result7.Count(x => x == ','), funkyArray.Array.Length - 1);
|
Assert.IsTrue(result7.Contains(", Test"));
|
|
var sweep = new SweepParameterStep();
|
// Sweep {Parameters} -> 'Sweep' when parameters is empty.
|
Assert.AreEqual("Sweep", sweep.GetFormattedName());
|
|
}
|
finally
|
{
|
System.Threading.Thread.CurrentThread.CurrentCulture = culture;
|
}
|
}
|
|
[Test]
|
public void TestNameFormat2()
|
{
|
var plan = new TestPlan();
|
var repeat = new RepeatStep { Count = 10, Action = RepeatStep.RepeatStepAction.Fixed_Count};
|
repeat.Name = "Repeat : {Iteration}";
|
plan.ChildTestSteps.Add(repeat);
|
var logStep = new LogStep();
|
repeat.ChildTestSteps.Add(logStep);
|
var log = new TestTraceListener();
|
|
Log.AddListener(log);
|
var run = plan.Execute();
|
Assert.AreEqual(Verdict.NotSet, run.Verdict);
|
Log.RemoveListener(log);
|
var thelog = log.GetLog();
|
|
for (int i = 0; i < repeat.Count; i++)
|
{
|
var str = string.Format("Repeat : {0} of {1}", i, repeat.Count);
|
Assert.IsTrue(thelog.Contains(str));
|
}
|
}
|
|
[Test]
|
public void TestNameFormat3()
|
{
|
var step = new VerdictStep() {Name = "Delay: {Resulting Verdict}", VerdictOutput = Verdict.NotSet};
|
var fmt = step.GetFormattedName();
|
Assert.AreEqual("Delay: Not Set", fmt);
|
}
|
|
[TestCase(Verdict.Pass)]
|
[TestCase(Verdict.Fail)]
|
[TestCase(Verdict.Error)]
|
[TestCase(Verdict.Inconclusive)]
|
[TestCase(Verdict.NotSet)]
|
public void BasicVerdictTest(Verdict verdict)
|
{
|
var plan = new TestPlan();
|
var step = new VerdictStep()
|
{
|
VerdictOutput = verdict
|
};
|
var seq = new SequenceStep();
|
plan.ChildTestSteps.Add(seq);
|
|
seq.ChildTestSteps.Add(step);
|
var run = plan.Execute();
|
Assert.AreEqual(verdict, run.Verdict);
|
}
|
|
[Test]
|
public void UpgradeVerdictRaceCondition()
|
{
|
var plan = new TestPlan();
|
var failStep = new VerdictStep()
|
{
|
VerdictOutput = Verdict.Fail
|
};
|
|
var parallel = new ParallelStep();
|
parallel.ChildTestSteps.AddRange(new []{failStep});
|
for (int i = 0; i < 20; i++)
|
{
|
var passStep = new VerdictStep
|
{
|
VerdictOutput = Verdict.Pass
|
};
|
parallel.ChildTestSteps.Add(passStep);
|
}
|
plan.ChildTestSteps.Add(parallel);
|
for (int i = 0; i < 10; i++)
|
{
|
var run = plan.Execute();
|
Assert.AreEqual(Verdict.Fail, run.Verdict);
|
}
|
}
|
|
|
[Test]
|
public void ContinueLoop()
|
{
|
var repeat = new RepeatStep() {Action = RepeatStep.RepeatStepAction.Fixed_Count};
|
|
var passStep = new VerdictStep {VerdictOutput = Verdict.Pass};
|
var ifstep = new IfStep() {Action = IfStep.IfStepAction.ContinueLoop, TargetVerdict = Verdict.Pass};
|
ifstep.InputVerdict.Property = TypeData.GetTypeData(passStep).GetMember(nameof(VerdictStep.Verdict));
|
ifstep.InputVerdict.Step = passStep;
|
var verdict2 = new VerdictStep() {VerdictOutput = Verdict.Fail};
|
repeat.ChildTestSteps.Add(passStep);
|
repeat.ChildTestSteps.Add(ifstep); // instructed to skip the last verdict step
|
repeat.ChildTestSteps.Add(verdict2); // if this step runs the plan will get the verdict 'fail'.
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(repeat);
|
var run = plan.Execute();
|
Assert.AreEqual(Verdict.Pass, run.Verdict);
|
}
|
|
[Test]
|
public void ContinueLoop2()
|
{
|
var repeat = new RepeatStep()
|
{
|
Action = RepeatStep.RepeatStepAction.Fixed_Count,
|
Count = 3
|
};
|
var sequence = new SequenceStep();
|
repeat.ChildTestSteps.Add(sequence);
|
// add some arbitrary depth to the loop.
|
var seq2 = new SequenceStep();
|
var seq3 = new SequenceStep();
|
var seq4 = new SequenceStep();
|
|
var verdict1 = new VerdictStep {VerdictOutput = Verdict.Pass};
|
var ifstep = new IfStep() {Action = IfStep.IfStepAction.ContinueLoop, TargetVerdict = Verdict.Pass};
|
ifstep.InputVerdict.Property = TypeData.GetTypeData(verdict1).GetMember(nameof(VerdictStep.Verdict));
|
ifstep.InputVerdict.Step = verdict1;
|
var failStep = new VerdictStep() {VerdictOutput = Verdict.Fail};
|
sequence.ChildTestSteps.Add(verdict1);
|
sequence.ChildTestSteps.Add(seq2);
|
seq2.ChildTestSteps.Add(seq3);
|
seq3.ChildTestSteps.Add(seq4);
|
seq4.ChildTestSteps.Add(ifstep); // instructed to skip the last verdict step
|
sequence.ChildTestSteps.Add(failStep); // if this step runs the plan will get the verdict 'fail'.
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(repeat);
|
|
var run = plan.Execute();
|
Assert.AreEqual(Verdict.Pass, run.Verdict);
|
}
|
|
class ThrowsOnValidationErrorStep : TestStep
|
{
|
public bool ValidationFails { get; set; }
|
|
public ThrowsOnValidationErrorStep()
|
{
|
Rules.Add(() => !ValidationFails, "Validation Failed", nameof(ValidationFails));
|
}
|
public override void Run()
|
{
|
ThrowOnValidationError(false);
|
UpgradeVerdict(Verdict.Pass);
|
}
|
}
|
|
[Test]
|
public void ThrowOnValidationErrorStepTest()
|
{
|
var plan = new TestPlan();
|
var step = new ThrowsOnValidationErrorStep() {ValidationFails = true};
|
plan.ChildTestSteps.Add(step);
|
|
var run = plan.Execute();
|
Assert.AreEqual(Verdict.Error, run.Verdict);
|
step.ValidationFails = false;
|
var run2 = plan.Execute();
|
Assert.AreEqual(Verdict.Pass, run2.Verdict);
|
}
|
|
[Test]
|
public void RefInstrumentDeletedTest()
|
{
|
using (Session.Create())
|
{
|
InstrumentSettings.Current.Clear();
|
var inst1 = new DummyInstrument();
|
var inst2 = new DummyReferencingInstrument
|
{
|
Other = inst1
|
};
|
InstrumentSettings.Current.AddRange([inst1, inst2]);
|
|
InstrumentSettings.Current.Remove(inst1);
|
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(new AnnotationTest.InstrumentStep {Instrument = inst2});
|
var r = plan.Execute();
|
Assert.IsTrue(r.FailedToStart);
|
|
var xml = new TapSerializer().SerializeToString(InstrumentSettings.Current);
|
var inst3 = (new TapSerializer().DeserializeFromString(xml) as InstrumentSettings)[0] as DummyReferencingInstrument;
|
Assert.IsNull(inst3.Other);
|
}
|
}
|
|
|
}
|
|
public class FormattedNameTests
|
{
|
public class TestNameFormat1
|
{
|
const string testStepName = "Enabled Check Boxes";
|
private EnabledFormattedNameTest step;
|
|
[Test]
|
public void TestNameEnabledType()
|
{
|
step = new EnabledFormattedNameTest();
|
AssertFormatName("{Checked Bool}", "False");
|
AssertFormatName("{Checked Bool Array}", "False, True");
|
AssertFormatName("{Checked Double}", "3.21");
|
AssertFormatName("{Checked Double Array}", "3.33, 45.6, 88.8");
|
AssertFormatName("{Checked String}", "Some comment");
|
AssertFormatName("{Checked String Array}", "abc, DEF, GhI");
|
AssertFormatName("{Checked String List}", "One, Two, Three");
|
AssertFormatName("{Checked Instrument}", "NULL");
|
|
//Uncheck a property
|
step.CheckedBoolArray.IsEnabled = false;
|
AssertFormatName("{Checked Bool Array}", "False, True (disabled)");
|
|
//Remove all value of the properties
|
step.CheckedDoubleArray.Value = new double[] { };
|
AssertFormatName("{Checked Double Array}", "");
|
|
step.CheckedDoubleArray.IsEnabled = false;
|
AssertFormatName("{Checked Double Array}", " (disabled)");
|
|
step.CheckedStringArray.Value = null;
|
AssertFormatName("{Checked String Array}", "NULL");
|
}
|
|
private void AssertFormatName(string formatName, string expectedOutput)
|
{
|
step.Name = testStepName + " " + formatName;
|
var result = step.GetFormattedName();
|
Assert.AreEqual((testStepName + " " + expectedOutput).TrimEnd(), result);
|
}
|
}
|
|
public class TestNameFormat2
|
{
|
const string testStepName = "Handle Input";
|
private HandleInputStep inputStep;
|
|
[Test]
|
public void TestNameInputOutputType()
|
{
|
GenerateOutputStep outputStep = new GenerateOutputStep();
|
inputStep = new HandleInputStep();
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(outputStep);
|
plan.ChildTestSteps.Add(inputStep);
|
|
var annotation = AnnotationCollection.Annotate(inputStep);
|
var inputAnnotation = annotation.GetMember(nameof(HandleInputStep.InputBoolArray));
|
SetOutputProperty(inputAnnotation);
|
inputAnnotation = annotation.GetMember(nameof(HandleInputStep.InputDouble));
|
SetOutputProperty(inputAnnotation);
|
inputAnnotation = annotation.GetMember(nameof(HandleInputStep.InputDoubleArray));
|
SetOutputProperty(inputAnnotation);
|
inputAnnotation = annotation.GetMember(nameof(HandleInputStep.InputString));
|
SetOutputProperty(inputAnnotation);
|
inputAnnotation = annotation.GetMember(nameof(HandleInputStep.InputStringArray));
|
SetOutputProperty(inputAnnotation);
|
inputAnnotation = annotation.GetMember(nameof(HandleInputStep.InputStringList));
|
SetOutputProperty(inputAnnotation);
|
|
annotation.Write(inputStep);
|
|
|
AssertFormatName("{Input Bool Array}", "False, True");
|
AssertFormatName("{Input Double}", "1");
|
AssertFormatName("{Input Double Array}", "1, 2.2");
|
AssertFormatName("{Input String}", "Something");
|
AssertFormatName("{Input String Array}", "tom, dick");
|
AssertFormatName("{Input String List}", "One, Two, Three");
|
}
|
|
|
private void SetOutputProperty(AnnotationCollection inputAnnotation)
|
{
|
var avail = inputAnnotation.Get<IAvailableValuesAnnotation>();
|
var setVal = avail as IAvailableValuesSelectedAnnotation;
|
var options = avail.AvailableValues.Cast<object>().ToArray();
|
|
setVal.SelectedValue = options[1];
|
}
|
|
private void AssertFormatName(string formatName, string expectedOutput)
|
{
|
inputStep.Name = testStepName + " " + formatName;
|
var result = inputStep.GetFormattedName();
|
Assert.AreEqual(result, testStepName + " " + expectedOutput);
|
}
|
}
|
}
|
}
|
