using NUnit.Framework;
|
using OpenTap.EngineUnitTestUtils;
|
using OpenTap.Plugins.BasicSteps;
|
using System;
|
using System.Collections.Generic;
|
using System.Threading;
|
|
namespace OpenTap.UnitTests
|
{
|
[TestFixture]
|
class MultiTestPlanRun
|
{
|
[Test]
|
public void SeparateLogs()
|
{
|
TestPlan plan1 = new TestPlan();
|
plan1.Steps.Add(new DelayStep { DelaySecs = 1, Name = "Delay1" });
|
|
TestPlan plan2 = new TestPlan();
|
plan2.Steps.Add(new DelayStep { DelaySecs = 1, Name = "Delay2" });
|
|
EngineSettings.Current.OperatorName = "Test";
|
TestTraceListener parentListener = new TestTraceListener();
|
Log.AddListener(parentListener);
|
TestTraceListener listener1 = null;
|
|
ManualResetEvent plan1Complete = new ManualResetEvent(false);
|
using (Session.Create())
|
{
|
EngineSettings.Current.OperatorName = "Test1";
|
|
var id = Session.Current.Id;
|
TapThread.Start(() =>
|
{
|
try
|
{
|
listener1 = new TestTraceListener();
|
Log.AddListener(listener1);
|
plan1.Execute();
|
Assert.AreEqual(id, Session.Current.Id);
|
Assert.AreEqual("Test1", EngineSettings.Current.OperatorName);
|
}
|
finally
|
{
|
plan1Complete.Set();
|
}
|
});
|
//Assert.AreEqual("Test1", EngineSettings.Current.OperatorName);
|
}
|
Assert.AreEqual("Test", EngineSettings.Current.OperatorName);
|
|
ManualResetEvent plan2Complete = new ManualResetEvent(false);
|
var t2 = TapThread.Start(() =>
|
{
|
var res = plan2.Execute();
|
plan2Complete.Set();
|
});
|
|
plan1Complete.WaitOne();
|
plan2Complete.WaitOne();
|
|
|
var parentLog = parentListener.GetLog();
|
//StringAssert.Contains("\"Delay1\" completed", parentLog);
|
StringAssert.Contains("\"Delay2\" completed", parentLog);
|
|
var session1Log = listener1.GetLog();
|
StringAssert.Contains("\"Delay1\" completed", session1Log);
|
StringAssert.DoesNotContain("\"Delay2\" completed", session1Log);
|
}
|
|
[Test]
|
public void Start()
|
{
|
TraceSource log = Log.CreateSource("StartTest");
|
HashSet<Guid> sessionIds = new HashSet<Guid>();
|
List<ManualResetEventSlim> sessionCompleted = new List<ManualResetEventSlim>();
|
for (int i = 0; i < 5; i++)
|
{
|
var completed = new ManualResetEventSlim(false);
|
sessionCompleted.Add(completed);
|
Session.Start(() =>
|
{
|
Thread.Sleep(20);
|
var sessionId = Session.Current.Id;
|
log.Info($"From session {sessionId}.");
|
lock (sessionIds)
|
{
|
CollectionAssert.DoesNotContain(sessionIds, sessionId);
|
sessionIds.Add(sessionId);
|
}
|
completed.Set();
|
});
|
}
|
sessionCompleted.ForEach(s => s.Wait());
|
Assert.AreEqual(5, sessionIds.Count);
|
CollectionAssert.AllItemsAreUnique(sessionIds);
|
}
|
|
class TestDisposable : IDisposable
|
{
|
public int Id { get; set; }
|
|
public bool IsDisposed { get; set; }
|
|
ManualResetEvent waitForDispose = new ManualResetEvent(false);
|
|
public void WaitForDispose() => waitForDispose.WaitOne();
|
public void Dispose()
|
{
|
if (IsDisposed) throw new Exception("This value was previously disposed");
|
IsDisposed = true;
|
waitForDispose.Set();
|
}
|
}
|
|
static SessionLocal<TestDisposable> testLocal = new SessionLocal<TestDisposable>(true);
|
/// <summary>
|
/// This unit test tests what happens with nested sessions and verifies that when session locals are configured
|
/// they keep their values, even when the session ends and some threads depends on the values from the threads.
|
/// Also checks that the values eventually will be disposed, even tough they
|
/// </summary>
|
|
public void NestedStart()
|
{
|
// start a new thread and return an action that is called to check
|
// if the value is still the expected one in that thread
|
Action startLocalValueChecker(int expectedLocalValue, CancellationToken cancellationToken)
|
{
|
var sem = new SemaphoreSlim(0, 1);
|
var sem2 = new SemaphoreSlim(0, 1);
|
TapThread.Start(() =>
|
{
|
try
|
{
|
while(true)
|
{
|
sem.Wait(cancellationToken);
|
try
|
{
|
Assert.IsFalse(testLocal.Value.IsDisposed);
|
Assert.AreEqual(expectedLocalValue, testLocal.Value.Id);
|
}
|
finally
|
{
|
sem2.Release();
|
}
|
}
|
}
|
catch
|
{
|
|
}
|
finally
|
{
|
sem2.Release();
|
}
|
});
|
|
void doCheck()
|
{
|
sem.Release();
|
sem2.Wait();
|
}
|
|
return doCheck;
|
}
|
|
var value1 = new TestDisposable(){Id = 5};
|
var value2 = new TestDisposable(){Id = 15};
|
var value3 = new TestDisposable(){Id = 25};
|
|
|
testLocal.Value = value1;
|
CancellationTokenSource c = new CancellationTokenSource();
|
Action check = startLocalValueChecker(5, c.Token);
|
check();
|
using(Session.Create())
|
{
|
Assert.AreEqual(5, testLocal.Value.Id);
|
testLocal.Value = value2;
|
check += startLocalValueChecker(15, c.Token);
|
check();
|
Assert.AreEqual(15, testLocal.Value.Id);
|
Assert.AreEqual(value2, testLocal.Value);
|
using(Session.Create())
|
{
|
Assert.AreEqual(value2, testLocal.Value);
|
Assert.AreEqual(15, testLocal.Value.Id);
|
testLocal.Value = value3;
|
check += startLocalValueChecker(25, c.Token);
|
Assert.AreEqual(25, testLocal.Value.Id);
|
check();
|
}
|
|
check();
|
Assert.AreEqual(15, testLocal.Value.Id);
|
}
|
Assert.AreEqual(5, testLocal.Value.Id);
|
check();
|
c.Cancel();
|
check();
|
|
Assert.IsFalse(value1.IsDisposed);
|
value2.WaitForDispose();
|
value3.WaitForDispose();
|
Assert.IsTrue(value2.IsDisposed);
|
Assert.IsTrue(value3.IsDisposed);
|
}
|
}
|
|
}
|
