public void DequeueFromAnyAsync_MultipleHaveEntries_OnlyDequeuesOne()
        {
            Test.Async(async () =>
            {
                var queue1 = new AsyncProducerConsumerQueue<int>(new[] { 5 });
                var queue2 = new AsyncProducerConsumerQueue<int>(new[] { 7 });
                var queues = new[] { queue1, queue2 };

                var result = await queues.DequeueFromAnyAsync();
                await ((result.Queue == queue1) ? queue2 : queue1).DequeueAsync();
            });
        }
        public void DequeueFromAnyAsync_Cancelled_Throws()
        {
            Test.Async(async () =>
            {
                var queue1 = new AsyncProducerConsumerQueue<int>();
                var queue2 = new AsyncProducerConsumerQueue<int>();
                var queues = new[] { queue1, queue2 };
                var cts = new CancellationTokenSource();
                var task = queues.DequeueFromAnyAsync(cts.Token);

                cts.Cancel();

                await AssertEx.ThrowsExceptionAsync<OperationCanceledException>(() => task);
            });
        }
        public void DequeueFromAnyAsync_Empty_DoesNotComplete()
        {
            Test.Async(async () =>
            {
                var queue1 = new AsyncProducerConsumerQueue<int>();
                var queue2 = new AsyncProducerConsumerQueue<int>();
                var queues = new[] { queue1, queue2 };

                var task = queues.DequeueFromAnyAsync();

                await AssertEx.NeverCompletesAsync(task);
            });
        }
        public void DequeueFromAnyAsync_Empty_ItemAdded_Completes()
        {
            Test.Async(async () =>
            {
                var queue1 = new AsyncProducerConsumerQueue<int>();
                var queue2 = new AsyncProducerConsumerQueue<int>();
                var queues = new[] { queue1, queue2 };
                var task = queues.DequeueFromAnyAsync();

                await queue2.EnqueueAsync(13);
                var result = await task;

                Assert.IsTrue(result.Success);
                Assert.AreSame(queue2, result.Queue);
                Assert.AreEqual(13, result.Item);
            });
        }
        public void DequeueFromAnyAsync_EmptyAndComplete_ThrowsException()
        {
            Test.Async(async () =>
            {
                var queue1 = new AsyncProducerConsumerQueue<int>();
                queue1.CompleteAdding();
                var queue2 = new AsyncProducerConsumerQueue<int>();
                queue2.CompleteAdding();
                var queues = new[] { queue1, queue2 };

                await AssertEx.ThrowsExceptionAsync<InvalidOperationException>(() => queues.DequeueFromAnyAsync());
            });
        }