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

                var result = await queues.EnqueueToAnyAsync(13);
                var dequeueResult = await queue2.DequeueAsync();

                Assert.AreSame(queue2, result);
                Assert.AreEqual(13, dequeueResult);
            });
        }
        public void EnqueueToAnyAsync_MultipleHaveRoom_OnlyEnqueuesOne()
        {
            Test.Async(async () =>
            {
                var queue1 = new AsyncProducerConsumerQueue<int>();
                var queue2 = new AsyncProducerConsumerQueue<int>();
                var queues = new[] { queue1, queue2 };

                var result = await queues.EnqueueToAnyAsync(13);
                Task task = ((result == queue1) ? queue2 : queue1).DequeueAsync();
                await result.DequeueAsync();

                await AssertEx.NeverCompletesAsync(task);
            });
        }
        public void EnqueueToAnyAsync_Cancelled_Throws()
        {
            Test.Async(async () =>
            {
                var queue1 = new AsyncProducerConsumerQueue<int>(new[] { 13 }, 1);
                var queue2 = new AsyncProducerConsumerQueue<int>(new[] { 13 }, 1);
                var queues = new[] { queue1, queue2 };
                var cts = new CancellationTokenSource();
                var task = queues.EnqueueToAnyAsync(7, cts.Token);

                cts.Cancel();

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

                await queue1.DequeueAsync();
                var result = await task;

                Assert.AreSame(queue1, result);
            });
        }
        public void EnqueueToAnyAsync_Full_DoesNotComplete()
        {
            Test.Async(async () =>
            {
                var queue1 = new AsyncProducerConsumerQueue<int>(new[] { 13 }, 1);
                var queue2 = new AsyncProducerConsumerQueue<int>(new[] { 13 }, 1);
                var queues = new[] { queue1, queue2 };

                var task = queues.EnqueueToAnyAsync(7);

                await AssertEx.NeverCompletesAsync(task);
            });
        }
        public void EnqueueToAnyAsync_CompleteAdding_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.EnqueueToAnyAsync(3));
            });
        }