public async Task AwaitOnCompleted_InvokesStateMachineMethods(bool awaitUnsafe)
        {
            AsyncValueTaskMethodBuilder <int> b = ValueTask <int> .CreateAsyncMethodBuilder();

            var ignored = b.Task;

            var callbackCompleted      = new TaskCompletionSource <bool>();
            IAsyncStateMachine foundSm = null;
            var dsm = new DelegateStateMachine
            {
                MoveNextDelegate        = () => callbackCompleted.SetResult(true),
                SetStateMachineDelegate = sm => foundSm = sm
            };

            TaskAwaiter t = Task.CompletedTask.GetAwaiter();

            if (awaitUnsafe)
            {
                b.AwaitUnsafeOnCompleted(ref t, ref dsm);
            }
            else
            {
                b.AwaitOnCompleted(ref t, ref dsm);
            }

            await callbackCompleted.Task;

            Assert.Equal(dsm, foundSm);
        }
        public void AwaitOnCompleted_ForcesTaskCreation(int numAwaits, bool awaitUnsafe)
        {
            AsyncValueTaskMethodBuilder <int> b = ValueTask <int> .CreateAsyncMethodBuilder();

            var dsm             = new DelegateStateMachine();
            TaskAwaiter <int> t = new TaskCompletionSource <int>().Task.GetAwaiter();

            Assert.InRange(numAwaits, 1, int.MaxValue);
            for (int i = 1; i <= numAwaits; i++)
            {
                if (awaitUnsafe)
                {
                    b.AwaitUnsafeOnCompleted(ref t, ref dsm);
                }
                else
                {
                    b.AwaitOnCompleted(ref t, ref dsm);
                }
            }

            b.SetResult(42);

            Assert.True(WrapsTask(b.Task));
            Assert.Equal(42, b.Task.Result);
        }
            private void MoveNext()
            {
                int          num = __1__state;
                NullCoalesce c   = __4__this;
                int          result;

                try
                {
                    /* M1AsyncAsyncA__d__5
                     * ValueTaskAwaiter<int> awaiter;
                     * if (num != 0)
                     * {
                     *  ValueTask<int> valueTask = (c.FAsync != null) ? c.FAsync() : default(ValueTask<int>);
                     *  awaiter = valueTask.GetAwaiter();
                     *  if (!awaiter.IsCompleted)
                     *  {
                     *      num = (__1__state = 0);
                     *      __u__1 = awaiter;
                     *      __t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
                     *      return;
                     *  }
                     * }
                     * else
                     * {
                     *  awaiter = __u__1;
                     *  __u__1 = default(ValueTaskAwaiter<int>);
                     *  num = (__1__state = -1);
                     * }
                     * result = awaiter.GetResult();
                     */

                    /* M1AsyncAsyncB__d__6 */

                    int num2;
                    ValueTaskAwaiter <int> awaiter;
                    if (num != 0)
                    {
                        if (c.FAsync == null)
                        {
                            num2 = 0;
                            goto IL_0082;
                        }
                        awaiter = c.FAsync().GetAwaiter();
                        if (!awaiter.IsCompleted)
                        {
                            num    = (__1__state = 0);
                            __u__1 = awaiter;
                            __t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
                            return;
                        }
                    }
                    else
                    {
                        awaiter = __u__1;
                        __u__1  = default(ValueTaskAwaiter <int>);
                        num     = (__1__state = -1);
                    }
                    num2 = awaiter.GetResult();
                    goto IL_0082;
IL_0082:
                    result = num2;
                    /**/

                    /* M2AsyncAsync__d__8
                     *
                     * ValueTaskAwaiter<int> awaiter;
                     * if (num != 0)
                     * {
                     *  Func<ValueTask<int>> fAsync = c.FAsync;
                     *  ValueTask<int> valueTask = (fAsync != null) ? fAsync() : default(ValueTask<int>);
                     *  awaiter = valueTask.GetAwaiter();
                     *  if (!awaiter.IsCompleted)
                     *  {
                     *      num = (__1__state = 0);
                     *      __u__1 = awaiter;
                     *      __t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
                     *      return;
                     *  }
                     * }
                     * else
                     * {
                     *  awaiter = __u__1;
                     *  __u__1 = default(ValueTaskAwaiter<int>);
                     *  num = (__1__state = -1);
                     * }
                     * result = awaiter.GetResult();
                     */

                    // ----
                }
                catch (Exception exception)
                {
                    __1__state = -2;
                    __t__builder.SetException(exception);
                    return;
                }
                __1__state = -2;
                __t__builder.SetResult(result);
            }