예제 #1
0
        async void TestBoundedBlockingQueueClearDispose()
        {
            BoundedBlockingQueue <TestQueueItem> bbq = new BoundedBlockingQueue <TestQueueItem>(3);

            bbq.TryEnqueue(new TestQueueItem {
                Value = 100
            });
            bbq.Enqueue(new TestQueueItem {
                Value = 200
            });

            Assert.Equal(2, bbq.Count);

            bbq.Enqueue(new TestQueueItem {
                Value = 300
            });

            Task.Run(async() =>
            {
                await Task.Delay(1000); //have to wait as new item will be enqueued immediately after clearing
                bbq.Enqueue(new TestQueueItem {
                    Value = 400
                });
            });

            bbq.Clear();

            Assert.Equal(0, bbq.Count);

            var result = bbq.TryDequeue(out var qItem);

            Assert.False(result);
            Assert.Null(qItem);

            await Task.Delay(1500);

            Assert.Equal(1, bbq.Count);
            var item400 = bbq.Dequeue();

            Assert.Equal(400, item400.Value);
            Assert.Equal(0, bbq.Count);

            bool threwObjectDisposedEx = false;

            Task.Run(() =>
            {
                try
                {
                    bbq.Dequeue();
                }
                catch (ObjectDisposedException ex)
                {
                    threwObjectDisposedEx = true;
                }
            });

            await Task.Delay(1500);

            bbq.Dispose();

            await Task.Delay(1500);

            Assert.True(threwObjectDisposedEx);

            Assert.True(bbq.IsDisposed);

            Assert.Throws <ObjectDisposedException>(() => bbq.Count);

            Assert.Throws <ObjectDisposedException>(() => bbq.Size);

            Assert.Throws <ObjectDisposedException>(() => bbq.QueueSyncRoot);

            Assert.Throws <ObjectDisposedException>(() => bbq.Values);

            Assert.Throws <ObjectDisposedException>(() => bbq.IsReadOnly);

            Assert.Throws <ObjectDisposedException>(() => bbq.Enqueue(new TestQueueItem {
                Value = 1000
            }));

            Assert.False(bbq.TryEnqueue(new TestQueueItem {
                Value = 1000
            }));

            Assert.Throws <ObjectDisposedException>(() => bbq.Peek());

            var resTryPeek = bbq.TryPeek(out var itemPeek);

            Assert.False(resTryPeek);
            Assert.Null(itemPeek);

            Assert.Throws <ObjectDisposedException>(() => bbq.Dequeue());

            var resTryDeq = bbq.TryDequeue(out var itemDequeue);

            Assert.False(resTryDeq);
            Assert.Null(itemDequeue);

            Assert.Throws <ObjectDisposedException>(() => bbq.Contains(new TestQueueItem {
                Value = 1000
            }));
            Assert.Throws <ObjectDisposedException>(() => bbq.CopyTo(new TestQueueItem[3], 0));

            Assert.Throws <ObjectDisposedException>(() => bbq.GetEnumerator());
            Assert.Throws <ObjectDisposedException>(() => (bbq as IEnumerable).GetEnumerator());
        }