public void FinallyAddRemoveThreadSafe()
        {
            var called = 0;
            var value  = new Exception();

            var token = new MutableAsyncToken <MyClass>();

            void FinallyAction(IMutableAsyncToken <MyClass> result)
            {
                called++;

                Assert.AreSame(token, result);

                token.Remove(FinallyAction);
            }

            token.OnFinally(_ =>
            {
                token.Remove(FinallyAction);
            });
            token.OnFinally(FinallyAction);

            token.Fail(value);

            Assert.AreEqual(1, called);
        }
        public void FinallyMulti()
        {
            var called = 0;
            var value  = new Exception();

            var token = new MutableAsyncToken <MyClass>();

            token
            .OnFinally(result =>
            {
                called++;

                Assert.AreSame(token, result);
            });

            token.Fail(value);
            token.Fail(value);

            Assert.AreEqual(2, called);
        }
        public void FailMulti()
        {
            var called = 0;
            var value  = new Exception();

            var token = new MutableAsyncToken <MyClass>();

            token
            .OnFailure(result =>
            {
                called++;

                Assert.AreSame(value, result);
            })
            .OnSuccess(exception => throw new Exception());

            token.Fail(value);
            token.Fail(value);

            Assert.AreEqual(2, called);
        }
        public void FailAddRemove()
        {
            var called = 0;
            var value  = new Exception();

            var token = new MutableAsyncToken <MyClass>();

            token.Fail(value);

            void FailAction(Exception result)
            {
                called++;

                Assert.AreSame(value, result);
            }

            token.OnFailure(FailAction);
            token.Remove(FailAction);

            token.Fail(value);

            Assert.AreEqual(1, called);
        }
        public void FinallyPost()
        {
            var isCalled = false;
            var value    = new Exception();

            var token = new MutableAsyncToken <MyClass>();

            token.Fail(value);

            token
            .OnFinally(result =>
            {
                isCalled = true;

                Assert.AreSame(token, result);
            });

            Assert.IsTrue(isCalled);
        }
        public void FailPost()
        {
            var isCalled = false;
            var value    = new Exception();

            var token = new MutableAsyncToken <MyClass>();

            token.Fail(value);

            token
            .OnFailure(result =>
            {
                isCalled = true;

                Assert.AreSame(value, result);
            })
            .OnSuccess(result => throw new Exception());

            Assert.IsTrue(isCalled);
        }