public async Task CatchExceptionFromAsyncFunction()
{
// Assign
var queue = new SerialQueue();
var exceptionCatched = false;
// Act
await queue.Enqueue(() => Thread.Sleep(10));
try {
await queue.Enqueue(asyncFunction : async() => {
await Task.Delay(50);
throw new Exception("Test");
#pragma warning disable CS0162 // Unreachable code detected
return(false);
#pragma warning restore CS0162 // Unreachable code detected
});
}
catch (Exception e) {
if (e.Message == "Test")
{
exceptionCatched = true;
}
}
// Assert
Assert.True(exceptionCatched);
}
public async Task CatchExceptionFromAsyncAction()
{
// Assign
var queue = new SerialQueue();
var exceptionCatched = false;
// Act
await queue.Enqueue(() => Thread.Sleep(10));
try {
await queue.Enqueue(async() => {
await Task.Delay(50);
throw new Exception("Test");
});
}
catch (Exception e) {
if (e.Message == "Test")
{
exceptionCatched = true;
}
}
// Assert
Assert.True(exceptionCatched);
}
public void EnqueueFromMultipleThreads()
{
// Assign
const int count = 10000;
var queue = new SerialQueue();
var list = new List <int>();
// Act
var counter = 0;
for (int i = 0; i < count; i++)
{
Task.Run(() => {
queue.Enqueue(() => list.Add(counter++));
});
}
while (list.Count != count)
{
}
;
// Assert
Assert.True(list.SequenceEqual(Enumerable.Range(0, count)));
}
public async Task QueueFunction()
{
// Assign
var queue = new SerialQueue();
var list = new List <int>();
var tasks = new List <Task <int> >();
var range = Enumerable.Range(0, 10000);
// Act
foreach (var number in range)
{
tasks.Add(queue.Enqueue(() => {
list.Add(number);
return(number);
}));
}
await Task.WhenAll(tasks);
// Assert
Assert.True(tasks.Select(x => x.Result).SequenceEqual(list));
}
public async Task EnqueueAsyncAction()
{
// Assign
var queue = new SerialQueue();
var list = new List <int>();
var tasks = new List <Task>();
var range = Enumerable.Range(0, 5000);
// Act
foreach (var number in range)
{
tasks.Add(queue.Enqueue(async() => {
await Task.Delay(1);
list.Add(number);
}));
}
await Task.WhenAll(tasks);
// Assert
Assert.True(range.SequenceEqual(list));
}
public async Task EnqueueMixed()
{
// Assign
var queue = new SerialQueue();
var list = new List <int>();
var tasks = new List <Task>();
var range = Enumerable.Range(0, 10000);
// Act
foreach (var number in range)
{
if (number % 4 == 0)
{
tasks.Add(queue.Enqueue(() => list.Add(number)));
}
else if (number % 3 == 0)
{
tasks.Add(queue.Enqueue(() => {
list.Add(number);
return(number);
}));
}
else if (number % 2 == 0)
{
tasks.Add(queue.Enqueue(async() => {
await Task.Delay(1);
list.Add(number);
}));
}
else
{
tasks.Add(queue.Enqueue(async() => {
await Task.Delay(1);
list.Add(number);
return(number);
}));
}
}
await Task.WhenAll(tasks);
// Assert
Assert.True(range.SequenceEqual(list));
}
/**
* <summary>
* Schedules new transaction request
* <see cref="SendTransaction(Newtonsoft.Json.Linq.JObject,string,string,BluzelleCSharp.Models.GasInfo)" /> into FIFO
* task queue.
* Method will wait until all request before it are done and returns this transaction result via <see cref="Task" />
* </summary>
* <param name="data">Transaction data</param>
* <param name="type">HTTP-style transaction request type</param>
* <param name="cmd">Transaction command</param>
* <param name="gasInfo">Gas used to execute transaction</param>
* <exception cref="Exceptions.InvalidChainIdException"></exception>
* <exception cref="Exceptions.TransactionExecutionException"></exception>
* <exception cref="KeyNotFoundException"></exception>
* <returns>JObject contains decoded transaction result</returns>
*/
public Task <JObject> SendTransaction(
JObject data,
string type,
string cmd,
GasInfo gasInfo = null)
{
return(_transactionQueue.Enqueue(() => ExecuteTransaction(data, type, cmd, gasInfo)));
}
public async Task <int> OpenBoil(string s)
{
await queue.Enqueue(() => {
BoilWorking(s);
});
return(watierTempperature);
}
