Пример #1
0
        public void TestDisposeAsYouGo_AnyAndEnumerate()
        {
            lock (typeof(SimpleDisposable)) {
                // ensure we're starting clean
                SimpleDisposable.Reset();

                var items = SimpleDisposable.GetSome(10).DisposeAsYouGo();

                // should call the DAYG 'any'
                Assert.True(items.Any());

                if (items.Any())
                {
                    // once you start you have to either enumerate the collection
                    // or dispose of the enumerable.
                    foreach (var i in items)
                    {
                        Console.Write($"each : {i.Number}   ");
                    }
                    Console.WriteLine();
                }

                // we can see that a disposable was created, and by disposing of the enumerable
                // we have cleaned up.
                Assert.False(SimpleDisposable.UndisposedItems.Any());
            }
        }
Пример #2
0
        public void TestDisposeAsYouGo_WorksWithNonDisposableToo()
        {
            lock (typeof(SimpleDisposable)) {
                // ensure we're starting clean
                SimpleDisposable.Reset();

                // it's safe to use on non-disposable enumerables too.
                using (var items = new[] { "each", "item", "is", "fun" }.DisposeAsYouGo()) {
                    // Should be some items.
                    Assert.True(items.Any());
                }

                // we can see that everything disposable that was created, has been disposed
                Assert.False(SimpleDisposable.UndisposedItems.Any());

                // because you might have something to dispose of after the collection is run.
                using (var items = new[] { "each", "item", "is", "fun" }.DisposeAsYouGo(new SimpleDisposable())) {
                    // Should be some items.
                    Assert.True(items.Any());
                }

                // we can see that everything disposable that was created, has been disposed
                Assert.False(SimpleDisposable.UndisposedItems.Any());

                var didItWork = false;
                // any disposable can be used on the tail end.
                using (var items = new[] { "each", "item", "is", "fun" }.DisposeAsYouGo(new OnDispose(() => { didItWork = true; }))) {
                    // Should be some items.
                    Assert.True(items.Any());
                }

                Assert.True(didItWork);
            }
        }
Пример #3
0
        public void TestDisposeAsYouGo_Any()
        {
            lock (typeof(SimpleDisposable)) {
                // ensure we're starting clean
                SimpleDisposable.Reset();

                var items = SimpleDisposable.GetSome(10).DisposeAsYouGo();

                // should call the DAYG 'any'
                Assert.True(items.Any());

                if (items.Any())
                {
                    // once you start you have to either enumerate the collection
                    // or dispose of the enumerable.
                    items.Dispose();
                }

                var more = SimpleDisposable.GetSome(0).DisposeAsYouGo();

                // should not find any items.
                Assert.False(more.Any());

                // I've used Any(), but nothing was found.
                // I should still dispose of more, but nothing was created.

                // we can see that everything disposable that was created, has been disposed
                Assert.False(SimpleDisposable.UndisposedItems.Any());
            }
        }
Пример #4
0
        public void TestLeakOfIDisposable()
        {
            lock (typeof(SimpleDisposable)) {
                // ensure we're starting clean
                SimpleDisposable.Reset();

                var items = SimpleDisposable.GetSome(10);

                // show that this would normally leak
                Assert.True(items.Any());

                // we can see that a disposable was created and nobody cared.
                Assert.True(SimpleDisposable.UndisposedItems.Any());
            }
        }
Пример #5
0
        public void TestDisposeAsYouGo_AnyWithDisposeAfterLeaksWhenImproperlyUsed()
        {
            lock (typeof(SimpleDisposable)) {
                // ensure we're starting clean
                SimpleDisposable.Reset();

                // but if we add something to dispose after, we should have disposed of the collection
                var evenmore = SimpleDisposable.GetSome(0).DisposeAsYouGo(new SimpleDisposable());

                // still no items.
                Assert.False(evenmore.Any());

                // we can see that a disposable was created and nobody cared.
                Assert.True(SimpleDisposable.UndisposedItems.Any());
            }
        }
Пример #6
0
        public void TestDisposeAsYouGo_AnyWithDisposeAfterIsOkWhenProperlyUsed()
        {
            lock (typeof(SimpleDisposable)) {
                // ensure we're starting clean
                SimpleDisposable.Reset();

                // but if we add something to dispose after, we should have disposed of the collection
                using (var evenmore = SimpleDisposable.GetSome(0).DisposeAsYouGo(new SimpleDisposable())) {
                    // still no items.
                    Assert.False(evenmore.Any());
                }

                // we can see that everything disposable that was created, has been disposed
                Assert.False(SimpleDisposable.UndisposedItems.Any());
            }
        }