How to use RuntimeProvider class of Microsoft.Coyote.Runtime package

Best Coyote code snippet using Microsoft.Coyote.Runtime.RuntimeProvider

ValueTaskAwaiter.cs

Source:ValueTaskAwaiter.cs

...45        {46            this.AwaitedTask = ValueTaskAwaiter.TryGetTask(ref awaitedTask, out Task innerTask) ?47                innerTask : null;48            this.Awaiter = awaitedTask.GetAwaiter();49            RuntimeProvider.TryGetFromSynchronizationContext(out CoyoteRuntime runtime);50            this.Runtime = runtime;51        }52        /// <summary>53        /// Initializes a new instance of the <see cref="ValueTaskAwaiter"/> struct.54        /// </summary>55        private ValueTaskAwaiter(ref SystemValueTask awaitedTask, ref SystemCompiler.ValueTaskAwaiter awaiter)56        {57            this.AwaitedTask = ValueTaskAwaiter.TryGetTask(ref awaitedTask, out Task innerTask) ?58                innerTask : null;59            this.Awaiter = awaiter;60            RuntimeProvider.TryGetFromSynchronizationContext(out CoyoteRuntime runtime);61            this.Runtime = runtime;62        }63        /// <summary>64        /// Ends asynchronously waiting for the completion of the awaiter.65        /// </summary>66        public void GetResult()67        {68            TaskServices.WaitUntilTaskCompletes(this.Runtime, this.AwaitedTask);69            this.Awaiter.GetResult();70        }71        /// <summary>72        /// Sets the action to perform when the controlled value task completes.73        /// </summary>74        [MethodImpl(MethodImplOptions.AggressiveInlining)]75        public void OnCompleted(Action continuation) => this.Awaiter.OnCompleted(continuation);76        /// <summary>77        /// Schedules the continuation action that is invoked when the controlled value task completes.78        /// </summary>79        [MethodImpl(MethodImplOptions.AggressiveInlining)]80        public void UnsafeOnCompleted(Action continuation) => this.Awaiter.UnsafeOnCompleted(continuation);81        /// <summary>82        /// Wraps the specified value task awaiter.83        /// </summary>84        public static ValueTaskAwaiter Wrap(SystemCompiler.ValueTaskAwaiter awaiter)85        {86            // Access the task being awaited through reflection.87            var field = awaiter.GetType().GetField("_value", BindingFlags.NonPublic | BindingFlags.Instance);88            var awaitedTask = (ValueTask)field?.GetValue(awaiter);89            return new ValueTaskAwaiter(ref awaitedTask, ref awaiter);90        }91        /// <summary>92        /// Wraps the specified generic value task awaiter.93        /// </summary>94        public static ValueTaskAwaiter<TResult> Wrap<TResult>(SystemCompiler.ValueTaskAwaiter<TResult> awaiter)95        {96            // Access the generic task being awaited through reflection.97            var field = awaiter.GetType().GetField("_value", BindingFlags.NonPublic | BindingFlags.Instance);98            var awaitedTask = (ValueTask<TResult>)field?.GetValue(awaiter);99            return new ValueTaskAwaiter<TResult>(ref awaitedTask, ref awaiter);100        }101        /// <summary>102        /// Tries to safely retrieve the payload of a value task if that payload is an asynchronous task.103        /// If the payload is a <see cref="SystemTasks.Sources.IValueTaskSource"/>, then it returns null.104        /// </summary>105        internal static bool TryGetTask(ref SystemValueTask task, out SystemTask payload)106        {107            // Access the payload through reflection.108            var field = task.GetType().GetField("_obj", BindingFlags.NonPublic | BindingFlags.Instance);109            payload = field?.GetValueDirect(__makeref(task)) as SystemTask;110            return payload != null;111        }112        /// <summary>113        /// Tries to safely retrieve the payload of a value task if that payload is an asynchronous task.114        /// If the payload is a <see cref="SystemTasks.Sources.IValueTaskSource"/>, then it returns null.115        /// </summary>116        internal static bool TryGetTask<TResult>(ref SystemTasks.ValueTask<TResult> task,117            out SystemTasks.Task<TResult> payload)118        {119            // Access the payload through reflection.120            var field = task.GetType().GetField("_obj", BindingFlags.NonPublic | BindingFlags.Instance);121            payload = field?.GetValueDirect(__makeref(task)) as SystemTasks.Task<TResult>;122            return payload != null;123        }124    }125    /// <summary>126    /// Implements a <see cref="ValueTask"/> awaiter.127    /// </summary>128    /// <typeparam name="TResult">The type of the produced result.</typeparam>129    /// <remarks>This type is intended for compiler use only.</remarks>130    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]131    public readonly struct ValueTaskAwaiter<TResult> : IControllableAwaiter, ICriticalNotifyCompletion, INotifyCompletion132    {133        // WARNING: The layout must remain the same, as the struct is used to access134        // the generic ValueTaskAwaiter<> as ValueTaskAwaiter.135        /// <summary>136        /// The inner task being awaited.137        /// </summary>138        private readonly SystemTasks.Task<TResult> AwaitedTask;139        /// <summary>140        /// The value task awaiter.141        /// </summary>142        private readonly SystemCompiler.ValueTaskAwaiter<TResult> Awaiter;143        /// <summary>144        /// The runtime controlling this awaiter.145        /// </summary>146        private readonly CoyoteRuntime Runtime;147        /// <summary>148        /// True if the awaiter has completed, else false.149        /// </summary>150        public bool IsCompleted => this.AwaitedTask?.IsCompleted ?? this.Awaiter.IsCompleted;151        /// <inheritdoc/>152        bool IControllableAwaiter.IsControlled =>153            !this.Runtime?.IsTaskUncontrolled(this.AwaitedTask) ?? false;154        /// <summary>155        /// Initializes a new instance of the <see cref="ValueTaskAwaiter{TResult}"/> struct.156        /// </summary>157        internal ValueTaskAwaiter(ref SystemTasks.ValueTask<TResult> awaitedTask)158        {159            this.AwaitedTask = ValueTaskAwaiter.TryGetTask<TResult>(ref awaitedTask, out Task<TResult> innerTask) ?160                innerTask : null;161            this.Awaiter = awaitedTask.GetAwaiter();162            RuntimeProvider.TryGetFromSynchronizationContext(out CoyoteRuntime runtime);163            this.Runtime = runtime;164        }165        /// <summary>166        /// Initializes a new instance of the <see cref="ValueTaskAwaiter{TResult}"/> struct.167        /// </summary>168        internal ValueTaskAwaiter(ref SystemTasks.ValueTask<TResult> awaitedTask,169            ref SystemCompiler.ValueTaskAwaiter<TResult> awaiter)170        {171            this.AwaitedTask = ValueTaskAwaiter.TryGetTask<TResult>(ref awaitedTask, out Task<TResult> innerTask) ?172                innerTask : null;173            this.Awaiter = awaiter;174            RuntimeProvider.TryGetFromSynchronizationContext(out CoyoteRuntime runtime);175            this.Runtime = runtime;176        }177        /// <summary>178        /// Ends asynchronously waiting for the completion of the awaiter.179        /// </summary>180        public TResult GetResult()181        {182            TaskServices.WaitUntilTaskCompletes(this.Runtime, this.AwaitedTask);183            return this.Awaiter.GetResult();184        }185        /// <summary>186        /// Sets the action to perform when the controlled value task completes.187        /// </summary>188        [MethodImpl(MethodImplOptions.AggressiveInlining)]...

