public void Count_nonempty()
{
var queue = new AsyncQueue<string>();
queue.Enqueue("A");
queue.Enqueue("B");
queue.Enqueue("C");
queue.Enqueue("D");
Assert.IsTrue(queue.TryDequeue());
Assert.AreEqual(3, queue.Count);
}
public void Items_should_be_dequeued_in_the_order_they_were_enqueued_2()
{
var subject = new AsyncQueue<int>();
var result = subject.DequeueAsync(CancellationToken.None);
var result2 = subject.DequeueAsync(CancellationToken.None);
subject.Enqueue(10);
subject.Enqueue(11);
result.Result.Should().Be(10);
result2.Result.Should().Be(11);
}
public void DequeueAsync_before_Enqueue()
{
var queue = new AsyncQueue<string>();
var task = queue.DequeueAsync().AssertNotCompleted();
queue.Enqueue("A");
task.AssertResult("A");
}
public async Task DequeueThenEnqueue()
{
var queue = new AsyncQueue<int>();
var task = queue.DequeueAsync();
Assert.False(task.IsCompleted);
queue.Enqueue(13);
Assert.Equal(13, await task.ConfigureAwait(false));
}
public void Dequeue_should_complete_when_an_item_is_added_to_the_queue()
{
var subject = new AsyncQueue<int>();
var result = subject.DequeueAsync(CancellationToken.None);
subject.Enqueue(10);
result.Result.Should().Be(10);
}
public void Enqueue()
{
var queue = new AsyncQueue<int>();
queue.Enqueue(42);
var task = queue.DequeueAsync();
Assert.True(task.IsCompleted);
Assert.Equal(42, task.Result);
}
public void DequeueAll_should_dequeue_all_items(int n)
{
var subject = new AsyncQueue<int>();
for (var i = 0; i < n; i++)
{
subject.Enqueue(i);
}
var count = subject.DequeueAll().Count();
count.Should().Be(n);
}
public void DequeueAsync_canceled_after_completion()
{
var queue = new AsyncQueue<string>();
queue.Enqueue("A");
using (var cts = new CancellationTokenSource())
{
var task = queue.DequeueAsync(cts.Token);
cts.Cancel();
task.AssertResult("A");
}
}
public async Task DequeueManyThenEnqueueMany()
{
var queue = new AsyncQueue<int>();
var count = 4;
var list = new List<Task<int>>();
for (var i = 0; i < count; i++)
{
list.Add(queue.DequeueAsync());
}
for (var i = 0; i < count; i++)
{
var task = list[i];
Assert.False(task.IsCompleted);
queue.Enqueue(i);
Assert.Equal(i, await task.ConfigureAwait(false));
}
}
public void TryDequeue()
{
var queue = new AsyncQueue<int>();
int value;
Assert.False(queue.TryDequeue(out value));
queue.Enqueue(13);
Assert.True(queue.TryDequeue(out value));
Assert.Equal(13, value);
}
public async Task DequeueAsyncWithCancellationAfterComplete()
{
var queue = new AsyncQueue<int>();
var cts = new CancellationTokenSource();
var task = queue.DequeueAsync(cts.Token);
Assert.False(task.IsCompleted);
queue.Enqueue(42);
await task.ConfigureAwait(false);
cts.Cancel();
}
private async Task PutItems(string prefix, AsyncQueue<string> dest, List<Item> items)
{
foreach(Item i in items)
{
await Task.Delay(i.delay);
await dest.Enqueue(prefix + i.value, CancellationToken.None);
}
dest.WriteEof();
}
private async Task CompleteAnyWithCancellationAsync()
{
AsyncQueue<string> q1 = new AsyncQueue<string>(5);
AsyncQueue<string> q2 = new AsyncQueue<string>(5);
Func<Task> producer1 = async delegate ()
{
await Task.Delay(2500);
await q1.Enqueue("one", CancellationToken.None);
q1.WriteEof();
};
Func<Task> producer2 = async delegate ()
{
await Task.Delay(5500);
await q2.Enqueue("two", CancellationToken.None);
q2.WriteEof();
};
Func<Task> consumer = async delegate ()
{
bool q1eof = false;
bool q2eof = false;
while (!q1eof || !q2eof)
{
Tuple<int, string> r1 = null;
using (CancellationTokenSource s1 = new CancellationTokenSource(1000))
{
try
{
r1 = await Utils.OperationStarters<int, string>()
.AddIf(!q1eof, 1, Utils.StartableGet(q1, x => x, null))
.AddIf(!q2eof, 2, Utils.StartableGet(q2, x => x, null))
.CompleteAny(s1.Token);
}
catch (OperationCanceledException)
{
}
}
if (r1 == null)
{
System.Diagnostics.Debug.WriteLine("Cancelled (because of timeout)");
}
else if (r1.Item1 == 1)
{
if (r1.Item2 == null)
{
System.Diagnostics.Debug.WriteLine("Got EOF from 1");
q1eof = true;
}
else
{
System.Diagnostics.Debug.WriteLine($"Got {r1.Item2} from 1");
}
}
else
{
Assert.AreEqual(2, r1.Item1);
if (r1.Item2 == null)
{
System.Diagnostics.Debug.WriteLine("Got EOF from 2");
q2eof = true;
}
else
{
System.Diagnostics.Debug.WriteLine($"Got {r1.Item2} from 2");
}
}
}
};
Task p1 = Task.Run(producer1);
Task p2 = Task.Run(producer2);
Task c = Task.Run(consumer);
await Task.WhenAll(p1, p2, c);
}
public async Task DequeueAfterCompleteWithData()
{
var queue = new AsyncQueue<int>();
queue.Enqueue(42);
queue.Complete();
await queue.WhenCompletedTask.ConfigureAwait(false);
Assert.Equal(42, await queue.DequeueAsync().ConfigureAwait(false));
var threw = false;
try
{
await queue.DequeueAsync().ConfigureAwait(false);
}
catch (OperationCanceledException)
{
threw = true;
}
Assert.True(threw);
}
public void DequeueAsync_handled_in_order_of_caller()
{
var queue = new AsyncQueue<string>();
var values = new List<string> { "A", "B", "C" };
var tasks = values.Select(_ => queue.DequeueAsync()).ToList();
for (int i = 0; i < values.Count; i++)
{
tasks[i].AssertNotCompleted();
queue.Enqueue(values[i]);
tasks[i].AssertResult(values[i]);
}
}
public void Should_be_not_empty_after_enqueue()
{
using var queue = new AsyncQueue <int>();
queue.Enqueue(42);
queue.Count.Should().Be(1);
}
internal void EnqueueCommand(Command command)
{
writeCommandQueue.Enqueue(command);
}
public SimpleDiagnosticQueue(Diagnostic diagnostic)
{
_queue = new AsyncQueue<Diagnostic>();
_queue.Enqueue(diagnostic);
}
private async Task ExtMethodQueueTestAsync()
{
AsyncQueue<string> q = new AsyncQueue<string>(5);
Func<Task> producer = async delegate ()
{
#region
for (int i = 0; i < 20; ++i)
{
System.Diagnostics.Debug.WriteLine($"Writing {i}...");
await q.Enqueue($"Value: {i}", CancellationToken.None);
}
System.Diagnostics.Debug.WriteLine("Writing EOF...");
q.WriteEof();
#endregion
};
Func<Task> consumer = async delegate ()
{
#region
bool more = true;
while (more)
{
System.Diagnostics.Debug.WriteLine("Reading...");
Option<string> ostr = await q.Dequeue(CancellationToken.None);
if (ostr.HasValue)
{
System.Diagnostics.Debug.WriteLine($"Read {ostr.Value}");
}
else
{
System.Diagnostics.Debug.WriteLine("Read EOF...");
more = false;
}
}
#endregion
};
Task tProducer = Task.Run(producer);
Task tConsumer = Task.Run(consumer);
await Task.WhenAll(tProducer, tConsumer);
}
public void First_in_first_out()
{
var queue = new AsyncQueue<string>();
var values = new List<string> { "A", "B", "C" };
for (int i = 0; i < values.Count; i++)
{
queue.Enqueue(values[i]);
}
for (int i = 0; i < values.Count; i++)
{
queue.DequeueAsync().AssertResult(values[i]);
}
}
public async Task TryDequeueAfterComplete()
{
var queue = new AsyncQueue<int>();
queue.Enqueue(13);
queue.Complete();
await queue.WhenCompletedTask.ConfigureAwait(false);
int value;
Assert.True(queue.TryDequeue(out value));
Assert.Equal(13, value);
}
public void TryPeek_nonempty()
{
var queue = new AsyncQueue<string>();
queue.Enqueue("A");
string value;
Assert.IsTrue(queue.TryPeek(out value));
Assert.AreEqual("A", value);
Assert.AreEqual(1, queue.Count);
}
public void DequeueAsync_already_canceled()
{
var queue = new AsyncQueue<string>();
queue.Enqueue("A");
queue.DequeueAsync(new CancellationToken(true)).AssertCanceled();
}
public void EnqueueAfterComplete()
{
var queue = new AsyncQueue<int>();
queue.Complete();
Assert.Throws(typeof(InvalidOperationException), () => queue.Enqueue(42));
}
public void DequeueAsync_empty_canceled()
{
var queue = new AsyncQueue<string>();
using (var cts = new CancellationTokenSource())
{
var task = queue.DequeueAsync(cts.Token);
cts.Cancel();
queue.Enqueue("A");
task.AssertCanceled();
}
}
public async Task <IEnumerable <FtpEntry> > ListFilesRecursiveAsync(string startPath = null, Predicate <FtpEntry> skipFolder = null, CancellationToken ctk = default)
{
startPath = startPath ?? "./";
if (skipFolder == null)
{
skipFolder = x => false;
}
List <Task <IEnumerable <FtpEntry> > > pending = new List <Task <IEnumerable <FtpEntry> > >();
IEnumerable <FtpEntry> files = new List <FtpEntry>();
using (var d = new DisposableContainer())
{
var clientsQueue = new AsyncQueue <FluentFTP.IFtpClient>(5);
for (int i = 0; i < 5; i++)
{
var c = _getClient();
d.Add(c);
await clientsQueue.Enqueue(c, ctk);
}
Func <string, CancellationToken, Task <IEnumerable <FtpEntry> > > listFolderAsync = async(string path, CancellationToken ct) =>
{
var c = await clientsQueue.Dequeue(ct);
try
{
var retrier = Policy
.Handle <Exception>()
.WaitAndRetryAsync(new[]
{
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(15)
}, (ex, ts) =>
{
_logger.Warn(ex, "Failed to list folder {0}. Try again soon ...", path);
});
var res = await retrier.ExecuteAsync(ct1 =>
{
return(c.Value.GetListingAsync(path));
}, ct).ConfigureAwait(false);
return(res.Select(x => new FtpEntry()
{
FullPath = x.FullName,
IsDirectory = x.Type == FtpFileSystemObjectType.Directory,
Modified = x.Modified,
Name = x.Name,
Size = x.Size
}).ToList());
} finally
{
await clientsQueue.Enqueue(c.Value, ct);
}
};
pending.Add(listFolderAsync(startPath, ctk));
while (pending.Count > 0 && !ctk.IsCancellationRequested)
{
var completedTask = await Task.WhenAny(pending).ConfigureAwait(false);
pending.Remove(completedTask);
// task could have completed with errors ... strange, let them progate.
var list = await completedTask.ConfigureAwait(false);
//we want to exclude folders . and .. that we dont want to search
foreach (var dir in list.Where(x => x.IsDirectory && !x.Name.Equals(".") && !x.Name.Equals("..")))
{
if (skipFolder.Invoke(dir))
{
_logger.Debug("Skipping folder: {0}", dir.FullPath);
}
else
{
pending.Add(listFolderAsync(dir.FullPath, ctk));
}
}
files = files.Concat(list.Where(x => !x.IsDirectory));
}
ctk.ThrowIfCancellationRequested();
return(files.ToList());
}
}
public override void SendData(byte[] data)
{
outbox.Enqueue(data);
StartSend();
}