How to use Start method of Microsoft.Coyote.Runtime.Operation class

Best Coyote code snippet using Microsoft.Coyote.Runtime.Operation.Start

AsyncTaskMethodBuilder.cs

Source:AsyncTaskMethodBuilder.cs

...60        /// Begins running the builder with the associated state machine.61        /// </summary>62        [DebuggerStepThrough]63        [MethodImpl(MethodImplOptions.AggressiveInlining)]64        public void Start<TStateMachine>(ref TStateMachine stateMachine)65            where TStateMachine : IAsyncStateMachine66        {67            IO.Debug.WriteLine("<AsyncBuilder> Start state machine from task '{0}'.", Task.CurrentId);68            this.Runtime?.CheckExecutingOperationIsControlled();69            this.MethodBuilder.Start(ref stateMachine);70        }71        /// <summary>72        /// Associates the builder with the specified state machine.73        /// </summary>74        public void SetStateMachine(IAsyncStateMachine stateMachine) =>75            this.MethodBuilder.SetStateMachine(stateMachine);76        /// <summary>77        /// Marks the task as successfully completed.78        /// </summary>79        public void SetResult()80        {81            IO.Debug.WriteLine("<AsyncBuilder> Set result of task '{0}' from task '{1}'.",82                this.MethodBuilder.Task.Id, Task.CurrentId);83            this.Runtime?.CheckExecutingOperationIsControlled();84            this.MethodBuilder.SetResult();85        }86        /// <summary>87        /// Marks the task as failed and binds the specified exception to the task.88        /// </summary>89        public void SetException(Exception exception)90        {91            this.Runtime?.OnAsyncTaskMethodBuilderSetException(exception);92            this.MethodBuilder.SetException(exception);93        }94        /// <summary>95        /// Schedules the state machine to proceed to the next action when the specified awaiter completes.96        /// </summary>97        [DebuggerHidden]98        [MethodImpl(MethodImplOptions.AggressiveInlining)]99        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)100            where TAwaiter : INotifyCompletion101            where TStateMachine : IAsyncStateMachine =>102            this.MethodBuilder.AwaitOnCompleted(ref awaiter, ref stateMachine);103        /// <summary>104        /// Schedules the state machine to proceed to the next action when the specified awaiter completes.105        /// </summary>106        [DebuggerHidden]107        [MethodImpl(MethodImplOptions.AggressiveInlining)]108        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)109            where TAwaiter : ICriticalNotifyCompletion110            where TStateMachine : IAsyncStateMachine =>111            this.MethodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);112    }113    /// <summary>114    /// Represents a builder for asynchronous methods that return a <see cref="Task{TResult}"/>.115    /// This type is intended for compiler use only.116    /// </summary>117    /// <remarks>This type is intended for compiler use rather than use directly in code.</remarks>118    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]119    [StructLayout(LayoutKind.Auto)]120    public struct AsyncTaskMethodBuilder<TResult>121    {122        /// <summary>123        /// Responsible for controlling the execution of tasks during systematic testing.124        /// </summary>125        private readonly CoyoteRuntime Runtime;126        /// <summary>127        /// The task builder to which most operations are delegated.128        /// </summary>129#pragma warning disable IDE0044 // Add readonly modifier130        private SystemCompiler.AsyncTaskMethodBuilder<TResult> MethodBuilder;131#pragma warning restore IDE0044 // Add readonly modifier132        /// <summary>133        /// Gets the task for this builder.134        /// </summary>135        public Task<TResult> Task136        {137            [DebuggerHidden]138            get139            {140                IO.Debug.WriteLine("<AsyncBuilder> Creating builder task '{0}' from task '{1}' (isCompleted {2}).",141                    this.MethodBuilder.Task.Id, System.Threading.Tasks.Task.CurrentId, this.MethodBuilder.Task.IsCompleted);142                this.Runtime?.CheckExecutingOperationIsControlled();143                this.Runtime?.OnTaskCompletionSourceGetTask(this.MethodBuilder.Task);144                return this.MethodBuilder.Task;145            }146        }147        /// <summary>148        /// Initializes a new instance of the <see cref="AsyncTaskMethodBuilder{TResult}"/> struct.149        /// </summary>150        private AsyncTaskMethodBuilder(CoyoteRuntime runtime)151        {152            this.Runtime = runtime;153            this.MethodBuilder = default;154        }155        /// <summary>156        /// Creates an instance of the <see cref="AsyncTaskMethodBuilder{TResult}"/> struct.157        /// </summary>158#pragma warning disable CA1000 // Do not declare static members on generic types159        public static AsyncTaskMethodBuilder<TResult> Create() =>160            new AsyncTaskMethodBuilder<TResult>(CoyoteRuntime.IsExecutionControlled ? CoyoteRuntime.Current : null);161#pragma warning restore CA1000 // Do not declare static members on generic types162        /// <summary>163        /// Begins running the builder with the associated state machine.164        /// </summary>165        [DebuggerStepThrough]166        [MethodImpl(MethodImplOptions.AggressiveInlining)]167        public void Start<TStateMachine>(ref TStateMachine stateMachine)168            where TStateMachine : IAsyncStateMachine169        {170            IO.Debug.WriteLine("<AsyncBuilder> Start state machine from task '{0}'.", System.Threading.Tasks.Task.CurrentId);171            this.Runtime?.CheckExecutingOperationIsControlled();172            this.MethodBuilder.Start(ref stateMachine);173        }174        /// <summary>175        /// Associates the builder with the specified state machine.176        /// </summary>177        public void SetStateMachine(IAsyncStateMachine stateMachine) =>178            this.MethodBuilder.SetStateMachine(stateMachine);179        /// <summary>180        /// Marks the task as successfully completed.181        /// </summary>182        /// <param name="result">The result to use to complete the task.</param>183        public void SetResult(TResult result)184        {185            IO.Debug.WriteLine("<AsyncBuilder> Set result of task '{0}' from task '{1}'.",186                this.MethodBuilder.Task.Id, System.Threading.Tasks.Task.CurrentId);...

