public void FromEvent1_EventNeverRaised_NeverCompletes()
{
Test.Async(async() =>
{
var timer = new Timer();
var task = AsyncFactory <ElapsedEventArgs> .FromEvent(timer, "Elapsed");
await AssertEx.NeverCompletesAsync(task);
});
}
public void FromEvent1_EventNeverRaised_NeverCompletes()
{
AsyncContext.Run(async() =>
{
var timer = new System.Timers.Timer();
var task = AsyncFactory <ElapsedEventArgs> .FromEvent(timer, "Elapsed");
await AssertEx.NeverCompletesAsync(task);
});
}
public void Args9()
{
Test.Async(async() =>
{
IntReference counter = new IntReference();
await AsyncFactory.FromApm(BeginSuccess9, End, counter, counter, counter, counter, counter, counter, counter, counter, counter);
Assert.AreEqual(1, counter.Value);
});
}
public void Args14()
{
AsyncContext.Run(async() =>
{
IntReference counter = new IntReference();
await AsyncFactory.FromApm(BeginSuccess14, End, counter, counter, counter, counter, counter, counter, counter, counter, counter, counter, counter, counter, counter, counter);
Assert.AreEqual(1, counter.Value);
});
}
public static IAsyncResult BeginSend(
this DicomClient @this,
INetworkStream stream,
string callingAe,
string calledAe,
AsyncCallback callback,
object state)
{
return(AsyncFactory.ToBegin(@this.SendAsync(stream, callingAe, calledAe), callback, state));
}
public static IAsyncResult BeginRead(
this DicomReader @this,
IByteSource source,
IDicomReaderObserver observer,
Func <ParseState, bool> stop,
AsyncCallback callback,
object state)
{
return(AsyncFactory.ToBegin(@this.ReadAsync(source, observer, stop), callback, state));
}
public static IAsyncResult BeginWrite(
this DicomFileWriter @this,
IByteTarget target,
DicomFileMetaInformation fileMetaInfo,
DicomDataset dataset,
AsyncCallback callback,
object state)
{
return(AsyncFactory.ToBegin(@this.WriteAsync(target, fileMetaInfo, dataset), callback, state));
}
public void FromWaitHandle_TimeoutBeforeHandleSignalled_CompletesWithFalseResult()
{
AsyncContext.Run(() => Task.Run(async() =>
{
var mre = new ManualResetEvent(false);
var task = AsyncFactory.FromWaitHandle(mre, TimeSpan.FromMilliseconds(10));
var result = await task;
Assert.IsFalse(result);
}));
}
public static IAsyncResult BeginRead(
this DicomFileReader @this,
IByteSource source,
IDicomReaderObserver fileMetaInfo,
IDicomReaderObserver dataset,
AsyncCallback callback,
object state)
{
return(AsyncFactory.ToBegin(@this.ReadAsync(source, fileMetaInfo, dataset), callback, state));
}
public void FromWaitHandle_TimeoutBeforeHandleSignalledOrCanceled_CompletesWithFalseResult()
{
Test.Async(async() =>
{
var mre = new ManualResetEvent(false);
var cts = new CancellationTokenSource();
var task = AsyncFactory.FromWaitHandle(mre, TimeSpan.FromMilliseconds(10), cts.Token);
var result = await task;
Assert.IsFalse(result);
});
}
public void FromWaitHandle_HandleSignalled_Completes()
{
AsyncContext.Run(() => Task.Run(async() =>
{
var mre = new ManualResetEvent(false);
var task = AsyncFactory.FromWaitHandle(mre);
Assert.IsFalse(task.IsCompleted);
mre.Set();
await task;
}));
}
protected Task IfHasPendingThenFlushTrackingRecordsAsync()
{
if (this.Controller.HasPendingTrackingRecords)
{
return(AsyncFactory.FromApm <TimeSpan>(this.Controller.BeginFlushTrackingRecords, this.Controller.EndFlushTrackingRecords, this.Parameters.TrackingTimeout));
}
else
{
return(TaskConstants.Completed);
}
}
public void FromEvent1_AsyncEventNeverRaised_NeverCompletes()
{
AsyncContext.Run(() => Task.Run(async() =>
{
var bgw = new BackgroundWorker();
bgw.DoWork += (_, __) => { new Semaphore(0, 1).WaitOne(); };
var task = AsyncFactory <RunWorkerCompletedEventArgs> .FromEvent(bgw, "RunWorkerCompleted");
bgw.RunWorkerAsync();
await AssertEx.NeverCompletesAsync(task);
}));
}
public void FromWaitHandle_HandleSignalledBeforeCanceled_CompletesSuccessfully()
{
AsyncContext.Run(() => Task.Run(async() =>
{
var mre = new ManualResetEvent(false);
var cts = new CancellationTokenSource();
var task = AsyncFactory.FromWaitHandle(mre, cts.Token);
Assert.IsFalse(task.IsCompleted);
mre.Set();
await task;
}));
}
public static IAsyncResult BeginSend(
this DicomClient @this,
string host,
int port,
bool useTls,
string callingAe,
string calledAe,
AsyncCallback callback,
object state)
{
return(AsyncFactory.ToBegin(@this.SendAsync(host, port, useTls, callingAe, calledAe), callback, state));
}
protected sealed override void EndExecute(AsyncCodeActivityContext context, IAsyncResult asyncResult)
{
try
{
AsyncFactory.ToEnd(asyncResult);
PostExecute(context);
}
catch (OperationCanceledException) when(context.IsCancellationRequested)
{
context.MarkCanceled();
}
}
protected sealed override void EndExecute(AsyncCodeActivityContext context, IAsyncResult asyncResult)
{
try
{
AsyncFactory.ToEnd(asyncResult);
PostExecute(context, (context.UserState as Tuple <TState, CancellationTokenSource>).Item1);
}
catch (OperationCanceledException) when(context.IsCancellationRequested)
{
context.MarkCanceled();
}
}
public void FromWaitHandle_CanceledBeforeTimeoutOrHandleSignalled_CompletesCanceled()
{
AsyncContext.Run(() => Task.Run(async() =>
{
var mre = new ManualResetEvent(false);
var cts = new CancellationTokenSource();
var task = AsyncFactory.FromWaitHandle(mre, Timeout.InfiniteTimeSpan, cts.Token);
Assert.IsFalse(task.IsCompleted);
cts.Cancel();
await AssertEx.CompletesCanceledAsync(task);
}));
}
public void FromWaitHandle_CanceledBeforeHandleSignalled_CompletesCanceled()
{
Test.Async(async() =>
{
var mre = new ManualResetEvent(false);
var cts = new CancellationTokenSource();
var task = AsyncFactory.FromWaitHandle(mre, cts.Token);
Assert.IsFalse(task.IsCompleted);
cts.Cancel();
await AssertEx.CompletesCanceledAsync(task);
});
}
public void FromWaitHandle_HandleSignalledBeforeTimeout_CompletesWithTrueResult()
{
AsyncContext.Run(() => Task.Run(async() =>
{
var mre = new ManualResetEvent(false);
var task = AsyncFactory.FromWaitHandle(mre, Timeout.InfiniteTimeSpan);
Assert.IsFalse(task.IsCompleted);
mre.Set();
var result = await task;
Assert.IsTrue(result);
}));
}
public void FromEvent1_AsyncEventFailed_Fails()
{
AsyncContext.Run(() => Task.Run(async() =>
{
var bgw = new BackgroundWorker();
bgw.DoWork += (_, args) => { throw new NotImplementedException(); };
var task = AsyncFactory <RunWorkerCompletedEventArgs> .FromEvent(bgw, "RunWorkerCompleted");
bgw.RunWorkerAsync();
await AssertEx.ThrowsExceptionAsync <NotImplementedException>(task);
}));
}
public void TestCoComplete()
{
var obj = new GameObject();
obj.name = "Generated by unit test";
var o = obj.AddComponent <UnitTestObject>();
var f = AsyncFactory.Start <string>(() => {
return("ok");
});
o.Future = f;
}
public void FromWaitHandle_HandleSignalledBeforeTimeoutOrCanceled_CompletesWithTrueResult()
{
Test.Async(async() =>
{
var mre = new ManualResetEvent(false);
var cts = new CancellationTokenSource();
var task = AsyncFactory.FromWaitHandle(mre, TaskShim.InfiniteTimeSpan, cts.Token);
Assert.IsFalse(task.IsCompleted);
mre.Set();
var result = await task;
Assert.IsTrue(result);
});
}
public void TestAsyncError()
{
var e = new Exception("Error");
var f = AsyncFactory.Start <string>(() => {
Thread.Sleep(TimeSpan.FromSeconds(1));
throw e;
});
// not finished yet.
Assert.False(f.Done);
f.Wait();
Assert.Equals(e, f.Error);
}
public void FromEvent1_AsyncEventRaised_Completes()
{
AsyncContext.Run(() => Task.Run(async() =>
{
var bgw = new BackgroundWorker();
var o = new object();
bgw.DoWork += (_, args) => { args.Result = o; };
var task = AsyncFactory <RunWorkerCompletedEventArgs> .FromEvent(bgw, "RunWorkerCompleted");
bgw.RunWorkerAsync();
var result = await task;
Assert.AreSame(o, result.Result);
}));
}
public static async Task RequestData <T>(T request)
{
if (request == null)
{
throw new NullReferenceException("request is null");
}
if (!OpcodesBinding.RequestResponseTypes.ContainsKey(typeof(T)))
{
throw new ArgumentException("RequestResponseTypes doesn`t contain the response type");
}
Type responseType = OpcodesBinding.RequestResponseTypes[typeof(T)];
Packet packet = PacketBuilder.Build(request);
if (responseType != typeof(EmptyResponse))
{
if (!_dataUpdateNotifiers.ContainsKey(responseType))
{
_dataUpdateNotifiers[responseType] = new EventWaitHandle(false, EventResetMode.ManualReset);
}
_dataUpdateNotifiers[responseType].Reset();
}
try
{
await _controllerClient.SendAsync(_client, packet);
}
catch (SocketException ex)
{
_connected = false;
_client.Disconnect();
throw ex;
}
if (responseType != typeof(EmptyResponse))
{
bool isSignaled = await AsyncFactory.FromWaitHandle(
_dataUpdateNotifiers[responseType],
TimeSpan.FromMilliseconds(Config.DataTimeout));
if (!isSignaled)
{
throw new TimeoutException("Server didn`t respont in time");
}
}
}
public void TestAsyncSuccess()
{
var f = AsyncFactory.Start <string>(() => {
Thread.Sleep(TimeSpan.FromSeconds(1));
return("ok");
});
// not finished yet.
Assert.False(f.Done);
string v = f.Get();
Assert.Equal("ok", v);
}
public void FromEvent1_EventRaised_Completes()
{
AsyncContext.Run(async() =>
{
var timer = new System.Timers.Timer();
var task = AsyncFactory <ElapsedEventArgs> .FromEvent(timer, "Elapsed");
var start = DateTime.Now;
timer.Enabled = true;
var result = await task;
var end = DateTime.Now;
Assert.IsTrue(result.SignalTime >= start && result.SignalTime <= end);
});
}
public void FromEvent0_EventRaised_Completes()
{
Test.Async(async() =>
{
var timer = new Timer();
var task = AsyncFactory <ElapsedEventArgs> .FromEvent(timer);
var start = DateTime.Now;
timer.Enabled = true;
var result = await task;
var end = DateTime.Now;
Assert.IsTrue(result.SignalTime >= start && result.SignalTime <= end);
});
}
public void FromEvent1_AsyncEventCanceled_Cancels()
{
Test.Async(async() =>
{
var bgw = new BackgroundWorker();
bgw.WorkerSupportsCancellation = true;
bgw.DoWork += (_, args) => { while (!bgw.CancellationPending)
{
Thread.Sleep(100);
}
args.Cancel = true; };
var task = AsyncFactory <RunWorkerCompletedEventArgs> .FromEvent(bgw, "RunWorkerCompleted");
bgw.RunWorkerAsync();
bgw.CancelAsync();
await AssertEx.CompletesCanceledAsync(task);
});
}
