Exemplo n.º 1
0
        public void TestRunWithTimeoutCallbackTimeoutCancellation()
        {
            var sample = new TimedOutSample
            {
                CallbackDelay     = _timeout10,
                CancellationDelay = _timeout10
            };

            var cts  = new CancellationTokenSource();
            var task = TaskHelper.RunWithTimeout(
                sample.OnCallback,
                _timeout1,
                sample.OnCancellation,
                cts.Token);

            cts.CancelAfter(_timeout2);

            task.Wait(CancellationToken.None);
            var events = sample.WaitForFullCompletion().WaitForResult();

            events.Sort();
            Assert.AreEqual(
                events,
                new[]
            {
                SampleEvent.CallbackStarted,
                SampleEvent.CallbackCanceled,
                SampleEvent.CancellationStarted,
                SampleEvent.CancellationCanceled
            });
        }
Exemplo n.º 2
0
        public void TestWithTimeoutCallbackCancellation()
        {
            var sample = new TimedOutSample
            {
                CallbackDelay     = _timeout10,
                CancellationDelay = _timeout10
            };

            var cts  = new CancellationTokenSource();
            var task = sample.OnCallback(cts.Token).WithTimeout(
                _timeout2,
                sample.OnCancellation,
                cts.Token);

            cts.CancelAfter(_timeout1);

            Assert.Throws <OperationCanceledException>(() => task.WaitForResult());
            var events = sample.WaitForCallbackCompletion().WaitForResult();

            Assert.AreEqual(
                events,
                new[]
            {
                SampleEvent.CallbackStarted,
                SampleEvent.CallbackCanceled
            });
        }
Exemplo n.º 3
0
        public void TestRunWithTimeoutCallbackFailure()
        {
            var sample = new TimedOutSample
            {
                CallbackDelay = _timeout10
            };

            var task = TaskHelper.RunWithTimeout(
                sample.OnCallback,
                _timeout1,
                sample.OnCancellation,
                CancellationToken.None);

            task.Wait();
            var events = sample.WaitForCancellationCompletion().WaitForResult();

            events.Sort();
            Assert.AreEqual(task.Result, SampleResult.FromCancellation);
            Assert.AreEqual(
                events,
                new[]
            {
                SampleEvent.CallbackStarted,
                SampleEvent.CallbackCanceled,
                SampleEvent.CancellationStarted,
                SampleEvent.CancellationCompleted
            });
        }
Exemplo n.º 4
0
        public void TestWithTimeoutCallbackSuccess()
        {
            var sample = new TimedOutSample();

            var task = sample.OnCallback().WithTimeout(
                _timeout1,
                sample.OnCancellation,
                CancellationToken.None);

            task.Wait();
            var events = sample.WaitForCallbackCompletion().WaitForResult();

            Assert.AreEqual(task.Result, SampleResult.FromCallback);
            Assert.AreEqual(
                events,
                new[]
            {
                SampleEvent.CallbackStarted,
                SampleEvent.CallbackCompleted
            });
        }