Operation.cs

Source:Operation.cs

...53            }54            return null;55        }56        /// <summary>57        /// Starts executing the operation with the specified id.58        /// </summary>59        public static void Start(ulong operationId)60        {61            var runtime = CoyoteRuntime.Current;62            if (runtime.SchedulingPolicy != SchedulingPolicy.None)63            {64                var op = runtime.GetOperationWithId(operationId);65                if (op is null)66                {67                    throw new InvalidOperationException($"Operation with id '{operationId}' does not exist.");68                }69                runtime.StartOperation(op);70            }71        }72        /// <summary>73        /// Pauses the currently executing operation until the specified condition gets resolved.74        /// </summary>75        public static void PauseUntil(Func<bool> condition)76        {77            var runtime = CoyoteRuntime.Current;78            if (runtime.SchedulingPolicy is SchedulingPolicy.Interleaving)79            {80                runtime.PauseOperationUntil(default, condition);81            }82        }83        /// <summary>...

RequestControllerMiddleware.cs

Source:RequestControllerMiddleware.cs

...42                    runtime.Id, request.Method, request.Path, SystemThread.CurrentThread.ManagedThreadId);43                TryExtractSourceOperation(request, runtime, out ControlledOperation source);44                var op = HttpOperation.Create(ToHttpMethod(request.Method), request.Path, runtime, source);45                OperationGroup.SetCurrent(op.Group);46                await runtime.TaskFactory.StartNew(state =>47                    {48                        SystemTask task = this.Next(context);49                        TaskServices.WaitUntilTaskCompletes(runtime, op, task);50                        task.GetAwaiter().GetResult();51                    },52                    op,53                    default,54                    runtime.TaskFactory.CreationOptions | SystemTaskCreationOptions.DenyChildAttach,55                    runtime.TaskFactory.Scheduler);56            }57            else58            {59                IO.Debug.WriteLine($"[coyote::debug] Unable to control the '{0} {1}' request on thread '{2}'.",60                    request?.Method, request?.Path, SystemThread.CurrentThread.ManagedThreadId);...

Start

Using AI Code Generation

1using System;2using Microsoft.Coyote;3using Microsoft.Coyote.Actors;4using Microsoft.Coyote.Actors.Timers;5{6    {7        static void Main(string[] args)8        {9            var runtime = RuntimeFactory.Create();10            runtime.CreateActor(typeof(MyActor));11            runtime.Start();12            Console.ReadLine();13        }14    }15    {16        [OnEventDoAction(typeof(UnitEvent), nameof(OnStart))]17        private class Init : State { }18        private void OnStart()19        {20            this.SendEvent(this.Id, UnitEvent.Instance);21        }22    }23}24using System;25using Microsoft.Coyote;26using Microsoft.Coyote.Actors;27using Microsoft.Coyote.Actors.Timers;28{29    {30        static void Main(string[] args)31        {32            var runtime = RuntimeFactory.Create();33            runtime.CreateActor(typeof(MyActor));34            runtime.Start();35            Console.ReadLine();36        }37    }38    {39        [OnEntry(nameof(OnStart))]40        private class Init : State { }41        [OnEventDoAction(typeof(UnitEvent), nameof(OnUnitEvent))]42        private class OnUnitEventState : State { }43        private void OnStart()44        {45            this.SendEvent(this.Id, UnitEvent.Instance);46        }47        private void OnUnitEvent()48        {49            Console.WriteLine("OnUnitEvent");50        }51    }52}

Start

Using AI Code Generation

1using System;2using Microsoft.Coyote;3using Microsoft.Coyote.Actors;4using Microsoft.Coyote.Runtime;5using Microsoft.Coyote.Tasks;6using System.Threading.Tasks;7using System.Threading;8using System.Collections.Generic;9using System.Linq;10using System.Text;11using System.Diagnostics;12{13    {14        static void Main(string[] args)15        {16            Console.WriteLine("Hello World!");17            Operation.Start(new OperationTask());18            Console.WriteLine("Hello World!");19            Console.ReadKey();20        }21    }22    {23        protected override async Task OnExecuteAsync()24        {25            Console.WriteLine("Hello World!");26        }27    }28}29using System;30using Microsoft.Coyote;31using Microsoft.Coyote.Actors;32using Microsoft.Coyote.Runtime;33using Microsoft.Coyote.Tasks;34using System.Threading.Tasks;35using System.Threading;36using System.Collections.Generic;37using System.Linq;38using System.Text;39using System.Diagnostics;40{41    {42        static void Main(string[] args)43        {44            Console.WriteLine("Hello World!");45            Operation.Start(new OperationTask());46            Console.WriteLine("Hello World!");47            Console.ReadKey();48        }49    }50    {51        protected override async Task OnExecuteAsync()52        {53            Console.WriteLine("Hello World!");54        }55    }56}57using System;58using Microsoft.Coyote;59using Microsoft.Coyote.Actors;60using Microsoft.Coyote.Runtime;61using Microsoft.Coyote.Tasks;62using System.Threading.Tasks;63using System.Threading;64using System.Collections.Generic;65using System.Linq;66using System.Text;67using System.Diagnostics;68{69    {70        static void Main(string[] args)71        {72            Console.WriteLine("Hello World!");73            Operation.Start(new OperationTask());74            Console.WriteLine("Hello World!");75            Console.ReadKey();76        }77    }78    {79        protected override async Task OnExecuteAsync()80        {81            Console.WriteLine("Hello World!");82        }83    }84}

Start

Using AI Code Generation

1using System.Threading.Tasks;2using Microsoft.Coyote;3using Microsoft.Coyote.Actors;4using Microsoft.Coyote.Specifications;5using Microsoft.Coyote.Tasks;6{7    {8        static void Main(string[] args)9        {10            var runtime = RuntimeFactory.Create();11            var task = Task.Run(() => runtime.CreateActor(typeof(Actor1)));12            runtime.WaitAllTasksAsync().Wait();13        }14    }15    {16        protected override async Task OnInitializeAsync(Event initialEvent)17        {18            await this.SendEventAsync(this.Id, new Event1());19        }20        protected override async Task OnEventAsync(Event e)21        {22            switch (e)23            {24                    await this.SendEventAsync(this.Id, new Event2());25                    break;26                    await this.SendEventAsync(this.Id, new Event3());27                    break;28                    break;29            }30        }31    }32    class Event1 : Event { }33    class Event2 : Event { }34    class Event3 : Event { }35}

Start

Using AI Code Generation

1{2    {3        static void Main(string[] args)4        {5            var runtime = RuntimeFactory.Create();6            runtime.Start(AsyncMethod());7        }8        private static async Task AsyncMethod()9        {10            await Task.Delay(10);11        }12    }13}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.