// 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 NUnit.Framework;
|
using OpenTap.EngineUnitTestUtils;
|
|
namespace OpenTap.Engine.UnitTests
|
{
|
[TestFixture]
|
public class ResourceDependencyTests
|
{
|
public interface ICircDummyInst : IInstrument
|
{
|
void DoTest();
|
}
|
|
public class CircDummyInst : Instrument, ICircDummyInst
|
{
|
public Enabled<IInstrument> inst { get; set; }
|
|
[ResourceOpen(ResourceOpenBehavior.InParallel)]
|
public Enabled<IInstrument> instWeak { get; set; }
|
|
public CircDummyInst()
|
{
|
inst = new Enabled<IInstrument>();
|
instWeak = new Enabled<IInstrument>();
|
}
|
|
public void DoTest()
|
{
|
if (inst.IsEnabled) Assert.IsTrue(inst.Value.IsConnected);
|
if (instWeak.IsEnabled) Assert.IsTrue(instWeak.Value.IsConnected);
|
}
|
|
public override void Open()
|
{
|
base.Open();
|
if (inst.IsEnabled) Assert.IsTrue(inst.Value.IsConnected);
|
}
|
|
public override void Close()
|
{
|
if (inst.IsEnabled) Assert.IsTrue(inst.Value.IsConnected);
|
base.Close();
|
}
|
}
|
|
public class CircTestStep : TestStep
|
{
|
public ICircDummyInst Instrument { get; set; }
|
|
public override void Run()
|
{
|
Instrument.DoTest();
|
}
|
}
|
|
public class CircInst : Instrument, ICircDummyInst
|
{
|
// verify that there is no issue with parameters and circular references.
|
[MetaData]
|
public string ID { get; set; } = Guid.NewGuid().ToString();
|
|
public bool Parallel { get; set; }
|
[EnabledIf(nameof(Parallel), false)]
|
public IInstrument Instrument => inst;
|
|
|
[EnabledIf(nameof(Parallel), true)]
|
[ResourceOpen(ResourceOpenBehavior.InParallel)]
|
public IInstrument Instrumentp => inst;
|
|
public IInstrument inst;
|
|
public void DoTest()
|
{
|
Assert.IsTrue(inst.IsConnected);
|
}
|
|
public override void Open()
|
{
|
base.Open();
|
if(!Parallel)
|
Assert.IsTrue(inst.IsConnected);
|
}
|
|
public override void Close()
|
{
|
if(!Parallel)
|
Assert.IsTrue(inst.IsConnected);
|
base.Close();
|
}
|
}
|
|
// when the instruments are opened in parallel, the circular resource reference should not be a problem
|
// when the instruments are not opened in the parallel, it means that the order of open/close cannot be determined.
|
[TestCase(true)]
|
[TestCase(false)]
|
public void CircularResourceReference(bool parallel)
|
{
|
EngineSettings.Current.ResourceManagerType = new ResourceTaskManager();
|
InstrumentSettings.Current.Clear();
|
try
|
{
|
var inst0 = new CircInst {Parallel = parallel};
|
var inst1 = new CircInst {Parallel = parallel};
|
var inst2 = new CircInst {Parallel = parallel};
|
|
inst0.inst = inst2;
|
inst1.inst = inst0;
|
inst2.inst = inst1;
|
|
InstrumentSettings.Current.AddRange([inst0, inst1, inst2]);
|
|
TestPlan plan = new TestPlan();
|
var step1 = new CircTestStep() { Instrument = inst0 };
|
|
plan.ChildTestSteps.Add(step1);
|
|
var planRun = plan.Execute();
|
|
Assert.AreEqual(parallel ? Verdict.NotSet : Verdict.Error, planRun.Verdict);
|
}
|
finally
|
{
|
InstrumentSettings.Current.Clear();
|
}
|
}
|
|
[Test]
|
public void LostReferenceStep()
|
{
|
using (Session.Create(SessionOptions.OverlayComponentSettings))
|
{
|
var inst1 = new CircInst();
|
var inst2 = new DummyInstrument();
|
inst1.inst = inst2;
|
|
InstrumentSettings.Current.Clear();
|
InstrumentSettings.Current.Add(inst1);
|
InstrumentSettings.Current.Add(inst2);
|
|
TestPlan plan = new TestPlan();
|
var step1 = new CircTestStep {Instrument = inst1};
|
plan.ChildTestSteps.Add(step1);
|
{
|
var planRun = plan.Execute();
|
Assert.AreEqual(Verdict.NotSet, actual: planRun.Verdict);
|
}
|
InstrumentSettings.Current.Remove(inst2);
|
{
|
// this should now fail because a inner reference resource has been removed.
|
var planRun = plan.Execute();
|
var ex = planRun.Exception;
|
Assert.AreEqual(Verdict.Error, actual: planRun.Verdict);
|
Assert.IsNotNull(ex);
|
Assert.IsFalse(ex is NullReferenceException);
|
}
|
}
|
}
|
|
[Test]
|
public void CircularResource2Reference()
|
{
|
EngineSettings.Current.ResourceManagerType = new ResourceTaskManager();
|
InstrumentSettings.Current.Clear();
|
try
|
{
|
var inst0 = new CircInst();
|
InstrumentSettings.Current.Add(inst0);
|
inst0.inst = InstrumentSettings.Current[0];
|
|
TestPlan plan = new TestPlan();
|
var step1 = new CircTestStep() { Instrument = inst0 };
|
|
plan.ChildTestSteps.Add(step1);
|
|
var planRun = plan.Execute();
|
Assert.AreEqual(Verdict.Error, planRun.Verdict);
|
}
|
finally
|
{
|
InstrumentSettings.Current.Clear();
|
}
|
}
|
|
[Test]
|
public void DependentResourceNull()
|
{
|
EngineSettings.Current.ResourceManagerType = new ResourceTaskManager();
|
InstrumentSettings.Current.Clear();
|
try
|
{
|
var inst0 = new CircInst();
|
InstrumentSettings.Current.Add(inst0);
|
InstrumentSettings.Current.Add(new CircInst { inst = null });
|
InstrumentSettings.Current.Add(new CircInst { inst = InstrumentSettings.Current[1] });
|
inst0.inst = InstrumentSettings.Current[2];
|
|
TestPlan plan = new TestPlan();
|
var step1 = new CircTestStep() { Instrument = inst0 };
|
|
plan.ChildTestSteps.Add(step1);
|
|
var planRun = plan.Execute();
|
Assert.IsTrue(planRun.FailedToStart);
|
Assert.AreEqual(Verdict.Error, planRun.Verdict);
|
}
|
finally
|
{
|
InstrumentSettings.Current.Clear();
|
}
|
}
|
|
[Test]
|
public void DependentEnabledTest()
|
{
|
InstrumentSettings.Current.Clear();
|
try
|
{
|
var inst0 = new CircDummyInst();
|
var inst1 = new CircDummyInst();
|
var inst2 = new CircDummyInst();
|
|
inst0.instWeak.Value = inst1;
|
inst0.instWeak.IsEnabled = true;
|
|
inst0.inst.Value = inst2;
|
inst0.inst.IsEnabled = true;
|
|
inst1.instWeak.Value = inst2;
|
inst1.instWeak.IsEnabled = true;
|
|
InstrumentSettings.Current.Add(inst0);
|
InstrumentSettings.Current.Add(inst1);
|
InstrumentSettings.Current.Add(inst2);
|
|
var listener = new EngineUnitTestUtils.TestTraceListener();
|
Log.AddListener(listener);
|
|
TestPlan plan = new TestPlan();
|
plan.ChildTestSteps.Add(new CircTestStep() { Instrument = inst0 });
|
plan.ChildTestSteps.Add(new CircTestStep() { Instrument = inst1 });
|
plan.ChildTestSteps.Add(new CircTestStep() { Instrument = inst2 });
|
|
var planRun = plan.Execute();
|
|
Log.RemoveListener(listener);
|
|
Assert.IsFalse(planRun.FailedToStart, listener.GetLog());
|
Assert.AreEqual(Verdict.NotSet, planRun.Verdict);
|
}
|
finally
|
{
|
InstrumentSettings.Current.Clear();
|
}
|
}
|
|
public class ResourceStep : TestStep, IResource
|
{
|
public IResource Inst { get; set; }
|
|
public bool IsConnected { get; private set; }
|
|
public void Close()
|
{
|
Assert.IsTrue(Inst.IsConnected);
|
|
IsConnected = false;
|
}
|
|
public void Open()
|
{
|
Assert.IsTrue(Inst.IsConnected);
|
|
IsConnected = true;
|
}
|
|
public override void Run()
|
{
|
Assert.IsTrue(Inst.IsConnected);
|
Assert.IsTrue(IsConnected);
|
}
|
}
|
|
[Test]
|
public void ResourceStepTest()
|
{
|
using (Session.Create(SessionOptions.OverlayComponentSettings))
|
{
|
InstrumentSettings.Current.Add(new CircDummyInst());
|
|
var tp = new TestPlan();
|
tp.ChildTestSteps.Add(new ResourceStep() {Inst = InstrumentSettings.Current[0]});
|
|
var run = tp.Execute();
|
|
Assert.AreEqual(1, run.StepsWithPrePlanRun.Count);
|
Assert.IsFalse(run.FailedToStart);
|
}
|
}
|
|
[Test]
|
public void ResourceStepRefTest()
|
{
|
using (Session.Create(0))
|
{
|
InstrumentSettings.Current.Add(new CircDummyInst());
|
|
var step1 = new ResourceStep() {Inst = InstrumentSettings.Current[0]};
|
var step2 = new ResourceStep() {Inst = step1};
|
|
var tp = new TestPlan();
|
tp.ChildTestSteps.Add(step1);
|
tp.ChildTestSteps.Add(step2);
|
|
var run = tp.Execute();
|
|
Assert.AreEqual(2, run.StepsWithPrePlanRun.Count);
|
Assert.IsFalse(run.FailedToStart);
|
}
|
}
|
|
public class IgnoredResourceStep : TestStep
|
{
|
[ResourceOpen(ResourceOpenBehavior.Ignore)]
|
public IInstrument resource { get; set; }
|
|
public override void Run()
|
{
|
UpgradeVerdict(resource.IsConnected ? Verdict.Fail : Verdict.Pass);
|
}
|
}
|
|
[Test]
|
public void IgnoredResource()
|
{
|
InstrumentSettings.Current.Clear();
|
ResultSettings.Current.Clear();
|
|
var inst = new CircDummyInst();
|
InstrumentSettings.Current.Add(inst);
|
var listener = new EngineUnitTestUtils.TestTraceListener();
|
Log.AddListener(listener);
|
var tp = new TestPlan();
|
tp.ChildTestSteps.Add(new IgnoredResourceStep() { resource = inst });
|
var run = tp.Execute();
|
Log.RemoveListener(listener);
|
|
Assert.IsFalse(run.FailedToStart);
|
Assert.AreEqual(1, run.StepsWithPrePlanRun.Count);
|
Assert.AreEqual(Verdict.Pass, run.Verdict, listener.GetLog());
|
}
|
|
[Test]
|
public void TestMethodResourceSettingNullReference()
|
{
|
TestTraceListener tapTraceListener = new TestTraceListener();
|
DummyDut device = new DummyDut();
|
try
|
{
|
Log.AddListener(tapTraceListener);
|
DutSettings.Current.Add(device);
|
|
// this works
|
var testPlan = new TestPlan();
|
var step = new DummyInstrumentAndDutStep() { Device = device, Instrument = null };
|
testPlan.ChildTestSteps.Add(step);
|
var run = testPlan.Execute();
|
|
Assert.AreEqual(Verdict.Error, run.Verdict);
|
tapTraceListener.ExpectWarnings("TestPlan aborted.");
|
tapTraceListener.ExpectErrors(
|
$"Resource setting {nameof(DummyInstrumentAndDutStep.Instrument)} not set on step {nameof(DummyInstrumentAndDutStep)}. Please configure or disable step.");
|
}
|
finally
|
{
|
tapTraceListener.Flush();
|
Log.RemoveListener(tapTraceListener);
|
DutSettings.Current.Remove(device);
|
}
|
}
|
|
public class DummyInstrumentAndDutStep : TestStep
|
{
|
public DummyDut Device { get; set; }
|
public DummyInstrument Instrument { get; set; }
|
|
public override void Run()
|
{
|
}
|
}
|
|
public class SelfHiddenCyclicResource : Instrument
|
{
|
public object Self => this;
|
}
|
|
public class SelfHiddenCyclicResourceTestStep : TestStep
|
{
|
public SelfHiddenCyclicResource Resource { get; set; }
|
|
public override void Run()
|
{
|
UpgradeVerdict(Verdict.Pass);
|
}
|
}
|
|
[Test]
|
public void SelfHiddenCyclicResourceTest()
|
{
|
var step = new SelfHiddenCyclicResourceTestStep
|
{Resource = new SelfHiddenCyclicResource()};
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(step);
|
var run = plan.Execute();
|
Assert.AreEqual(Verdict.Pass, run.Verdict);
|
}
|
|
}
|
}
|
