// 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.Threading;
|
using OpenTap.Plugins.BasicSteps;
|
using NUnit.Framework;
|
using OpenTap.Engine.UnitTests.TestTestSteps;
|
|
namespace OpenTap.Engine.UnitTests
|
{
|
public class ReadInputStep : TestStep
|
{
|
public Input<double> Input { get; set; } = new Input<double>();
|
|
public override void Run()
|
{
|
Log.Debug("Input Value: {0}", Input.Value);
|
}
|
}
|
|
[TestFixture]
|
public class InputTest
|
{
|
[Test]
|
public void InputBasicTests()
|
{
|
var prop = TypeData.FromType(typeof(DelayStep)).GetMember(nameof(DelayStep.DelaySecs));
|
DelayStep delay = new DelayStep();
|
Input<double> secs = new Input<double>() { Step = delay, Property = prop};
|
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(delay);
|
|
delay.DelaySecs = 2;
|
Assert.AreEqual(secs.Value, delay.DelaySecs);
|
|
Input<double> secs2 = new Input<double>() { Step = delay, Property = prop };
|
Assert.AreEqual(secs, secs2);
|
|
Input<double> secs3 = new Input<double>() { Step = delay, Property = null };
|
Input<double> secs4 = new Input<double>() { Step = null, Property = prop };
|
Input<double> secs5 = new Input<double>() { Step = null, Property = null };
|
Input<double> secs6 = new Input<double>() { Step = delay, PropertyName = prop.Name};
|
Assert.IsFalse(secs3 == secs4);
|
Assert.IsFalse(secs4 == secs5);
|
Assert.IsFalse(secs3 == secs5);
|
Assert.IsTrue(secs == secs2);
|
Assert.IsTrue(secs == secs6);
|
|
{ // test serialize
|
plan.ChildTestSteps.Add(new ReadInputStep() { Input = secs });
|
|
var planxml = new TapSerializer().SerializeToString(plan);
|
TestPlan plan2 = (TestPlan)new TapSerializer().DeserializeFromString(planxml);
|
var step2 = plan2.ChildTestSteps[1] as ReadInputStep;
|
Assert.IsTrue(step2.Input.Step == plan2.ChildTestSteps[0]);
|
}
|
}
|
|
[Test]
|
public void NullInputTest()
|
{
|
Input<double> a = null;
|
Input<double> b = null;
|
Assert.IsTrue(a == b);
|
a = new Input<double>(){};
|
Assert.IsTrue(a != b);
|
b = new Input<double>(){};
|
|
var prop = TypeData.FromType(typeof(DelayStep)).GetMember(nameof(DelayStep.DelaySecs));
|
DelayStep delay = new DelayStep();
|
|
Assert.IsTrue(a == b);
|
a.Step = delay;
|
a.Property = prop;
|
Assert.IsTrue(a != b);
|
b.Step = delay;
|
b.Property = prop;
|
Assert.IsTrue(a == b);
|
}
|
|
[Test]
|
public void DeletedInputTest()
|
{
|
var plan = new TestPlan();
|
var delayStep = new DelayStep();
|
var ifStep = new IfStep();
|
plan.ChildTestSteps.AddRange([delayStep, ifStep]);
|
|
var a = AnnotationCollection.Annotate(ifStep);
|
var mem = a.GetMember(nameof(ifStep.InputVerdict));
|
var sv = mem.Get<IStringReadOnlyValueAnnotation>();
|
|
{
|
// Verify the value is initally not set
|
Assert.That(sv.Value, Is.EqualTo("None"));
|
Assert.That(ifStep.InputVerdict.ToString(), Is.EqualTo("NotSet"));
|
}
|
{
|
// Verify that the string value is updated
|
ifStep.InputVerdict.Step = delayStep;
|
ifStep.InputVerdict.Property = TypeData.GetTypeData(delayStep).GetMember(nameof(delayStep.Verdict));
|
a.Read();
|
Assert.That(sv.Value, Is.EqualTo("Verdict from Delay"));
|
Assert.That(ifStep.InputVerdict.ToString(), Is.EqualTo("NotSet"));
|
}
|
{
|
// Delete the target step from the test plan and verify the string value is unset
|
plan.ChildTestSteps.Remove(delayStep);
|
a.Read();
|
Assert.That(sv.Value, Is.EqualTo("None"));
|
Assert.That(ifStep.InputVerdict.ToString(), Is.EqualTo("NotSet"));
|
}
|
}
|
|
[Test]
|
public void TestSerializeInput()
|
{
|
var step = new HandleInputStep();
|
var plan = new TestPlan();
|
plan.Steps.Add(step);
|
var s = new TapSerializer();
|
var xml = s.SerializeToString(plan);
|
Assert.IsFalse(s.Errors.Any());
|
var deserialized = s.DeserializeFromString(xml);
|
Assert.IsFalse(s.Errors.Any());
|
}
|
|
[Test]
|
public void UnconfiguredInputToStringTest()
|
{
|
var x = new Input<string>();
|
Assert.DoesNotThrow(() => x.ToString());
|
Assert.AreEqual("", x.ToString());
|
}
|
|
/// <summary>
|
/// OpenTAP issue: #666
|
/// </summary>
|
[Test]
|
public void ParallelIfVerdict()
|
{
|
var plan = new TestPlan();
|
var par = new ParallelStep();
|
var seq = new SequenceStep();
|
var del1 = new DelayStep {DelaySecs = 0};
|
var ifVerdict = new IfStep();
|
var del2 = new DelayStep {DelaySecs = 0};
|
|
plan.Steps.Add(par);
|
par.ChildTestSteps.Add(seq);
|
seq.ChildTestSteps.Add(del1);
|
del1.Enabled = false;
|
seq.ChildTestSteps.Add(ifVerdict);
|
ifVerdict.ChildTestSteps.Add(del2);
|
|
ifVerdict.InputVerdict.Step = del1;
|
ifVerdict.InputVerdict.Property = TypeData.GetTypeData(del1).GetMember(nameof(del1.Verdict));
|
|
var cancel = new CancellationTokenSource();
|
var trd = TapThread.StartAwaitable(() =>
|
{
|
var r = plan.Execute();
|
Assert.AreEqual(Verdict.NotSet, r.Verdict);
|
}, cancel.Token);
|
if (!trd.Wait(TimeSpan.FromMinutes(2)))
|
{
|
cancel.Cancel();
|
Assert.Fail("Test timed out");
|
}
|
}
|
|
[TestCase(1)]
|
[TestCase(2)]
|
[TestCase(10)]
|
public void ParallelIfVerdictDeadlock(int n)
|
{
|
var plan = new TestPlan();
|
ParallelStep parallelStep = new ParallelStep();
|
plan.Steps.Add(parallelStep);
|
for (int i = 1; i < n; i++)
|
{
|
var step = new ParallelStep();
|
parallelStep.ChildTestSteps.Add(step);
|
parallelStep = step;
|
}
|
var ifVerdictStep = new IfStep();
|
parallelStep.ChildTestSteps.Add(ifVerdictStep);
|
ifVerdictStep.InputVerdict.Step = parallelStep;
|
ifVerdictStep.InputVerdict.Property = TypeData.GetTypeData(parallelStep).GetMember(nameof(parallelStep.Verdict));
|
|
Assert.AreEqual(plan.Execute().Verdict, Verdict.Error);
|
}
|
|
[Test]
|
public void MovingStepWithInputTest()
|
{
|
var plan = new TestPlan();
|
var ifVerdict = new IfStep
|
{
|
};
|
var ifVerdict2 = new IfStep{};
|
plan.ChildTestSteps.Add(ifVerdict);
|
plan.ChildTestSteps.Add(ifVerdict2);
|
ifVerdict2.InputVerdict.Step = ifVerdict;
|
ifVerdict2.InputVerdict.Step = null;
|
plan.ChildTestSteps.Remove(ifVerdict);
|
plan.ChildTestSteps.Insert(0, ifVerdict);
|
|
// this should still be null, but was not because of a (fixed) bug.
|
Assert.IsNull(ifVerdict2.InputVerdict.Step);
|
}
|
|
[Test]
|
public void RepeatVerdictTest()
|
{
|
var plan = new TestPlan();
|
var repeat0 = new RepeatStep { Count = 2 };
|
var repeat = new RepeatStep { Count = 2 };
|
var delay = new DelayStep();
|
var ifVerdict = new IfStep
|
{
|
Action = IfStep.IfStepAction.RunChildren,
|
InputVerdict =
|
{
|
Step = delay, Property = TypeData.GetTypeData(delay).GetMember(nameof(delay.Verdict))
|
}
|
};
|
var setVerdict = new VerdictStep() {VerdictOutput = Verdict.Pass};
|
plan.ChildTestSteps.Add(repeat0);
|
repeat0.ChildTestSteps.Add(repeat);
|
repeat0.ChildTestSteps.Add(ifVerdict);
|
repeat.ChildTestSteps.Add(delay);
|
ifVerdict.ChildTestSteps.Add(setVerdict);
|
|
var run = plan.Execute();
|
Assert.AreEqual(Verdict.Pass, run.Verdict);
|
}
|
|
[Test]
|
public void AssignOutputDialogWithPlan()
|
{
|
var plan = new TestPlan();
|
var selectedOutputItem = AssignOutputDialog.SelectedOutputItem.Create(plan, TypeData.GetTypeData(plan).GetMembers().First());
|
Assert.DoesNotThrow(() => selectedOutputItem.ToString());
|
}
|
}
|
|
[AllowAnyChild]
|
public class OutputParentStep : TestStep
|
{
|
[Output]
|
public double OutputValue { get; set; }
|
|
public override void Run()
|
{
|
RunChildSteps();
|
}
|
}
|
|
public class GenerateOutputStep : TestStep
|
{
|
[Output]
|
public bool[] OutputBoolArray { get; private set; }
|
[Output]
|
public double OutputDouble { get; private set; }
|
[Output]
|
public double[] OutputDoubleArray { get; private set; }
|
[Output]
|
public string OutputString { get; private set; }
|
[Output]
|
public string[] OutputStringArray { get; private set; }
|
[Output]
|
public List<string> OutputStringList { get; private set; }
|
|
public GenerateOutputStep()
|
{
|
OutputBoolArray = new bool[] { false, true };
|
OutputDouble = 1.0;
|
OutputDoubleArray = new double[] { 1.0, 2.2 };
|
OutputString = "Something";
|
OutputStringArray = new string[] { "tom", "dick" };
|
OutputStringList = new List<string> { "One", "Two", "Three" };
|
}
|
|
public override void Run()
|
{
|
|
}
|
}
|
|
[Display("Handle Input")]
|
public class HandleInputStep : TestStep
|
{
|
[Display("Input Bool Array")]
|
public Input<bool[]> InputBoolArray { get; set; }
|
[Display("Input Double")]
|
public Input<double> InputDouble { get; set; }
|
[Display("Input Double Array")]
|
public Input<double[]> InputDoubleArray { get; set; }
|
[Display("Input String")]
|
public Input<string> InputString { get; set; }
|
[Display("Input String Array")]
|
public Input<string[]> InputStringArray { get; set; }
|
[Display("Input String List")]
|
public Input<List<string>> InputStringList { get; set; }
|
|
public HandleInputStep()
|
{
|
InputDouble = new Input<double>();
|
InputDoubleArray = new Input<double[]>();
|
InputBoolArray = new Input<bool[]>();
|
InputString = new Input<string>();
|
InputStringArray = new Input<string[]>();
|
InputStringList = new Input<List<string>>();
|
}
|
|
public override void Run()
|
{
|
throw new NotImplementedException();
|
}
|
}
|
}
|
