// 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.ComponentModel;
|
using NUnit.Framework;
|
using System.IO;
|
using System.Linq;
|
|
namespace OpenTap.Engine.UnitTests
|
{
|
[TestFixture]
|
public class UserCodeTest
|
{
|
[Test]
|
public void ResultListeners()
|
{
|
resultListenerCrash[] crashers = new resultListenerCrash[]{
|
new resultListenerCrash{CrashResultPhase = resultListenerCrash.ResultPhase.PlanRunStart},
|
new resultListenerCrash{CrashResultPhase = resultListenerCrash.ResultPhase.StepRunStart},
|
new resultListenerCrash{CrashResultPhase = resultListenerCrash.ResultPhase.Result},
|
new resultListenerCrash{CrashResultPhase = resultListenerCrash.ResultPhase.StepRunCompleted},
|
new resultListenerCrash{CrashResultPhase = resultListenerCrash.ResultPhase.PlanRunCompleted},
|
new resultListenerCrash{CrashResultPhase = resultListenerCrash.ResultPhase.Open},
|
new resultListenerCrash{CrashResultPhase = resultListenerCrash.ResultPhase.Close}
|
};
|
|
TestPlan testplan = new TestPlan();
|
testplan.Steps.Add(new TestStepTest());
|
foreach (var crasher in crashers)
|
{
|
testplan.Execute(new IResultListener[] { crasher });
|
}
|
}
|
|
[Test]
|
[Ignore("Since the result thread is not synced with the test plan thread, the test plan might complete before the abort is used from the result listeners.")]
|
public void ResultListenerAbortPlan()
|
{
|
// since the
|
|
resultListenerCrash[] crashers = new resultListenerCrash[]{
|
new resultListenerCrash{CrashResultPhase = resultListenerCrash.ResultPhase.PlanRunStart, AbortPlan = true},
|
new resultListenerCrash{CrashResultPhase = resultListenerCrash.ResultPhase.StepRunStart, AbortPlan = true},
|
new resultListenerCrash{CrashResultPhase = resultListenerCrash.ResultPhase.Result, AbortPlan = true},
|
new resultListenerCrash{CrashResultPhase = resultListenerCrash.ResultPhase.StepRunCompleted, AbortPlan = true},
|
// The plan cannot be aborted on PlanRunCompleted. The at that point it will be ignored.
|
new resultListenerCrash{CrashResultPhase = resultListenerCrash.ResultPhase.PlanRunCompleted, AbortPlan = true}
|
};
|
|
TestPlan testplan = new TestPlan();
|
testplan.Steps.Add(new TestStepTest());
|
foreach (var c in crashers)
|
{
|
c.FinalVerdict = Verdict.NotSet;
|
var expectedVerdict = Verdict.Aborted;
|
|
if (c.CrashResultPhase != resultListenerCrash.ResultPhase.PlanRunStart)
|
expectedVerdict = Verdict.Pass;
|
|
// Simply running the plan.
|
var planrun = testplan.Execute(new IResultListener[] { c });
|
Assert.AreEqual(expectedVerdict, planrun.Verdict);
|
Assert.AreEqual(expectedVerdict, c.FinalVerdict);
|
|
// Test that it works in composite runs.
|
// Here it's important that the abort does not spill into the next run.
|
// Which is why the plan is run twice.
|
testplan.Open(new IResultListener[] { c });
|
c.FinalVerdict = Verdict.NotSet;
|
Assert.AreEqual(expectedVerdict, testplan.Execute(new IResultListener[] { c }).Verdict);
|
Assert.AreEqual(expectedVerdict, c.FinalVerdict);
|
c.CrashResultPhase = resultListenerCrash.ResultPhase.None;
|
c.FinalVerdict = Verdict.NotSet;
|
Assert.AreEqual(Verdict.Pass, testplan.Execute(new IResultListener[] { c }).Verdict);
|
Assert.AreEqual(Verdict.Pass, c.FinalVerdict);
|
testplan.Close();
|
}
|
|
|
}
|
|
|
[Test]
|
public void VersionProperties()
|
{
|
TestPlan tp = new TestPlan();
|
tp.ChildTestSteps.Add(new Plugins.BasicSteps.DelayStep());
|
var tpr = tp.Execute();
|
|
Assert.IsTrue(tpr.Parameters.Any(p => p.Group == "Version" && p.Name == "OpenTap"), "No engine version parameter found");
|
}
|
|
[Test]
|
public void InstrumentTestMethod()
|
{
|
InstrumentTest openCrash = new InstrumentTest { CrashPhase = InstrumentTest.InstrPhase.Open };
|
InstrumentTest closeCrash = new InstrumentTest { CrashPhase = InstrumentTest.InstrPhase.Close };
|
foreach (var instr in new IInstrument[] { openCrash, closeCrash })
|
{
|
InstrumentTestStep step = new InstrumentTestStep { Instrument = instr };
|
TestPlan plan = new TestPlan();
|
plan.Steps.Add(step);
|
plan.Execute();
|
}
|
}
|
|
[Test]
|
public void DutInheritingFromIDut()
|
{
|
try
|
{
|
var dut = new InterfaceTestDut();
|
DutSettings setting = new DutSettings();
|
setting.Add(dut);
|
}
|
catch (Exception ex)
|
{
|
Assert.Fail("Unit test for duts inheriting from the IDut interface has trown an exception: " + ex.Message);
|
}
|
}
|
|
[Test]
|
public void ResultListenerInheritingFromIResultListener()
|
{
|
try
|
{
|
var resultListener = new InterfaceTestResultListenser();
|
var setting = new ResultSettings();
|
setting.Add(resultListener);
|
}
|
catch (Exception ex)
|
{
|
Assert.Fail("Unit test for result listener inheriting from the IResultListener interface has trown an exception: " + ex.Message);
|
}
|
}
|
|
public void InstrumentInheritingFromIInstrument()
|
{
|
try
|
{
|
var instrument = new InterfaceTestInstrument();
|
var setting = new InstrumentSettings();
|
setting.Add(instrument);
|
}
|
catch (Exception ex)
|
{
|
Assert.Fail("Unit test for instruments inheriting from the IInstrument interface has trown an exception: " + ex.Message);
|
}
|
}
|
}
|
|
public class InstrumentTestStep : TestStep
|
{
|
public IInstrument Instrument { get; set; }
|
public override void Run()
|
{
|
Assert.IsTrue(Instrument.IsConnected);
|
}
|
}
|
|
public class InstrumentTest : Instrument
|
{
|
public InstrumentTest()
|
{
|
Name = "InstrTest";
|
}
|
|
public enum InstrPhase
|
{
|
Open,
|
Close
|
}
|
|
public InstrPhase CrashPhase { get; set; }
|
|
public override void Open()
|
{
|
base.Open();
|
tryCrash(InstrPhase.Open);
|
}
|
|
public override void Close()
|
{
|
base.Close();
|
tryCrash(InstrPhase.Close);
|
}
|
|
void tryCrash(InstrPhase phase)
|
{
|
if (phase == CrashPhase)
|
{
|
throw new Exception("Intended Crash: " + phase.ToString());
|
}
|
}
|
}
|
|
[DisplayName("Test\\Crash")]
|
public class resultListenerCrash : ResultListener
|
{
|
public enum ResultPhase
|
{
|
PlanRunStart,
|
PlanRunCompleted,
|
StepRunStart,
|
StepRunCompleted,
|
Result,
|
Close,
|
Open,
|
None
|
}
|
|
public bool AbortPlan { get; set; }
|
|
public ResultPhase CrashResultPhase { get; set; }
|
public Verdict FinalVerdict { get; set; }
|
public resultListenerCrash()
|
{
|
Name = "CRSH";
|
CrashResultPhase = ResultPhase.PlanRunStart;
|
}
|
|
public override void Close()
|
{
|
base.Close();
|
if (CrashResultPhase == ResultPhase.Close)
|
{
|
throw new Exception("Intended Close Crash");
|
}
|
}
|
|
public override void Open()
|
{
|
base.Open();
|
if (CrashResultPhase == ResultPhase.Open)
|
{
|
throw new Exception("Intended Open Crash");
|
}
|
}
|
|
TestPlanRun planrun;
|
public override void OnTestPlanRunStart(TestPlanRun planRun)
|
{
|
this.planrun = planRun;
|
if (CrashResultPhase == ResultPhase.PlanRunStart)
|
{
|
if (AbortPlan)
|
TapThread.Current.Abort();
|
else
|
throw new Exception("Intended");
|
}
|
}
|
|
public override void OnTestPlanRunCompleted(TestPlanRun planRun, System.IO.Stream logStream)
|
{
|
FinalVerdict = planrun.Verdict;
|
if (CrashResultPhase == ResultPhase.PlanRunCompleted)
|
{
|
if (AbortPlan)
|
TapThread.Current.Abort();
|
else
|
throw new Exception("Intended");
|
}
|
planrun = null;
|
}
|
|
/// <summary>
|
/// Called just before a test step is started.
|
/// </summary>
|
/// <param name="stepRun"></param>
|
public override void OnTestStepRunStart(TestStepRun stepRun)
|
{
|
if (CrashResultPhase == ResultPhase.StepRunStart)
|
{
|
if (AbortPlan)
|
TapThread.Current.Abort();
|
else
|
throw new Exception("Intended");
|
}
|
}
|
|
public override void OnTestStepRunCompleted(TestStepRun stepRun)
|
{
|
if (CrashResultPhase == ResultPhase.StepRunCompleted)
|
{
|
if (AbortPlan)
|
TapThread.Current.Abort();
|
else
|
throw new Exception("Intended");
|
}
|
}
|
|
public override void OnResultPublished(Guid stepRunId, ResultTable result)
|
{
|
if (CrashResultPhase == ResultPhase.Result)
|
{
|
if (AbortPlan)
|
TapThread.Current.Abort();
|
else
|
throw new Exception("Intended");
|
}
|
}
|
}
|
|
public class InterfaceTestDut : ValidatingObject, IDut
|
{
|
private bool isConnected = true;
|
public bool IsConnected
|
{
|
get { return isConnected; }
|
set
|
{
|
if (value == IsConnected) return;
|
isConnected = value;
|
OnPropertyChanged("IsConnected");
|
}
|
}
|
|
string _shortName = "";
|
public string Name
|
{
|
get
|
{
|
return _shortName;
|
}
|
set
|
{
|
if (_shortName != value)
|
{
|
_shortName = value;
|
OnPropertyChanged("Name");
|
}
|
}
|
}
|
|
public event EventHandler<EventArgs> ActivityStateChanged;
|
|
public void Close()
|
{
|
|
}
|
|
public void Dispose()
|
{
|
|
}
|
|
public void OnActivity()
|
{
|
if (ActivityStateChanged != null)
|
{
|
ActivityStateChanged.Invoke(this, new EventArgs());
|
}
|
}
|
|
public void Open()
|
{
|
|
}
|
}
|
|
public class InterfaceTestResultListenser : ValidatingObject, IResultListener
|
{
|
private bool isConnected = true;
|
public bool IsConnected
|
{
|
get { return isConnected; }
|
set
|
{
|
if (value == isConnected) return;
|
isConnected = value;
|
OnPropertyChanged("IsConnected");
|
}
|
}
|
|
string _shortName = "InterfaceTestResultListener";
|
public string Name
|
{
|
get
|
{
|
return _shortName;
|
}
|
set
|
{
|
if (_shortName != value)
|
{
|
_shortName = value;
|
OnPropertyChanged("Name");
|
}
|
}
|
}
|
|
public event EventHandler<EventArgs> ActivityStateChanged;
|
|
public void OnResultPublished(Guid stepRun, ResultTable result)
|
{
|
|
}
|
|
public void Close()
|
{
|
|
}
|
|
public void Dispose()
|
{
|
|
}
|
|
public void OnActivity()
|
{
|
if (ActivityStateChanged != null)
|
{
|
ActivityStateChanged.Invoke(this, new EventArgs());
|
}
|
}
|
|
public void OnTestPlanRunCompleted(TestPlanRun planRun, Stream logStream)
|
{
|
|
}
|
|
public void OnTestPlanRunStart(TestPlanRun planRun)
|
{
|
|
}
|
|
public void OnTestStepRunCompleted(TestStepRun stepRun)
|
{
|
|
}
|
|
public void OnTestStepRunStart(TestStepRun stepRun)
|
{
|
|
}
|
|
public void Open()
|
{
|
|
}
|
}
|
|
[DisplayName("InterfaceTestInstrument")]
|
public class InterfaceTestInstrument : IInstrument
|
{
|
private bool isConnected = false;
|
public bool IsConnected
|
{
|
get { return isConnected; }
|
set
|
{
|
if (value == isConnected) return;
|
isConnected = value;
|
OnPropertyChanged("IsConnected");
|
}
|
}
|
|
private void OnPropertyChanged(string v)
|
{
|
if (PropertyChanged != null)
|
{
|
PropertyChanged.Invoke(this, new PropertyChangedEventArgs(v));
|
}
|
}
|
|
string _shortName = "InterfaceTestInstrument";
|
public string Name
|
{
|
get
|
{
|
return _shortName;
|
}
|
set
|
{
|
if (_shortName != value)
|
{
|
_shortName = value;
|
OnPropertyChanged("Name");
|
}
|
}
|
}
|
|
public event EventHandler<EventArgs> ActivityStateChanged;
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
public void Close()
|
{
|
IsConnected = false;
|
}
|
|
public void Dispose()
|
{
|
|
}
|
|
public void OnActivity()
|
{
|
if (ActivityStateChanged != null)
|
{
|
ActivityStateChanged.Invoke(this, new EventArgs());
|
}
|
}
|
|
public void Open()
|
{
|
IsConnected = true;
|
}
|
}
|
|
public class QuickTestStep : TestStep
|
{
|
public InterfaceTestInstrument Instrument { get; set; }
|
|
public override void Run()
|
{
|
|
}
|
}
|
}
|
