[PreventExecutionContextLeaks] // Workaround for https://github.com/nunit/nunit/issues/3283
        public static async Task BeginContext_handler_flows_into_new_thread()
        {
            var source  = new TaskCompletionSource <object?>();
            var watcher = new CallbackWatcher();

            var thread = new Thread(() =>
            {
                try
                {
                    using (watcher.ExpectCallback())
                        AmbientTasks.Add(Task.FromException(new Exception()));

                    source.SetResult(null);
                }
                catch (Exception ex)
                {
                    source.SetException(ex);
                }
            });

            AmbientTasks.BeginContext(ex => watcher.OnCallback());

            thread.Start();

            await source.Task;
        }
        [PreventExecutionContextLeaks] // Workaround for https://github.com/nunit/nunit/issues/3283
        public static async Task BeginContext_handler_flows_into_ThreadPool_QueueUserWorkItem()
        {
            var watcher = new CallbackWatcher();

            AmbientTasks.BeginContext(ex => watcher.OnCallback());

            var source = new TaskCompletionSource <object?>();

            ThreadPool.QueueUserWorkItem(_ =>
            {
                try
                {
                    using (watcher.ExpectCallback())
                        AmbientTasks.Add(Task.FromException(new Exception()));

                    source.SetResult(null);
                }
                catch (Exception ex)
                {
                    source.SetException(ex);
                }
            }, null);

            await source.Task;
        }
        [PreventExecutionContextLeaks] // Workaround for https://github.com/nunit/nunit/issues/3283
        public static async Task BeginContext_handler_does_not_flow_from_inner_method_back_to_outer_method_after_await()
        {
            var watcher = new CallbackWatcher();

            AmbientTasks.BeginContext(ex => watcher.OnCallback());

            await InnerFunction();

            using (watcher.ExpectCallback())
                AmbientTasks.Add(Task.FromException(new Exception()));
        [PreventExecutionContextLeaks] // Workaround for https://github.com/nunit/nunit/issues/3283
        public static async Task BeginContext_handler_flows_across_await()
        {
            var watcher = new CallbackWatcher();

            AmbientTasks.BeginContext(ex => watcher.OnCallback());

            await Task.Yield();

            using (watcher.ExpectCallback())
                AmbientTasks.Add(Task.FromException(new Exception()));
        }
        [PreventExecutionContextLeaks] // Workaround for https://github.com/nunit/nunit/issues/3283
        public static void BeginContext_handler_is_replaced_with_next_call()
        {
            AmbientTasks.BeginContext(ex => Assert.Fail("This handler should not be called."));

            var watcher = new CallbackWatcher();

            AmbientTasks.BeginContext(ex => watcher.OnCallback());

            using (watcher.ExpectCallback())
                AmbientTasks.Add(Task.FromException(new Exception()));
        }
        [PreventExecutionContextLeaks] // Workaround for https://github.com/nunit/nunit/issues/3283
        public static async Task BeginContext_handler_flows_into_Task_Run()
        {
            var watcher = new CallbackWatcher();

            AmbientTasks.BeginContext(ex => watcher.OnCallback());

            await Task.Run(() =>
            {
                using (watcher.ExpectCallback())
                    AmbientTasks.Add(Task.FromException(new Exception()));
            });
        }
Exemple #7
0
        [PreventExecutionContextLeaks] // Workaround for https://github.com/nunit/nunit/issues/3283
        public static void BeginContext_handler_receives_exception_thrown_from_func()
        {
            var exception = new Exception();
            var watcher   = new CallbackWatcher();

            AmbientTasks.BeginContext(ex =>
            {
                watcher.OnCallback();
                ex.ShouldBeSameAs(exception);
            });

            using (watcher.ExpectCallback())
                AmbientTasks.Add(() => throw exception);
        }
        [PreventExecutionContextLeaks] // Workaround for https://github.com/nunit/nunit/issues/3283
        public static void BeginContext_handler_receives_exceptions_from_synchronously_faulted_tasks()
        {
            var exception = new Exception();
            var watcher   = new CallbackWatcher();

            AmbientTasks.BeginContext(ex =>
            {
                watcher.OnCallback();
                ex.ShouldBeSameAs(exception);
            });

            using (watcher.ExpectCallback())
                AmbientTasks.Add(Task.FromException(exception));
        }
        [PreventExecutionContextLeaks] // Workaround for https://github.com/nunit/nunit/issues/3283
        public static void BeginContext_handler_receives_exceptions_from_asynchronously_faulted_tasks()
        {
            var source    = new TaskCompletionSource <object?>();
            var exception = new Exception();
            var watcher   = new CallbackWatcher();

            AmbientTasks.BeginContext(ex =>
            {
                watcher.OnCallback();
                ex.ShouldBeSameAs(exception);
            });

            AmbientTasks.Add(source.Task);

            using (watcher.ExpectCallback())
                source.SetException(exception);
        }
        [PreventExecutionContextLeaks] // Workaround for https://github.com/nunit/nunit/issues/3283
        public static void Exception_from_user_delegate_is_handled_by_BeginContext_handler([Values] PostOverload overload)
        {
            var exception = new Exception();
            var watcher   = new CallbackWatcher();

            AmbientTasks.BeginContext(ex =>
            {
                watcher.OnCallback();
                ex.ShouldBeSameAs(exception);
            });

            using (SynchronizationContextAssert.ExpectSinglePost(postedAction => postedAction.Invoke()))
            {
                using (watcher.ExpectCallback())
                    AmbientTasksPost(overload, () => throw exception);
            }
        }