TaskAwaiter.cs

Source:TaskAwaiter.cs

...42        internal TaskAwaiter(SystemTask awaitedTask)43        {44            this.AwaitedTask = awaitedTask;45            this.Awaiter = awaitedTask.GetAwaiter();46            RuntimeProvider.TryGetFromSynchronizationContext(out CoyoteRuntime runtime);47            this.Runtime = runtime;48        }49        /// <summary>50        /// Initializes a new instance of the <see cref="TaskAwaiter"/> struct.51        /// </summary>52        private TaskAwaiter(SystemTask awaitedTask, ref SystemCompiler.TaskAwaiter awaiter)53        {54            this.AwaitedTask = awaitedTask;55            this.Awaiter = awaiter;56            RuntimeProvider.TryGetFromSynchronizationContext(out CoyoteRuntime runtime);57            this.Runtime = runtime;58        }59        /// <summary>60        /// Ends asynchronously waiting for the completion of the awaiter.61        /// </summary>62        public void GetResult()63        {64            TaskServices.WaitUntilTaskCompletes(this.Runtime, this.AwaitedTask);65            this.Awaiter.GetResult();66        }67        /// <summary>68        /// Sets the action to perform when the controlled task completes.69        /// </summary>70        [MethodImpl(MethodImplOptions.AggressiveInlining)]71        public void OnCompleted(Action continuation) => this.Awaiter.OnCompleted(continuation);72        /// <summary>73        /// Schedules the continuation action that is invoked when the controlled task completes.74        /// </summary>75        [MethodImpl(MethodImplOptions.AggressiveInlining)]76        public void UnsafeOnCompleted(Action continuation)77        {78            this.Awaiter.UnsafeOnCompleted(continuation);79        }80        /// <summary>81        /// Wraps the specified task awaiter.82        /// </summary>83        public static TaskAwaiter Wrap(SystemCompiler.TaskAwaiter awaiter)84        {85            // Access the task being awaited through reflection.86            var field = awaiter.GetType().GetField("m_task", BindingFlags.NonPublic | BindingFlags.Instance);87            var awaitedTask = (SystemTask)field?.GetValue(awaiter);88            return new TaskAwaiter(awaitedTask, ref awaiter);89        }90        /// <summary>91        /// Wraps the specified generic task awaiter.92        /// </summary>93        public static TaskAwaiter<TResult> Wrap<TResult>(SystemCompiler.TaskAwaiter<TResult> awaiter)94        {95            // Access the generic task being awaited through reflection.96            var field = awaiter.GetType().GetField("m_task", BindingFlags.NonPublic | BindingFlags.Instance);97            var awaitedTask = (SystemTasks.Task<TResult>)field?.GetValue(awaiter);98            return new TaskAwaiter<TResult>(awaitedTask, ref awaiter);99        }100    }101    /// <summary>102    /// Implements a generic task awaiter.103    /// </summary>104    /// <typeparam name="TResult">The type of the produced result.</typeparam>105    /// <remarks>This type is intended for compiler use only.</remarks>106    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]107    public readonly struct TaskAwaiter<TResult> : IControllableAwaiter, ICriticalNotifyCompletion, INotifyCompletion108    {109        // WARNING: The layout must remain the same, as the struct is used to access110        // the generic TaskAwaiter<> as TaskAwaiter.111        /// <summary>112        /// The task being awaited.113        /// </summary>114        private readonly SystemTasks.Task<TResult> AwaitedTask;115        /// <summary>116        /// The task awaiter.117        /// </summary>118        private readonly SystemCompiler.TaskAwaiter<TResult> Awaiter;119        /// <summary>120        /// The runtime controlling this awaiter.121        /// </summary>122        private readonly CoyoteRuntime Runtime;123        /// <summary>124        /// True if the awaiter has completed, else false.125        /// </summary>126        public bool IsCompleted => this.AwaitedTask?.IsCompleted ?? this.Awaiter.IsCompleted;127        /// <inheritdoc/>128        bool IControllableAwaiter.IsControlled =>129            !this.Runtime?.IsTaskUncontrolled(this.AwaitedTask) ?? false;130        /// <summary>131        /// Initializes a new instance of the <see cref="TaskAwaiter{TResult}"/> struct.132        /// </summary>133        internal TaskAwaiter(SystemTasks.Task<TResult> awaitedTask)134        {135            this.AwaitedTask = awaitedTask;136            this.Awaiter = awaitedTask.GetAwaiter();137            RuntimeProvider.TryGetFromSynchronizationContext(out CoyoteRuntime runtime);138            this.Runtime = runtime;139        }140        /// <summary>141        /// Initializes a new instance of the <see cref="TaskAwaiter{TResult}"/> struct.142        /// </summary>143        internal TaskAwaiter(SystemTasks.Task<TResult> awaitedTask, ref SystemCompiler.TaskAwaiter<TResult> awaiter)144        {145            this.AwaitedTask = awaitedTask;146            this.Awaiter = awaiter;147            RuntimeProvider.TryGetFromSynchronizationContext(out CoyoteRuntime runtime);148            this.Runtime = runtime;149        }150        /// <summary>151        /// Ends asynchronously waiting for the completion of the awaiter.152        /// </summary>153        public TResult GetResult()154        {155            TaskServices.WaitUntilTaskCompletes(this.Runtime, this.AwaitedTask);156            return this.Awaiter.GetResult();157        }158        /// <summary>159        /// Sets the action to perform when the controlled task completes.160        /// </summary>161        [MethodImpl(MethodImplOptions.AggressiveInlining)]...

