public void FutureWithFutureContentDisposedOnComplete()
        {
            var disposable = new DisposableTest();
            var future     = Future.Success(disposable);

            future.Dispose();

            Assert.Throws <FutureContentDisposed>(() => future.Complete(() => {}));
        }
        public void DerivedFutureToDisposableNotCallsDispose()
        {
            var disposable = new DisposableTest();
            var future     = Future.Success(disposable).Map((x) => {});

            future.Dispose();

            Assert.AreEqual(0, disposable.Disposed);
        }
        public void FutureToDisposableCallsDisposeWhenDisposed()
        {
            var disposable = new DisposableTest();
            var future     = Future.Success(disposable);

            future.Dispose();

            Assert.AreEqual(1, disposable.Disposed);
        }
        public void DisposedFuture()
        {
            var disposable = new DisposableTest();
            var promise    = new Promise <DisposableTest>();
            var future     = promise.Future;

            future.Dispose();

            promise.Fulfill(disposable);

            Assert.AreEqual(1, disposable.Disposed);
        }
        public void MultyMapSingleDispose()
        {
            var disposable = new DisposableTest();
            var promise    = new Promise <DisposableTest>();
            var future     = promise.Future;

            future.Map((x) => {});
            future.Map((x) => {});

            future.Dispose();

            promise.Fulfill(disposable);

            Assert.AreEqual(1, disposable.Disposed);
        }
        public void NotMapAsyncDisposedFuture()
        {
            var  disposable = new DisposableTest();
            var  promise    = new Promise <DisposableTest>();
            var  future     = promise.Future;
            bool called     = false;

            future.Map((x) => {
                called = true;
            });

            future.Dispose();

            promise.Fulfill(disposable);

            Assert.That(!called);
        }
        public void DirectRecoverDerivedAsyncDisposedFuture()
        {
            var  disposable = new DisposableTest();
            var  promise    = new Promise <DisposableTest>();
            var  future     = promise.Future;
            bool called     = false;

            future.Recover((e) => {
                called = true;
            });

            future.Dispose();

            promise.Fulfill(disposable);

            Assert.That(called);
        }