public void FromWaitHandle_SignaledHandleWithCanceledToken_SynchronouslyCompletes()
{
var mre = new ManualResetEvent(true);
var task = WaitHandleAsyncFactory.FromWaitHandle(mre, new CancellationToken(true));
Assert.True(task.IsCompleted);
}
public void FromWaitHandle_SignaledHandle_SynchronouslyCompletes()
{
var mre = new ManualResetEvent(true);
var task = WaitHandleAsyncFactory.FromWaitHandle(mre);
Assert.True(task.IsCompleted);
}
public void FromWaitHandle_SignaledHandleWithZeroTimeout_SynchronouslyCompletesWithTrueResult()
{
var mre = new ManualResetEvent(true);
var task = WaitHandleAsyncFactory.FromWaitHandle(mre, TimeSpan.Zero);
Assert.True(task.IsCompleted);
Assert.True(task.Result);
}
public void FromWaitHandle_SignaledHandleWithZeroTimeoutAndCanceledToken_SynchronouslyCompletesWithTrueResult()
{
ManualResetEvent mre = new ManualResetEvent(true);
Task <bool> task = WaitHandleAsyncFactory.FromWaitHandle(mre, TimeSpan.Zero, new CancellationToken(true));
Assert.True(task.IsCompleted);
Assert.True(task.Result);
}
public async Task FromWaitHandle_TimeoutBeforeHandleSignalled_CompletesWithFalseResult()
{
var mre = new ManualResetEvent(false);
var task = WaitHandleAsyncFactory.FromWaitHandle(mre, TimeSpan.FromMilliseconds(10));
var result = await task;
Assert.False(result);
}
public void FromWaitHandle_UnsignaledHandleWithCanceledToken_SynchronouslyCancels()
{
ManualResetEvent mre = new ManualResetEvent(false);
Task task = WaitHandleAsyncFactory.FromWaitHandle(mre, new CancellationToken(true));
Assert.True(task.IsCompleted);
Assert.True(task.IsCanceled);
}
public void FromWaitHandle_UnsignaledHandleWithZeroTimeout_SynchronouslyCompletesWithFalseResult()
{
ManualResetEvent mre = new ManualResetEvent(false);
Task <bool> task = WaitHandleAsyncFactory.FromWaitHandle(mre, TimeSpan.Zero);
Assert.True(task.IsCompleted);
Assert.False(task.Result);
}
public void FromWaitHandle_UnsignaledHandleWithZeroTimeoutAndCanceledToken_SynchronouslyCompletesWithFalseResult()
{
var mre = new ManualResetEvent(false);
var task = WaitHandleAsyncFactory.FromWaitHandle(mre, TimeSpan.Zero, new CancellationToken(true));
Assert.True(task.IsCompleted);
Assert.False(task.Result);
}
public async Task FromWaitHandle_HandleSignalled_Completes()
{
var mre = new ManualResetEvent(false);
var task = WaitHandleAsyncFactory.FromWaitHandle(mre);
Assert.False(task.IsCompleted);
mre.Set();
await task;
}
public async Task FromWaitHandle_TimeoutBeforeHandleSignalledOrCanceled_CompletesWithFalseResult()
{
ManualResetEvent mre = new ManualResetEvent(false);
CancellationTokenSource cts = new CancellationTokenSource();
Task <bool> task = WaitHandleAsyncFactory.FromWaitHandle(mre, TimeSpan.FromMilliseconds(10), cts.Token);
bool result = await task;
Assert.False(result);
}
public async Task FromWaitHandle_HandleSignalledBeforeCanceled_CompletesSuccessfully()
{
var mre = new ManualResetEvent(false);
var cts = new CancellationTokenSource();
var task = WaitHandleAsyncFactory.FromWaitHandle(mre, cts.Token);
Assert.False(task.IsCompleted);
mre.Set();
await task;
}
public async Task FromWaitHandle_CanceledBeforeTimeoutOrHandleSignalled_CompletesCanceled()
{
var mre = new ManualResetEvent(false);
var cts = new CancellationTokenSource();
var task = WaitHandleAsyncFactory.FromWaitHandle(mre, Timeout.InfiniteTimeSpan, cts.Token);
Assert.False(task.IsCompleted);
cts.Cancel();
await AsyncAssert.CancelsAsync(task);
}
public async Task FromWaitHandle_CanceledBeforeHandleSignalled_CompletesCanceled()
{
ManualResetEvent mre = new ManualResetEvent(false);
CancellationTokenSource cts = new CancellationTokenSource();
Task task = WaitHandleAsyncFactory.FromWaitHandle(mre, cts.Token);
Assert.False(task.IsCompleted);
cts.Cancel();
await AsyncAssert.CancelsAsync(task).ConfigureAwait(false);
}
public async Task FromWaitHandle_HandleSignalledBeforeTimeout_CompletesWithTrueResult()
{
var mre = new ManualResetEvent(false);
var task = WaitHandleAsyncFactory.FromWaitHandle(mre, Timeout.InfiniteTimeSpan);
Assert.False(task.IsCompleted);
mre.Set();
var result = await task;
Assert.True(result);
}
public async Task FromWaitHandle_HandleSignalledBeforeTimeoutOrCanceled_CompletesWithTrueResult()
{
ManualResetEvent mre = new ManualResetEvent(false);
CancellationTokenSource cts = new CancellationTokenSource();
Task <bool> task = WaitHandleAsyncFactory.FromWaitHandle(mre, Timeout.InfiniteTimeSpan, cts.Token);
Assert.False(task.IsCompleted);
mre.Set();
bool result = await task;
Assert.True(result);
}
internal Task WaitForFenceAsync(ID3D12Fence fence, long fenceValue)
{
if (IsFenceComplete(fence, fenceValue))
{
return(Task.CompletedTask);
}
ManualResetEvent fenceEvent = new ManualResetEvent(false);
fence.SetEventOnCompletion(fenceValue, fenceEvent);
return(WaitHandleAsyncFactory.FromWaitHandle(fenceEvent));
}
internal Task WaitForFenceAsync(ID3D12Fence fence, long fenceValue)
{
if (IsFenceComplete(fence, fenceValue))
{
return(Task.CompletedTask);
}
lock (fenceLock)
{
fence.SetEventOnCompletion(fenceValue, fenceEvent);
return(WaitHandleAsyncFactory.FromWaitHandle(fenceEvent));
}
}
protected override async Task ExecuteAsync(CancellationToken ct)
{
int channel = _borderControlConfig.ServoConfig.ChannelNumber;
var objectInside = _communicationObject.ObjectInside;
var objectOutside = _communicationObject.ObjectOutside;
int openingDelay = _borderControlConfig.DelayBeforeOpeningMiliseconds;
using (var servoHat = new ServoHat(_borderControlConfig.ServoHatI2c))
{
servoHat.Init(_borderControlConfig.ServoConfig.ChannelNumber);
servoHat[_borderControlConfig.ServoConfig.ChannelNumber].Calibrate(
_borderControlConfig.ServoConfig.MaximumAngle,
_borderControlConfig.ServoConfig.MinimumPulseWidthMicroseconds,
_borderControlConfig.ServoConfig.MaximumPulseWidthMicroseconds);
servoHat[_borderControlConfig.ServoConfig.ChannelNumber].WriteAngle(90);
while (!ct.IsCancellationRequested)
{
Console.WriteLine("Open. Waiting for CLOSE signal...");
//wait for CLOSE signal periodically checking if exit requested
while (!await WaitHandleAsyncFactory.FromWaitHandle(objectInside, System.TimeSpan.FromSeconds(1), ct))
{
if (ct.IsCancellationRequested)
{
return;
}
}
servoHat[channel].WriteAngle(0);
do
{
Console.WriteLine("Close. CLOSE signal received. Waiting for OPEN signal...");
//wait for OPEN signal periodically checking if exit requested
while (!await WaitHandleAsyncFactory.FromWaitHandle(objectOutside, System.TimeSpan.FromSeconds(1), ct))
{
if (ct.IsCancellationRequested)
{
return;
}
}
Console.WriteLine("Close. OPEN signal received. Waiting 5sec...");
} while (await WaitHandleAsyncFactory.FromWaitHandle(objectInside, System.TimeSpan.FromMilliseconds(openingDelay)));
servoHat[channel].WriteAngle(90);
}
}
}
public Task WaitOneAsync() => WaitHandleAsyncFactory.FromWaitHandle(_argsWaitHandle);
