using System;
|
using System.Collections.Generic;
|
using System.IO;
|
using System.Linq;
|
using System.Reflection;
|
using System.Threading;
|
using NUnit.Framework;
|
using OpenTap.Diagnostic;
|
using OpenTap.Engine.UnitTests.TestTestSteps;
|
using OpenTap.EngineUnitTestUtils;
|
using OpenTap.Plugins.BasicSteps;
|
|
namespace OpenTap.UnitTests
|
{
|
public class SubPlanTest
|
{
|
|
class SubPlanResultListener : ResultListener
|
{
|
ResultSource proxy;
|
public SubPlanResultListener(ResultSource proxy) => this.proxy = proxy;
|
|
public override void OnResultPublished(Guid stepRunId, ResultTable result)
|
{
|
base.OnResultPublished(stepRunId, result);
|
proxy.PublishTable(result);
|
}
|
}
|
|
public class SubDut : Dut
|
{
|
public override void Open()
|
{
|
base.Open();
|
}
|
|
public override void Close()
|
{
|
base.Close();
|
}
|
}
|
|
public class SubPlanStep : TestStep
|
{
|
|
public TestPlan Plan { get; set; }
|
|
public SubDut Dut{ get; set; }
|
public override void Run()
|
{
|
var planXml = Plan.SerializeToString();
|
using (Session.Create(SessionOptions.OverlayComponentSettings))
|
{
|
|
var plan = Utils.DeserializeFromString<TestPlan>(planXml);
|
var subRun = plan.Execute(new IResultListener[] {new SubPlanResultListener(Results)});
|
UpgradeVerdict(subRun.Verdict);
|
}
|
}
|
}
|
|
public class DutStep : TestStep
|
{
|
public Dut Dut { get; set; }
|
public override void Run()
|
{
|
Assert.IsTrue(Dut.IsConnected);
|
}
|
}
|
|
[Test]
|
public void TestRunningSubPlan()
|
{
|
using (Session.Create())
|
{
|
string knownLogMessage = "asdasdasd";
|
var dut = new SubDut();
|
DutSettings.Current.Add(dut);
|
var subPlan = new TestPlan();
|
subPlan.Steps.Add(new LogStep {LogMessage = knownLogMessage});
|
subPlan.Steps.Add(new VerdictStep {Verdict = Verdict.Pass});
|
subPlan.Steps.Add(new DutStep {Dut = dut});
|
|
var plan = new TestPlan();
|
plan.Steps.Add(new SubPlanStep {Plan = subPlan, Dut = dut});
|
var listener = new MemoryTraceListener();
|
using (Session.Create(SessionOptions.RedirectLogging))
|
{
|
Log.AddListener(listener);
|
var run = plan.Execute();
|
Assert.IsTrue(run.Verdict == Verdict.Pass);
|
}
|
|
Assert.IsTrue(listener.Events.Any(x => x.Message == knownLogMessage));
|
}
|
}
|
|
class MemoryTraceListener : ILogListener
|
{
|
public readonly List<Event> Events = new List<Event>();
|
public void EventsLogged(IEnumerable<Event> Events)
|
{
|
this.Events.AddRange(Events);
|
}
|
|
public void Flush()
|
{
|
|
}
|
}
|
|
[Test]
|
public void RedirectedLogTest()
|
{
|
var rootListener = new MemoryTraceListener();
|
var sessionListener = new MemoryTraceListener();
|
var log = Log.CreateSource("Redirect?");
|
string msg1 = "This is redirected";
|
string msg2 = "This is redirected and from another thread";
|
string msg3 = "This is also redirected";
|
|
Log.AddListener(rootListener);
|
|
log.Debug("This is not redirected");
|
|
var trd = TapThread.Start(() =>
|
{
|
try
|
{
|
while (true)
|
{
|
TapThread.Sleep(1);
|
log.Debug("Not redirected!");
|
}
|
}
|
catch
|
{
|
|
}
|
});
|
|
using (Session.Create(SessionOptions.RedirectLogging))
|
{
|
Log.AddListener(sessionListener);
|
var sem = new Semaphore(0, 1);
|
log.Debug(msg1);
|
TapThread.Start(() =>
|
{
|
// messages from a different thread should also be redirected.
|
log.Info(msg2);
|
sem.Release();
|
});
|
sem.WaitOne();
|
}
|
|
log.Debug("This is also not redirected");
|
using (Session.Create(SessionOptions.RedirectLogging))
|
{
|
Log.AddListener(sessionListener);
|
log.Debug(msg3);
|
}
|
|
trd.Abort();
|
|
Assert.AreEqual(3, sessionListener.Events.Count);
|
Assert.IsTrue(sessionListener.Events[0].Message == msg1);
|
Assert.IsTrue(sessionListener.Events[1].Message == msg2);
|
Assert.IsTrue(sessionListener.Events[2].Message == msg3);
|
|
Assert.IsFalse(rootListener.Events.Any(e => e.Message == msg1));
|
}
|
|
[Test]
|
[Retry(3)]
|
public void RedirectedLogTest2()
|
{
|
var listener = new MemoryTraceListener();
|
var listener1 = new MemoryTraceListener();
|
var listener2 = new MemoryTraceListener();
|
var log = Log.CreateSource("Redirect?");
|
string msg1 = "This is redirected";
|
string msg2 = "This is redirected and from another thread";
|
|
Log.AddListener(listener);
|
log.Debug("This is not redirected0");
|
|
var sem = new Semaphore(0, 1);
|
using (Session.Create(SessionOptions.RedirectLogging))
|
{
|
Log.AddListener(listener1);
|
log.Debug(msg1);
|
TapThread.Start(() =>
|
{
|
Log.AddListener(listener2);
|
Thread.Sleep(50);
|
// messages from a different thread should also be redirected.
|
log.Info(msg2);
|
sem.Release();
|
});
|
}
|
log.Debug("This is not redirected1");
|
sem.WaitOne();
|
log.Debug("This is not redirected2");
|
log.Flush();
|
Assert.AreEqual(3, listener.Events.Count, string.Join(Environment.NewLine, listener.Events.Select(evt => evt.Message)));
|
|
Assert.IsTrue(listener1.Events[0].Message == msg1);
|
Assert.IsTrue(listener1.Events[1].Message == msg2);
|
Assert.IsTrue(listener2.Events[0].Message == msg2);
|
}
|
|
public enum SessionEnum
|
{
|
Parent,
|
SessionA,
|
SessionB
|
}
|
|
public class TestUserInterface : IUserInputInterface
|
{
|
public SessionEnum SessionEnum { get; set; }
|
|
public TestUserInterface(SessionEnum caller)
|
{
|
SessionEnum = caller;
|
}
|
void IUserInputInterface.RequestUserInput(object dataObject, TimeSpan timeout, bool modal)
|
{
|
|
}
|
}
|
|
void InterfaceAssert(SessionEnum expected)
|
{
|
var i = UserInput.GetInterface() as TestUserInterface;
|
Assert.IsTrue(i?.SessionEnum == expected,
|
$"User interface '{expected}' expected, but was {i?.SessionEnum.ToString() ?? "Not Set"}");
|
}
|
|
[Test]
|
public void RedirectedUserInputTest()
|
{
|
var previousInterface = UserInput.GetInterface();
|
try
|
{
|
var parentInterface = new TestUserInterface(SessionEnum.Parent);
|
var aInterface = new TestUserInterface(SessionEnum.SessionA);
|
var bInterface = new TestUserInterface(SessionEnum.SessionB);
|
|
UserInput.SetInterface(parentInterface);
|
InterfaceAssert(SessionEnum.Parent);
|
|
// Verify the user input is correctly inherited
|
using (Session.Create())
|
{
|
InterfaceAssert(SessionEnum.Parent);
|
UserInput.SetInterface(aInterface);
|
InterfaceAssert(SessionEnum.SessionA);
|
}
|
|
// Verify the user input is correctly reset
|
InterfaceAssert(SessionEnum.Parent);
|
|
// Verify the user input is correctly inherited in nested contexts
|
using (Session.Create())
|
{
|
InterfaceAssert(SessionEnum.Parent);
|
UserInput.SetInterface(aInterface);
|
InterfaceAssert(SessionEnum.SessionA);
|
|
using (Session.Create())
|
{
|
InterfaceAssert(SessionEnum.SessionA);
|
UserInput.SetInterface(bInterface);
|
InterfaceAssert(SessionEnum.SessionB);
|
}
|
InterfaceAssert(SessionEnum.SessionA);
|
}
|
// Verify the user input is correctly reset from nested contexts
|
InterfaceAssert(SessionEnum.Parent);
|
}
|
finally
|
{
|
UserInput.SetInterface(previousInterface);
|
}
|
}
|
|
[Test]
|
public void RedirectedUserInputParallelTest()
|
{
|
// 1: Session B sets its interface
|
// 2: Session A verifies its interface is unchanged
|
var e2 = new ManualResetEventSlim(false);
|
// 3: Session A verifies its interface changes
|
// 4: Session B verifies it still has the correct interface
|
var e4 = new ManualResetEventSlim(false);
|
// 5: Session A verifies it still has the correct interface
|
var e5 = new ManualResetEventSlim(false);
|
// 6: Session A verifies its interface has been reset to 'parent'
|
// 7: Session B verifies its interface has been reset to 'parent'
|
var e7 = new ManualResetEventSlim(false);
|
|
var previousInterface = UserInput.GetInterface();
|
try
|
{
|
var parentInterface = new TestUserInterface(SessionEnum.Parent);
|
var aInterface = new TestUserInterface(SessionEnum.SessionA);
|
var bInterface = new TestUserInterface(SessionEnum.SessionB);
|
|
UserInput.SetInterface(parentInterface);
|
InterfaceAssert(SessionEnum.Parent);
|
|
{ // Session A
|
TapThread.Start(() =>
|
{
|
e2.Wait();
|
using (Session.Create())
|
{
|
InterfaceAssert(SessionEnum.Parent); // 2: Session A verifies its interface is unchanged
|
UserInput.SetInterface(aInterface);
|
InterfaceAssert(SessionEnum.SessionA); // 3: Session A verifies its interface changes
|
e4.Set();
|
e5.Wait();
|
InterfaceAssert(SessionEnum.SessionA); // 5: Session A verifies it still has the correct interface
|
}
|
|
InterfaceAssert(SessionEnum.Parent); // 6: Session A verifies its interface has been reset to 'parent'
|
e7.Set();
|
});
|
}
|
|
{ // Session B
|
|
using (Session.Create())
|
{
|
InterfaceAssert(SessionEnum.Parent);
|
UserInput.SetInterface(bInterface); // 1: Session B sets its interface
|
InterfaceAssert(SessionEnum.SessionB);
|
e2.Set();
|
e4.Wait();
|
InterfaceAssert(SessionEnum.SessionB); // 4: Session B verifies it still has the correct interface
|
e5.Set();
|
e7.Wait();
|
}
|
InterfaceAssert(SessionEnum.Parent); // 7: Session B verifies its interface has been reset to 'parent'
|
}
|
|
// Verify the user input is correctly reset from nested contexts
|
InterfaceAssert(SessionEnum.Parent);
|
|
}
|
finally
|
{
|
UserInput.SetInterface(previousInterface);
|
}
|
}
|
|
|
[Test]
|
public void ComponentSettingSession()
|
{
|
DutSettings.Current.Clear();
|
var dut1 = new SubDut();
|
try
|
{
|
|
DutSettings.Current.Add(dut1);
|
var profile1 = EngineSettings.Current.OperatorName;
|
using (Session.Create(SessionOptions.OverlayComponentSettings))
|
{
|
var profile2 = "profile2";
|
EngineSettings.Current.OperatorName = profile2;
|
|
var dut2 = new SubDut();
|
DutSettings.Current.Add(dut2);
|
Assert.AreEqual(2, DutSettings.Current.Count);
|
using (Session.Create(SessionOptions.OverlayComponentSettings))
|
{
|
var profile3 = "profile3";
|
var dut3 = new SubDut();
|
DutSettings.Current.Add(dut3);
|
Assert.AreEqual(3, DutSettings.Current.Count);
|
Assert.AreEqual(profile2, EngineSettings.Current.OperatorName);
|
EngineSettings.Current.OperatorName = profile3;
|
}
|
|
using (Session.Create(SessionOptions.OverlayComponentSettings))
|
{
|
Assert.AreEqual(profile2, EngineSettings.Current.OperatorName);
|
}
|
|
Assert.AreEqual(2, DutSettings.Current.Count);
|
Assert.AreEqual(profile2, EngineSettings.Current.OperatorName);
|
}
|
|
Assert.AreEqual(1, DutSettings.Current.Count);
|
Assert.AreEqual(profile1, EngineSettings.Current.OperatorName);
|
}
|
finally
|
{
|
DutSettings.Current.Remove(dut1);
|
}
|
|
Assert.AreEqual(0, DutSettings.Current.Count);
|
}
|
|
[Test]
|
public void TestPlanReferenceDetectChangesTest()
|
{
|
var planName = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".TapPlan");
|
var subPlan = new TestPlan();
|
var delay = new DelayStep();
|
|
delay.DelaySecs = 0.1;
|
subPlan.Steps.Add(delay);
|
|
var mainPlan = new TestPlan();
|
var tpr = new TestPlanReference() { Filepath = { Text = planName } };
|
mainPlan.ChildTestSteps.Add(tpr);
|
|
string saveAndRun()
|
{
|
subPlan.Save(planName);
|
tpr.LoadTestPlan();
|
var hash = mainPlan.Execute().Hash;
|
Assert.IsFalse(string.IsNullOrWhiteSpace(hash));
|
return hash;
|
}
|
|
var firstHash = saveAndRun();
|
Assert.AreEqual(firstHash, saveAndRun(), "Expected hash to be the same.");
|
delay.DelaySecs = 0.01;
|
Assert.AreNotEqual(firstHash, saveAndRun(), "Expected hash to be different.");
|
}
|
|
[Test]
|
public void TestPlanReferenceSubPlanTest()
|
{
|
int parallelism = 10;
|
var planName = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".TapPlan");
|
string knownLogMessage = "Hello";
|
using (Session.Create())
|
try
|
{
|
var dut = new SubDut();
|
DutSettings.Current.Add(dut);
|
|
{
|
var subPlan = new TestPlan();
|
subPlan.Steps.Add(new LogStep {LogMessage = knownLogMessage});
|
subPlan.Steps.Add(new VerdictStep {Verdict = Verdict.Pass});
|
subPlan.Steps.Add(new DutStep {Dut = dut});
|
subPlan.Save(planName);
|
}
|
var plan = new TestPlan();
|
var par = new ParallelStep();
|
plan.ChildTestSteps.Add(par);
|
for (int i = 0; i < parallelism; i++)
|
{
|
var tpr1 = new TestPlanReference
|
{
|
Filepath = {Text = planName}
|
};
|
var hideSteps = tpr1.GetType().GetProperty("HideSteps", BindingFlags.Instance | BindingFlags.NonPublic);
|
hideSteps.SetValue(tpr1, true);
|
par.ChildTestSteps.Add(tpr1);
|
}
|
|
var testListener = new TestTraceListener();
|
Log.AddListener(testListener);
|
var run = plan.Execute();
|
var log = testListener.GetLog();
|
Assert.AreEqual(Verdict.Pass, run.Verdict, log);
|
}
|
finally
|
{
|
File.Delete(planName);
|
}
|
}
|
}
|
}
|
