Example #1
0
        public void Dispose_FaultsAwaiters()
        {
            var lck = new Lock();

            using (var cts = new CancellationTokenSource())
            {
                var awaiters = new[]
                {
                    TaskAssert.Detach(lck.WaitAsync),
                    TaskAssert.Detach(() => lck.WaitAsync(cts.Token)),
                    TaskAssert.Detach(lck.WaitAsync),
                    TaskAssert.Detach(lck.WaitAsync)
                };

                cts.Cancel();
                lck.Dispose();

                using (TaskAssert.Completed(awaiters[0])) { }
                TaskAssert.Cancelled(awaiters[1]);

                foreach (var awaiter in awaiters.Skip(2))
                {
                    TaskAssert.Faulted <ObjectDisposedException>(awaiter);
                }
            }
        }
Example #2
0
        public void WaitAsync_Acquired_WaitsForTurn()
        {
            using (var lck = new Lock())
            {
                var t1 = TaskAssert.Detach(lck.WaitAsync);
                var t2 = TaskAssert.Detach(lck.WaitAsync);

                using (TaskAssert.Completed(t1))
                {
                    TaskAssert.DoesNotEnd(t2);
                }

                using (TaskAssert.Completed(t2)) { }
            }
        }
Example #3
0
        public void WaitAsync_Acquired_Reenters()
        {
            using (var lck = new Lock())
            {
                var h1 = TaskAssert.Completed(lck.WaitAsync());
                var t1 = TaskAssert.Detach(lck.WaitAsync);
                var h2 = TaskAssert.Completed(lck.WaitAsync());

                TaskAssert.DoesNotEnd(t1);

                h1.Dispose();
                TaskAssert.DoesNotEnd(t1);

                h2.Dispose();
                using (TaskAssert.Completed(t1)) { }
            }
        }
Example #4
0
        public void WaitAsync_Acquired_CanCedeTurn()
        {
            using (var cts = new CancellationTokenSource())
                using (var lck = new Lock())
                {
                    var t1 = TaskAssert.Detach(lck.WaitAsync);
                    var t2 = TaskAssert.Detach(() => lck.WaitAsync(cts.Token));
                    var t3 = TaskAssert.Detach(lck.WaitAsync);

                    TaskAssert.DoesNotEnd(t2);
                    TaskAssert.DoesNotEnd(t3);

                    cts.Cancel();
                    TaskAssert.Cancelled(t2);
                    TaskAssert.DoesNotEnd(t3);

                    using (TaskAssert.Completed(t1)) { }
                    using (TaskAssert.Completed(t3)) { }
                }
        }