Program.cs

Source:Program.cs

...12        private static bool RunForever = false;13        public static void Main()14        {15            RunForever = true;16            ICoyoteRuntime runtime = RuntimeProvider.Create();17            _ = Execute(runtime);18            Console.ReadLine();19            Console.WriteLine("User cancelled the test by pressing ENTER");20        }21        private static void OnRuntimeFailure(Exception ex)22        {23            Console.WriteLine("### Failure: " + ex.Message);24        }25        [Microsoft.Coyote.SystematicTesting.Test]26        public static async Task Execute(ICoyoteRuntime runtime)27        {28            LogWriter.Initialize(runtime.Logger, RunForever);29            runtime.OnFailure += OnRuntimeFailure;30            Specification.RegisterMonitor<LivenessMonitor>();...

RuntimeProvider

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Runtime;5{6    {7        static async Task Main(string[] args)8        {9            var config = Configuration.Create().WithNumberOfIterations(100);10            await Runtime.RunAsync(config, async () =>11            {12                var machine = new MyMachine();13                await machine.Start();14            });15        }16    }17    {18        [OnEventDoAction(typeof(UnitEvent), nameof(TestMethod))]19        class Init : MachineState { }20        async Task TestMethod()21        {22            Console.WriteLine("Hello World!");23        }24    }25}26using System;27using System.Threading.Tasks;28using Microsoft.Coyote;29using Microsoft.Coyote.Runtime;30{31    {32        static async Task Main(string[] args)33        {34            var config = Configuration.Create().WithNumberOfIterations(100);35            await Runtime.RunAsync(config, async () =>36            {37                var machine = new MyMachine();38                await machine.Start();39            });40        }41    }42    {43        [OnEventDoAction(typeof(UnitEvent), nameof(TestMethod))]44        class Init : MachineState { }45        async Task TestMethod()46        {47            Console.WriteLine("Hello World!");48        }49    }50}51Error: The type or namespace name 'Runtime' could not be found (are you missing a using directive or an assembly reference?)

RuntimeProvider

Using AI Code Generation

1using Microsoft.Coyote.Runtime;2using System;3{4    {5        static void Main(string[] args)6        {7            var runtime = RuntimeProvider.GetRuntime();8            runtime.CreateActor(typeof(Actor1));9            runtime.CreateActor(typeof(Actor2));10            runtime.Wait();11        }12    }13}14using Microsoft.Coyote.Actors;15using System;16{17    {18        protected override async System.Threading.Tasks.Task OnInitializeAsync(Event initialEvent)19        {20            Console.WriteLine("Actor1.OnInitializeAsync");21            await this.SendEvent(this.Id, new Event1());22        }23        protected override async System.Threading.Tasks.Task OnEventAsync(Event e)24        {25            Console.WriteLine("Actor1.OnEventAsync");26            await this.SendEvent(this.Id, new Event1());27        }28    }29}30using Microsoft.Coyote.Actors;31using System;32{33    {34        protected override async System.Threading.Tasks.Task OnInitializeAsync(Event initialEvent)35        {36            Console.WriteLine("Actor2.OnInitializeAsync");37            await this.SendEvent(this.Id, new Event1());38        }39        protected override async System.Threading.Tasks.Task OnEventAsync(Event e)40        {41            Console.WriteLine("Actor2.OnEventAsync");42            await this.SendEvent(this.Id, new Event1());43        }44    }45}46using Microsoft.Coyote.Actors;47{48    {49    }50}

RuntimeProvider

Using AI Code Generation

1using Microsoft.Coyote.Runtime;2using System;3using System.Threading.Tasks;4{5    {6        static void Main(string[] args)7        {8            Test();9            Console.WriteLine("Hello World!");10        }11        public static async Task Test()12        {13            var runtime = RuntimeProvider.Current;14            await runtime.CreateActorAsync(typeof(MyActor));15        }16    }17    {18        protected override Task OnInitializeAsync(Event initialEvent)19        {20            Console.WriteLine("Hello from actor");21            return Task.CompletedTask;22        }23    }24}

RuntimeProvider

Using AI Code Generation

1using Microsoft.Coyote.Runtime;2using System;3{4    {5        static void Main(string[] args)6        {7            RuntimeProvider provider = new RuntimeProvider();8            provider.Initialize();9            provider.Dispose();10        }11    }12}13using Microsoft.Coyote.Runtime;14using System;15{16    {17        static void Main(string[] args)18        {19            RuntimeProvider provider = new RuntimeProvider();20            provider.Initialize();21            provider.Dispose();22        }23    }24}25using Microsoft.Coyote.Runtime;26using System;27{28    {29        static void Main(string[] args)30        {31            RuntimeProvider provider = new RuntimeProvider();32            provider.Initialize();33            provider.Dispose();34        }35    }36}

RuntimeProvider

Using AI Code Generation

1using Microsoft.Coyote.Runtime;2using System;3using System.Threading.Tasks;4{5    {6        static void Main(string[] args)7        {8            var runtime = RuntimeFactory.Create();9            runtime.Configure();10            var actor = runtime.CreateActor(typeof(Actor1));11            runtime.SendEvent(actor, new Event1());12            var actor2 = runtime.CreateActor(typeof(Actor2));13            runtime.SendEvent(actor2, new Event2());14            var actor3 = runtime.CreateActor(typeof(Actor3));15            runtime.SendEvent(actor3, new Event3());16            var actor4 = runtime.CreateActor(typeof(Actor4));17            runtime.SendEvent(actor4, new Event4());18            var actor5 = runtime.CreateActor(typeof(Actor5));19            runtime.SendEvent(actor5, new Event5());20            var actor6 = runtime.CreateActor(typeof(Actor6));21            runtime.SendEvent(actor6, new Event6());22            var actor7 = runtime.CreateActor(typeof(Actor7));23            runtime.SendEvent(actor7, new Event7());

RuntimeProvider

Using AI Code Generation

1using Microsoft.Coyote.Runtime;2using System.Threading.Tasks;3{4    static void Main(string[] args)5    {6        Task t = Task.Run(() => {7        });8        t.Wait();9    }10}11using Microsoft.Coyote.Runtime;12using System.Threading.Tasks;13{14    static void Main(string[] args)15    {16        Task t = Task.Run(() => {17        });18        t.Wait();19    }20}21using Microsoft.Coyote.Runtime;22using System.Threading.Tasks;23{24    static void Main(string[] args)25    {26        Task t = Task.Run(() => {27        });28        t.Wait();29    }30}31using Microsoft.Coyote.Runtime;32using System.Threading.Tasks;33{34    static void Main(string[] args)35    {36        Task t = Task.Run(() => {37        });38        t.Wait();39    }40}41using Microsoft.Coyote.Runtime;42using System.Threading.Tasks;43{44    static void Main(string[] args)45    {46        Task t = Task.Run(() => {47        });48        t.Wait();49    }50}

RuntimeProvider

Using AI Code Generation

1using Microsoft.Coyote.Runtime;2using System.Threading.Tasks;3{4    {5        static async Task Main(string[] args)6        {7            var runtime = RuntimeFactory.Create();8            var task = Task.Run(() => { System.Console.WriteLine("Hello World!"); });9            await task;10        }11    }12}

RuntimeProvider

Using AI Code Generation

1using Microsoft.Coyote.Runtime;2{3    static void Main(string[] args)4    {5        RuntimeProvider runtime = new RuntimeProvider();6    }7}8using Microsoft.Coyote.Runtime;9{10    static void Main(string[] args)11    {12        var config = Configuration.Create();13        config.SchedulingIterations = 100;14        RuntimeProvider runtime = new RuntimeProvider(config);15    }16}17using Microsoft.Coyote.Runtime;18{19    static void Main(string[] args)20    {21        var config = Configuration.Create();22        config.SchedulingIterations = 100;23        var logger = new TestLogger();24        RuntimeProvider runtime = new RuntimeProvider(config, logger);25    }26}27using Microsoft.Coyote.Runtime;28{29    static void Main(string[] args)30    {31        var config = Configuration.Create();32        config.SchedulingIterations = 100;33        var logger = new TestLogger();34        var random = new RandomNumberGenerator();35        RuntimeProvider runtime = new RuntimeProvider(config, logger, random);36    }37}38using Microsoft.Coyote.Runtime;39{40    static void Main(string[] args)41    {42        var config = Configuration.Create();

RuntimeProvider

Using AI Code Generation

1using Microsoft.Coyote.Runtime;2using System;3{4    {5        static void Main(string[] args)6        {7            var runtime = RuntimeFactory.Create();8            runtime.Execute(() =>9            {10                Console.WriteLine("Hello World!");11            });12        }13    }14}15using Microsoft.Coyote.Runtime;16using System;17using System.Threading.Tasks;18{19    {20        static void Main(string[] args)21        {22            var runtime = RuntimeFactory.Create();23            runtime.Execute(() =>24            {25                AsyncMethod();26            });27        }28        static async void AsyncMethod()29        {30            Console.WriteLine("Hello World!");31            await Task.Delay(1000);32        }33    }34}35using Microsoft.Coyote.Runtime;36using System;37using System.Threading.Tasks;38{39    {40        static void Main(string[] args)41        {42            var runtime = RuntimeFactory.Create();43            runtime.Execute(() =>44            {45                AsyncMethod();46            });47        }

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.