public async Task TestConcurrentCancelFirst()
{
var entryContext = AsyncTestContext.Current;
var sut = new FastAsyncLock();
var ct = new CancellationTokenSource();
using (var otherThread = new AsyncTestRunner(CommonTwoStepsLock(sut)))
{
// Acquire the lock on another async context
await otherThread.Advance();
Assert.IsTrue(otherThread.HasLock());
// Try to acquire the lock from this async context
entryContext.Validate();
var locking = sut.LockAsync(CancellationToken.None);
Assert.AreEqual(TaskStatus.WaitingForActivation, locking.Status);
// Cancel the CT of the other thread ... this should not impact the awaiter !
ct.Cancel();
Assert.AreEqual(TaskStatus.WaitingForActivation, locking.Status);
// Finally validate that if we release the lock from the other thread, we are still able to acquire the lock
await otherThread.Advance();
Assert.AreEqual(TaskStatus.RanToCompletion, locking.Status);
}
}
public async Task TestExitFromAnotherExecutionContext()
{
var sut = new FastAsyncLock();
var locking = default(IDisposable);
var entryContext = default(AsyncTestContext);
using (var externalThread = new AsyncTestRunner(ExternalThread))
{
entryContext = AsyncTestContext.Current;
locking = await sut.LockAsync(CancellationToken.None);
await externalThread.AdvanceTo(1);
Assert.IsTrue(externalThread.HasLock());
await externalThread.AdvanceToEnd();
}
async Task ExternalThread(CancellationToken ct, AsyncTestRunner r)
{
Assert.AreNotEqual(entryContext, AsyncTestContext.Current);
locking.Dispose();
// Try to relock from the external execution context to validate that the lock was effectively released
using (await sut.LockAsync(ct))
{
r.HasLock(true);
r.Sync(position: 1);
await Task.Yield();
}
r.HasLock(false);
}
}
public static void TestRunnerControlInstantiation()
{
TestRunnerControl control = null;
AsyncTestRunner runner = null;
ObjectProxy proxy = null;
try
{
proxy = new StubObjectProxy();
runner = new PmlTestRunner(proxy, new StubMethodInvoker());
proxy = null;
var provider = new FileIndexTestCaseProvider();
control = new TestRunnerControl(provider, runner, new RegistrySettingsProvider());
runner = null;
}
finally
{
if (proxy != null)
{
proxy.Dispose();
}
if (runner != null)
{
runner.Dispose();
}
if (control != null)
{
control.Dispose();
}
}
}
public void InvokingAsyncVoidWhichThrowsIsObservedAndRethrown()
{
var methodInfo = typeof(WhenStepScannerFactoryAsyncMethods).GetMethod("AsyncTaskMethod", BindingFlags.Instance | BindingFlags.NonPublic);
var stepAction = StepActionFactory.GetStepAction(methodInfo, new object[] { new SomeScenario() });
Should.Throw <ArgumentException>(() => AsyncTestRunner.Run(() => stepAction(this)));
}
private void RunTests()
{
this.Title = "Unit Tests for " + new AssemblyName(this.GetType().Assembly.FullName).Name;
if (TestRunner == null)
{
try {
OnTestRunStarted();
}
catch (Exception e) {
MethodInfo method = GetType().GetMethod("OnTestRunStarted", BindingFlags.NonPublic | BindingFlags.Instance);
this.m_headerOutcome = new MethodOutcome(method);
this.m_headerOutcome.SetOutcome(e);
this.m_headerView.SetHtml(TestClassResultActivity.GetHTMLDescriptionFor(this.m_headerOutcome));
this.m_headerView.Visibility = ViewStates.Visible;
this.ResultBar.SetColorByState(TestState.Failed);
Toast.MakeText(this, "OnTestRunStarted() notification failed.", ToastLength.Long).Show();
return;
}
this.m_headerView.Visibility = ViewStates.Gone;
this.ResultBar.SetColorByState(TestState.Running);
AsyncTestRunner.Run(this, this.CreateTestRunner, this.OnTestRunFinished);
}
}
public async Task TestReleaseThenReAcquireWithConcurrentAccess()
{
var sut = new FastAsyncLock();
using (var otherThread = new AsyncTestRunner(OtherThread))
{
await otherThread.AdvanceTo(1);
Assert.IsTrue(otherThread.HasLock());
await otherThread.AdvanceTo(2);
Assert.IsFalse(otherThread.HasLock());
using (await sut.LockAsync(CancellationToken.None))
{
await Task.Yield();
await otherThread.AdvanceAndFreezeBefore(3);
Assert.IsFalse(otherThread.HasLock());
}
await otherThread.AdvanceTo(4);
Assert.IsTrue(otherThread.HasLock());
}
async Task OtherThread(CancellationToken ct, AsyncTestRunner r)
{
using (await sut.LockAsync(CancellationToken.None))
{
await Task.Yield();
r.HasLock(true);
r.Sync(position: 1);
}
await Task.Yield();
r.HasLock(false);
r.Sync(position: 2);
using (await sut.LockAsync(CancellationToken.None))
{
await Task.Yield();
r.HasLock(true);
r.Sync(position: 3);
r.Sync(position: 4);
}
await Task.Yield();
r.HasLock(false);
}
}
public virtual void SetUp()
{
contextManagerStub = new Mock <IContextManager>();
testExecutionEngineStub = new Mock <ITestExecutionEngine>();
testExecutionEngineStub.Setup(tr => tr.ScenarioContext).Returns(() => contextManagerStub.Object.ScenarioContext);
testExecutionEngineStub.Setup(tr => tr.FeatureContext).Returns(() => contextManagerStub.Object.FeatureContext);
testExecutionEngineStub.Setup(m => m.OnScenarioStart(It.IsAny <ScenarioInfo>())).Callback(
(ScenarioInfo si) => contextManagerStub.Setup(cm => cm.ScenarioContext).Returns(new ScenarioContext(si, asyncTestRunner, null))
);
fakeAsyncTestExecutor = new FakeAsyncTestExecutor();
asyncTestRunner = new AsyncTestRunner(testExecutionEngineStub.Object);
}
public TestForm()
{
ObjectProxy proxy = null;
AsyncTestRunner runner = null;
TestRunnerControl control = null;
try
{
Index = new MutablePathIndex(Path.GetFullPath("..\\..\\..\\..\\pmllib-tests"));
proxy = new StubObjectProxy();
runner = new PmlTestRunner(proxy, new ControlMethodInvoker(this), new StubClock(), Index);
proxy = null;
control = new TestRunnerControl(Index, runner, new RegistrySettingsProvider());
RunnerControl = control;
runner = null;
control.Dock = DockStyle.Fill;
InitializeComponent();
PathComboBox.Text = Index.Path;
FolderBrowser.SelectedPath = Index.Path;
ControlPanel.Controls.Add(control);
control = null;
}
finally
{
if (control != null)
{
control.Dispose();
}
if (runner != null)
{
runner.Dispose();
}
if (proxy != null)
{
proxy.Dispose();
}
}
}
public async Task TestConcurrentAccess()
{
var entryContext = AsyncTestContext.Current;
var sut = new FastAsyncLock();
using (var otherThread = new AsyncTestRunner(CommonTwoStepsLock(sut)))
{
// Acquire the lock on another async context
await otherThread.Advance();
Assert.IsTrue(otherThread.HasLock());
// Try to acquire the lock from this async context
entryContext.Validate();
var locking = sut.LockAsync(CancellationToken.None);
Assert.AreEqual(TaskStatus.WaitingForActivation, locking.Status);
await otherThread.Advance(); // Will release the lock
Assert.AreEqual(TaskStatus.RanToCompletion, locking.Status); // so lock is now acquired (sync)
}
}
public async Task TestConcurrentCancelSecond()
{
var entryContext = AsyncTestContext.Current;
var sut = new FastAsyncLock();
var ct = new CancellationTokenSource();
using (var otherThread = new AsyncTestRunner(CommonTwoStepsLock(sut)))
{
// Acquire the lock on another async context
await otherThread.Advance();
Assert.IsTrue(otherThread.HasLock());
// Try to acquire the lock from this async context
entryContext.Validate();
var locking = sut.LockAsync(ct.Token);
Assert.AreEqual(TaskStatus.WaitingForActivation, locking.Status);
// But cancel before the other async context completes
ct.Cancel();
Assert.AreEqual(TaskStatus.Canceled, locking.Status);
}
}
internal static void HasLock(this AsyncTestRunner runner, bool value) => runner.Set("hasLock", value);
internal static bool HasLock(this AsyncTestRunner runner) => runner.Get <bool>("hasLock");
[Ignore] // https://github.com/nventive/Uno.Core/issues/48
public async Task TestUnlockReleaseNextSynchronously()
{
Console.WriteLine($"Running on thread {Thread.CurrentThread.ManagedThreadId}");
var sut = new FastAsyncLock();
var thread1ExitingThread = -1;
var thread2LockingTask = default(Task <IDisposable>);
var thread1 = new AsyncTestRunner(Thread1);
var thread2 = new AsyncTestRunner();
thread2.Run(Thread2);
using (thread1)
using (thread2)
{
// Acquire the lock on thread 1
await thread1.AdvanceTo(1);
// Wait for the thread 2 to be stuck to acquire the lock
var thread2Locking = thread2.AdvanceTo(1);
while (thread2LockingTask == null)
{
await Task.Yield();
}
// Make sure that the thread 2 is really awaiting the thread2LockingTask before requesting thread1 to continue
await Task.Delay(100);
Assert.AreEqual(TaskStatus.WaitingForActivation, thread2LockingTask.Status);
// Relase the thread 1 and make sure that the thread 2 is able to acquire the lock
var thread1Release = thread1.AdvanceTo(2);
await thread2Locking;
}
async Task Thread1(CancellationToken ct, AsyncTestRunner r)
{
Console.WriteLine($"Thread 1: {Thread.CurrentThread.ManagedThreadId}");
var ctx = AsyncTestContext.Current;
using (await sut.LockAsync(ct))
{
Console.WriteLine($"Acquired lock for Thread1 on thread: {Thread.CurrentThread.ManagedThreadId}");
ctx.Validate();
await Task.Yield();
r.Sync(position: 1);
thread1ExitingThread = Thread.CurrentThread.ManagedThreadId;
Console.WriteLine($"Releasing lock from Thread1 on thread: {Thread.CurrentThread.ManagedThreadId}");
}
Console.WriteLine($"Released lock from Thread1 on thread: {Thread.CurrentThread.ManagedThreadId}");
// This must have run synchronously when lock got released (disposed).
Assert.AreEqual(TaskStatus.RanToCompletion, thread2LockingTask.Status);
r.Sync(position: 2);
}
async Task Thread2(CancellationToken ct, AsyncTestRunner r)
{
Console.WriteLine($"Thread 2: {Thread.CurrentThread.ManagedThreadId}");
var ctx = AsyncTestContext.Current;
thread2LockingTask = sut.LockAsync(ct);
// Validate that we are running on thread 2
Assert.AreEqual(thread2.ThreadId, Thread.CurrentThread.ManagedThreadId);
Console.WriteLine("Thread 2 is waiting for lock");
using (await thread2LockingTask)
{
Console.WriteLine($"Acquired lock for Thread2 on thread: {Thread.CurrentThread.ManagedThreadId}");
// Here we should run on the thread 1 since the lock is released synchronously from thread 1
Assert.AreEqual(thread1ExitingThread, Thread.CurrentThread.ManagedThreadId);
// But we should have kept the ExecutionContext from the thread 2
ctx.Validate();
await Task.Yield();
r.Sync(position: 1);
Console.WriteLine($"Releasing lock from Thread2 on thread: {Thread.CurrentThread.ManagedThreadId}");
}
Console.WriteLine($"Released lock from Thread2 on thread: {Thread.CurrentThread.ManagedThreadId}");
r.Sync(position: 2);
}
}
public void CallingAsyncVoidWhichThrowsIsObservedAndRethrown()
{
var stepAction = StepActionFactory.GetStepAction <SomeScenario>(s => AsyncVoidMethod(s));
Should.Throw <ArgumentException>(() => AsyncTestRunner.Run(() => stepAction(new SomeScenario())));
}
public async Task TestConcurrentCancelSecondWithThird()
{
var sut = new FastAsyncLock();
var ct = new CancellationTokenSource();
var thread2LockingTask = default(Task <IDisposable>);
using (var thread1 = new AsyncTestRunner(Thread1))
using (var thread2 = new AsyncTestRunner(Thread2))
using (var thread3 = new AsyncTestRunner(Thread3))
{
// Acquire the lock on thread 1 THEN
await thread1.AdvanceTo(1);
Assert.IsTrue(thread1.HasLock());
// Try to acquire the lock from this async context
await thread2.AdvanceAndFreezeBefore(1);
//var locking = sut.LockAsync(ct.Token);
Assert.AreEqual(TaskStatus.WaitingForActivation, thread2LockingTask.Status);
Assert.IsFalse(thread2.HasLock());
// Try to acquire it on thread 3
var t3Locked = thread3.AdvanceTo(1);
await thread3.IsFrozen();
Assert.IsFalse(thread3.HasLock());
// But cancel before the other async context completes
ct.Cancel();
Assert.AreEqual(TaskStatus.Canceled, thread2LockingTask.Status);
// Release the lock from thread1, and wait for thread 3 to acquire the lock
await thread1.AdvanceAndFreezeBefore(2); // will freeze in continuation of thread 3
await t3Locked;
//Assert.IsFalse(thread1.HasLock()); // flag not set yet: the thread 1 is dead locked by the continuation of thread 3
Assert.IsTrue(thread3.HasLock());
await thread3.AdvanceToEnd();
//await thread1.AdvanceToEnd();
await Task.Delay(500);
Assert.IsFalse(thread1.HasLock());
Assert.IsFalse(thread3.HasLock());
}
async Task Thread1(CancellationToken ct2, AsyncTestRunner r)
{
using (await sut.LockAsync(ct2))
{
r.HasLock(true);
r.Sync(position: 1);
}
r.HasLock(false);
r.Sync(position: 2);
};
async Task Thread2(CancellationToken ct2, AsyncTestRunner r)
{
thread2LockingTask = sut.LockAsync(ct.Token);
using (await thread2LockingTask)
{
r.HasLock(true);
r.Sync(position: 1);
}
r.HasLock(false);
r.Sync(position: 2);
}
async Task Thread3(CancellationToken ct2, AsyncTestRunner r)
{
using (await sut.LockAsync(ct2))
{
r.HasLock(true);
r.Sync(position: 1);
}
r.HasLock(false);
r.Sync(position: 2);
};
}
public static void Run(Context ctx, Func <TestRunner> testRunnerCreatorFunc, Action <TestRunner> finishedHandler)
{
AsyncTestRunner runner = new AsyncTestRunner(ctx, testRunnerCreatorFunc, finishedHandler);
runner.Execute();
}
public async Task TestReEntrencyWithConcurrentAccess()
{
var sut = new FastAsyncLock();
using (var thread2 = new AsyncTestRunner(Thread2))
using (var thread1 = new AsyncTestRunner(Thread1))
{
// Enter from main thread
await thread1.AdvanceTo(1);
// Try enter from second thread
var thread2Locking = thread2.AdvanceTo(2);
await Task.Delay(100);
Assert.AreEqual(TaskStatus.WaitingForActivation, thread2Locking.Status);
// ReEnter
await thread1.AdvanceTo(2);
// Exit once
await thread1.AdvanceTo(3);
Assert.AreEqual(TaskStatus.WaitingForActivation, thread2Locking.Status);
// Final exit
thread1.AdvanceTo(4);
await thread2Locking;
}
async Task Thread1(CancellationToken ct, AsyncTestRunner r)
{
using (await sut.LockAsync(CancellationToken.None))
{
await Task.Yield();
r.HasLock(true);
r.Sync(position: 1);
using (await sut.LockAsync(CancellationToken.None))
{
await Task.Yield();
r.Sync(position: 2);
}
r.Sync(position: 3);
}
r.HasLock(false);
r.Sync(position: 4);
}
async Task Thread2(CancellationToken ct, AsyncTestRunner r)
{
using (await sut.LockAsync(ct))
{
r.HasLock(true);
r.Sync(position: 1);
}
r.HasLock(false);
r.Sync(position: 2);
}
}
public void CallingAsyncTaskWhichThrowsIsObservedAndRethrown()
{
var stepAction = StepActionFactory.GetStepAction <SomeScenario>(o => AsyncTaskMethod(o));
Assert.Throws <ArgumentException>(() => AsyncTestRunner.Run(() => stepAction(new SomeScenario())));
}
