public void TryEnqueueToAnyAsync_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.TryEnqueueToAnyAsync(7, cts.Token);

                cts.Cancel();

                await AssertEx.ThrowsExceptionAsync<OperationCanceledException>(() => task);
            });
        }
        public void TryEnqueueToAnyAsync_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.TryEnqueueToAnyAsync(7);

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

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

                var result = await queues.TryEnqueueToAnyAsync(3);

                Assert.IsNull(result);
            });
        }
        public void TryEnqueueToAnyAsync_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.TryEnqueueToAnyAsync(7);

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

                var result = await queues.TryEnqueueToAnyAsync(13);
                var dequeueResult = await queue1.DequeueAsync();

                Assert.AreSame(queue1, result);
                Assert.AreEqual(13, dequeueResult);
            });
        }