KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta Join TestMu Conference

How to use Suppress method of Microsoft.Coyote.Runtime.SchedulingPoint class

Best Coyote code snippet using Microsoft.Coyote.Runtime.SchedulingPoint.Suppress

SchedulingPoint.cs

Source:SchedulingPoint.cs

...22                runtime.TryGetExecutingOperation(out ControlledOperation current))23            {24                if (runtime.SchedulingPolicy is SchedulingPolicy.Interleaving)25                {26                    runtime.ScheduleNextOperation(current, SchedulingPointType.Interleave, isSuppressible: false);27                }28                else if (runtime.SchedulingPolicy is SchedulingPolicy.Fuzzing)29                {30                    runtime.DelayOperation(current);31                }32            }33        }34        /// <summary>35        /// Attempts to yield execution to another controlled operation.36        /// </summary>37        /// <remarks>38        /// Invoking this method might lower the scheduling priority of the currently executing39        /// operation when certain exploration strategies are used.40        /// </remarks>41        public static void Yield()42        {43            var runtime = CoyoteRuntime.Current;44            if (runtime.SchedulingPolicy != SchedulingPolicy.None &&45                runtime.TryGetExecutingOperation(out ControlledOperation current))46            {47                if (runtime.SchedulingPolicy is SchedulingPolicy.Interleaving)48                {49                    runtime.ScheduleNextOperation(current, SchedulingPointType.Yield, isSuppressible: false, isYielding: true);50                }51                else if (runtime.SchedulingPolicy is SchedulingPolicy.Fuzzing)52                {53                    runtime.DelayOperation(current);54                }55            }56        }57#pragma warning disable CA1801 // Parameter not used58        /// <summary>59        /// Explores a possible interleaving due to a 'READ' operation on the specified shared state.60        /// </summary>61        /// <param name="state">The shared state that is being read represented as a string.</param>62        /// <param name="comparer">63        /// Checks if the read shared state is equal with another shared state that is being accessed concurrently.64        /// </param>65        public static void Read(string state, IEqualityComparer<string> comparer = default)66        {67            var runtime = CoyoteRuntime.Current;68            if (runtime.SchedulingPolicy != SchedulingPolicy.None &&69                runtime.TryGetExecutingOperation(out ControlledOperation current))70            {71                if (runtime.SchedulingPolicy is SchedulingPolicy.Interleaving)72                {73                    runtime.ScheduleNextOperation(current, SchedulingPointType.Read, isSuppressible: false);74                }75                else if (runtime.SchedulingPolicy is SchedulingPolicy.Fuzzing)76                {77                    runtime.DelayOperation(current);78                }79            }80        }81        /// <summary>82        /// Explores a possible interleaving due to a 'WRITE' operation on the specified shared state.83        /// </summary>84        /// <param name="state">The shared state that is being written represented as a string.</param>85        /// <param name="comparer">86        /// Checks if the written shared state is equal with another shared state that is being accessed concurrently.87        /// </param>88        public static void Write(string state, IEqualityComparer<string> comparer = default)89        {90            var runtime = CoyoteRuntime.Current;91            if (runtime.SchedulingPolicy != SchedulingPolicy.None &&92                runtime.TryGetExecutingOperation(out ControlledOperation current))93            {94                if (runtime.SchedulingPolicy is SchedulingPolicy.Interleaving)95                {96                    runtime.ScheduleNextOperation(current, SchedulingPointType.Write, isSuppressible: false);97                }98                else if (runtime.SchedulingPolicy is SchedulingPolicy.Fuzzing)99                {100                    runtime.DelayOperation(current);101                }102            }103        }104        /// <summary>105        /// Suppresses interleavings until <see cref="Resume"/> is invoked.106        /// </summary>107        /// <remarks>108        /// This method does not suppress interleavings that happen when an operation is waiting109        /// some other operation to complete, when an operation completes and the scheduler110        /// switches to a new operation, or interleavings from uncontrolled concurrency.111        /// </remarks>112        public static void Suppress()113        {114            var runtime = CoyoteRuntime.Current;115            if (runtime.SchedulingPolicy is SchedulingPolicy.Interleaving)116            {117                runtime.SuppressScheduling();118            }119        }120        /// <summary>121        /// Resumes interleavings that were suppressed by invoking <see cref="Suppress"/>.122        /// </summary>123        public static void Resume()124        {125            var runtime = CoyoteRuntime.Current;126            if (runtime.SchedulingPolicy is SchedulingPolicy.Interleaving)127            {128                runtime.ResumeScheduling();129            }130        }131        /// <summary>132        /// Sets a checkpoint in the execution path that is so far explored during the current133        /// test iteration. This will capture all controlled scheduling and nondeterministic134        /// decisions taken until the checkpoint and the testing engine will then try to replay135        /// the same decisions in subsequent iterations before performing any new exploration....

SchedulingPointTests.cs

Source:SchedulingPointTests.cs

...72            expectedError: "A: 1, B: 1",73            replay: true);74        }75        [Fact(Timeout = 5000)]76        public void TestSuppressTaskInterleaving()77        {78            this.Test(async r =>79            {80                int value = 0;81                SchedulingPoint.Suppress();82                var t = Task.Run(() =>83                {84                    value = 2;85                });86                SchedulingPoint.Resume();87                value = 1;88                await t;89                Specification.Assert(value is 2, $"Value is {value}.");90            },91            configuration: this.GetConfiguration().WithTestingIterations(100));92        }93        [Fact(Timeout = 5000)]94        public void TestAvoidSuppressTaskInterleaving()95        {96            this.TestWithError(async r =>97            {98                int value = 0;99                SchedulingPoint.Suppress();100                var t = Task.Run(() =>101                {102                    value = 2;103                });104                SchedulingPoint.Interleave();105                SchedulingPoint.Resume();106                value = 1;107                await t;108                Specification.Assert(value is 2, $"Value is {value}.");109            },110            configuration: this.GetConfiguration().WithTestingIterations(100),111            expectedError: "Value is 1.",112            replay: true);113        }114        [Fact(Timeout = 5000)]115        public void TestSuppressAndResumeTaskInterleaving()116        {117            this.TestWithError(async r =>118            {119                int value = 0;120                SchedulingPoint.Suppress();121                SchedulingPoint.Resume();122                var t = Task.Run(() =>123                {124                    value = 2;125                });126                value = 1;127                await t;128                Specification.Assert(value is 2, $"Value is {value}.");129            },130            configuration: this.GetConfiguration().WithTestingIterations(100),131            expectedError: "Value is 1.",132            replay: true);133        }134        [Fact(Timeout = 5000)]135        public void TestSuppressLockInterleaving()136        {137            this.Test(async r =>138            {139                var set = new HashSet<int>();140                var t1 = Task.Run(() =>141                {142                    SchedulingPoint.Suppress();143                    lock (set)144                    {145                        set.Remove(1);146                    }147                    lock (set)148                    {149                        set.Add(2);150                    }151                    SchedulingPoint.Resume();152                });153                var t2 = Task.Run(() =>154                {155                    SchedulingPoint.Suppress();156                    lock (set)157                    {158                        set.Remove(2);159                    }160                    lock (set)161                    {162                        set.Add(1);163                    }164                    SchedulingPoint.Resume();165                });166                await Task.WhenAll(t1, t2);167                Specification.Assert(set.Count is 1, $"Count is {set.Count}.");168            },169            configuration: this.GetConfiguration().WithTestingIterations(100));170        }171        [Fact(Timeout = 5000)]172        public void TestSuppressNoResumeTaskInterleaving()173        {174            this.Test(async r =>175            {176                // Make sure the scheduler does not deadlock.177                SchedulingPoint.Suppress();178                // Only interleavings of enabled operations should be suppressed.179                await Task.Run(() => { });180            },181            configuration: this.GetConfiguration().WithTestingIterations(100));182        }183    }184}...

Suppress

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Actors;5using Microsoft.Coyote.Tasks;6using Microsoft.Coyote.Runtime;7using Microsoft.Coyote.Specifications;8using Microsoft.Coyote.Actors.Timers;9using Microsoft.Coyote.SystematicTesting;10using Microsoft.Coyote.Actors.BugFinding;11using Microsoft.Coyote.Actors.BugFinding.Strategies;12using Microsoft.Coyote.Actors.BugFinding.Strategies.FaultInjection;13using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration;14using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies;15using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies.BoundedExploration;16using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies.UnboundedExploration;17using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies.UnboundedExploration.Heuristics;18using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies.UnboundedExploration.Heuristics.Fairness;19using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies.UnboundedExploration.Heuristics.Random;20using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies.UnboundedExploration.Heuristics.SchedulingPoints;21using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies.UnboundedExploration.Heuristics.StateSpace;22using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies.UnboundedExploration.Heuristics.StateSpace.GlobalState;23using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies.UnboundedExploration.Heuristics.StateSpace.LocalState;24using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies.UnboundedExploration.Heuristics.StateSpace.StateGraph;25using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies.UnboundedExploration.Heuristics.StateSpace.StateGraph.Strategies;26using Microsoft.Coyote.Actors.BugFinding.Strategies.ScheduleExploration.Strategies.UnboundedExploration.Heuristics.StateSpace.StateGraph.Strategies.BugFinding;

Suppress

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Actors;5using Microsoft.Coyote.Tasks;6using Microsoft.Coyote.SystematicTesting;7using Microsoft.Coyote.Runtime;8{9    {10        static void Main(string[] args)11        {12            var configuration = Configuration.Create();13            configuration.SchedulingIterations = 100;14            configuration.SchedulingStrategy = SchedulingStrategy.DFS;15            configuration.Verbose = 1;16            configuration.SuppressDeadlockDetection = true;17            var test = new SystematicTestingEngine(configuration);18            test.RegisterEventHandler(typeof(Task), typeof(MyTaskEventHandler));19            test.RegisterEventHandler(typeof(Actor), typeof(MyActorEventHandler));20            test.RegisterMonitor(typeof(MyMonitor));21            test.TestProgram(typeof(Program), "Test1");22        }23        public static void Test1()24        {25            SchedulingPoint.Suppress();26            Console.WriteLine("Hello World!");27        }28    }29    {30        protected override Task OnCreateTaskAsync(Task task)31        {32            Console.WriteLine("OnCreateTaskAsync");33            return base.OnCreateTaskAsync(task);34        }35    }36    {37        protected override Task OnCreateActorAsync(Actor actor)38        {39            Console.WriteLine("OnCreateActorAsync");40            return base.OnCreateActorAsync(actor);41        }42    }43    {44        [Microsoft.Coyote.SystematicTesting.OnEventDoAction(typeof(Microsoft.Coyote.Runtime.SchedulingPoint), nameof(OnSchedulingPoint))]45        class SchedulingPointEvent : Event { }46        void OnSchedulingPoint()47        {48            Console.WriteLine("OnSchedulingPoint");49        }50    }51}52{53    "runtime": {

Suppress

Using AI Code Generation

1using Microsoft.Coyote.Runtime;2using System;3using System.Threading.Tasks;4{5    {6        static void Main(string[] args)7        {8            Console.WriteLine("Hello World!");9            SchedulingPoint.Suppress();10            Console.WriteLine("Hello World!");11            Console.ReadLine();12        }13    }14}15using Microsoft.Coyote.Runtime;16using Microsoft.Coyote.Tasks;17using System;18using System.Threading.Tasks;19{20    {21        static void Main(string[] args)22        {23            Console.WriteLine("Hello World!");24            SchedulingPoint.Suppress();25            Console.WriteLine("Hello World!");26            Console.ReadLine();27        }28    }29}30using Microsoft.Coyote;31using Microsoft.Coyote.Tasks;32using Microsoft.Coyote.Testing;33using Microsoft.Coyote.Testing.Systematic;34using System;35using System.Threading.Tasks;36using Xunit;37{38    {39        public void Test1()40        {41            this.Test(r =>42            {43                r.CreateActor(typeof(Program));44            });45        }46    }47}

Suppress

Using AI Code Generation

1using System;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 config = Configuration.Create();11            config.SchedulingIterations = 100;12            config.SchedulingStrategy = SchedulingStrategy.PCT;13            config.SchedulingSeed = 1;14            config.SchedulingVerbosity = 1;15            config.SchedulingMaxSteps = 1000;16            config.SchedulingMaxFairSchedulesToExplore = 1000;17            config.SchedulingMaxFairSchedulesToDisplay = 1000;18            config.SchedulingFairScheduling = true;19            config.SchedulingFairSchedulingWithPriority = true;20            config.SchedulingFairSchedulingWithFairness = true;21            config.SchedulingFairSchedulingWithPriorityAndFairness = true;22            config.SchedulingMaxInterleavingsToExplore = 1000;23            config.SchedulingMaxInterleavingsToDisplay = 1000;24            config.SchedulingMaxFairInterleavingsToExplore = 1000;25            config.SchedulingMaxFairInterleavingsToDisplay = 1000;26            config.SchedulingFairInterleavingWithPriority = true;27            config.SchedulingFairInterleavingWithFairness = true;28            config.SchedulingFairInterleavingWithPriorityAndFairness = true;29            config.SchedulingMaxFairIterations = 1000;30            config.SchedulingMaxFairSteps = 1000;31            config.SchedulingMaxFairSchedules = 1000;32            config.SchedulingMaxFairInterleavings = 1000;33            config.SchedulingMaxUnfairIterations = 1000;34            config.SchedulingMaxUnfairSteps = 1000;35            config.SchedulingMaxUnfairSchedules = 1000;36            config.SchedulingMaxUnfairInterleavings = 1000;37            config.SchedulingMaxStepsPerScheduling = 1000;38            config.SchedulingMaxFairStepsPerScheduling = 1000;39            config.SchedulingMaxUnfairStepsPerScheduling = 1000;40            config.SchedulingMaxFairSchedulesPerScheduling = 1000;41            config.SchedulingMaxUnfairSchedulesPerScheduling = 1000;42            config.SchedulingMaxFairInterleavingsPerScheduling = 1000;

Suppress

Using AI Code Generation

1using Microsoft.Coyote.Runtime;2{3    {4        static void Main(string[] args)5        {6            SchedulingPoint.Suppress();7        }8    }9}10using Microsoft.Coyote.Runtime;11{12    {13        static void Main(string[] args)14        {15            SchedulingPoint.Suppress();16        }17    }18}19using Microsoft.Coyote.Runtime;20{21    {22        static void Main(string[] args)23        {24            SchedulingPoint.Suppress();25        }26    }27}28using Microsoft.Coyote.Runtime;29{30    {31        static void Main(string[] args)32        {33            SchedulingPoint.Suppress();34        }35    }36}37using Microsoft.Coyote.Runtime;38{39    {40        static void Main(string[] args)41        {42            SchedulingPoint.Suppress();43        }44    }45}46using Microsoft.Coyote.Runtime;47{48    {49        static void Main(string[] args)50        {51            SchedulingPoint.Suppress();52        }53    }54}55using Microsoft.Coyote.Runtime;56{57    {58        static void Main(string[] args)59        {60            SchedulingPoint.Suppress();61        }62    }63}64using Microsoft.Coyote.Runtime;65{66    {67        static void Main(string[] args)68        {69            SchedulingPoint.Suppress();70        }71    }72}

Suppress

Using AI Code Generation

1using System;2using System.Collections.Generic;3using System.Linq;4using System.Text;5using System.Threading.Tasks;6using Microsoft.Coyote.Runtime;7using Microsoft.Coyote.Specifications;8{9    {10        static void Main(string[] args)11        {12            SchedulingPoint.Suppress();13            Console.WriteLine("Hello World!");14        }15    }16}17using System;18using System.Collections.Generic;19using System.Linq;20using System.Text;21using System.Threading.Tasks;22using Microsoft.Coyote.Runtime;23using Microsoft.Coyote.Specifications;24{25    {26        static void Main(string[] args)27        {28            SchedulingPoint.Suppress();29            Console.WriteLine("Hello World!");30        }31    }32}

Suppress

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Actors;5using Microsoft.Coyote.Runtime;6using Microsoft.Coyote.Actors.Timers;7{8    {9        private static void Main(string[] args)10        {11            using (var runtime = RuntimeFactory.Create())12            {13                runtime.CreateActor(typeof(Program));14                runtime.RunAsync().Wait();15            }16        }17        [OnEventDoAction(typeof(UnitEvent), nameof(OnStart))]18        private class Init : MachineState { }19        private void OnStart()20        {21            this.CreateActor(typeof(Actor1));22        }23        [OnEventDoAction(typeof(UnitEvent), nameof(OnEvent))]24        private class Actor1State : MachineState { }25        private void OnEvent()26        {27            SchedulingPoint.Suppress();28            Console.WriteLine("Hello World!");29        }30    }31    {32        protected override Task OnInitializeAsync(Event initialEvent)33        {34            this.SendEvent(this.Id, UnitEvent.Instance);35            return Task.CompletedTask;36        }37    }38}

Suppress

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote.Actors;4using Microsoft.Coyote.Runtime;5using Microsoft.Coyote.Specifications;6using Microsoft.Coyote.Tasks;7{8    {9        static async Task Main(string[] args)10        {11            var runtime = RuntimeFactory.Create();12            runtime.ConfigureEventLogging(1);13            runtime.CreateActor(typeof(Monitor));14            await Task.CompletedTask;15        }16    }17    {18        protected override Task OnInitializeAsync(Event initialEvent)19        {20            this.CreateActor(typeof(Actor1));21            this.CreateActor(typeof(Actor2));22            return Task.CompletedTask;23        }24    }25    {26        protected override Task OnInitializeAsync(Event initialEvent)27        {28            this.SendEvent(this.Id, new E1());29            return Task.CompletedTask;30        }31        protected override Task OnEventAsync(Event e)32        {33            if (e is E1)34            {35                SchedulingPoint.Suppress();36                this.SendEvent(this.Id, new E2());37            }38            else if (e is E2)39            {40                SchedulingPoint.Suppress();41                this.SendEvent(this.Id, new E1());42            }43            return Task.CompletedTask;44        }45    }46    {47        protected override Task OnInitializeAsync(Event initialEvent)48        {49            this.SendEvent(this.Id, new E1());50            return Task.CompletedTask;51        }52        protected override Task OnEventAsync(Event e)53        {54            if (e is E1)55            {56                SchedulingPoint.Suppress();57                this.SendEvent(this.Id, new E2());58            }59            else if (e is E2)60            {61                SchedulingPoint.Suppress();62                this.SendEvent(this.Id, new E1());63            }64            return Task.CompletedTask;65        }66    }67    class E1 : Event { }68    class E2 : Event { }69}70using System;71using System.Threading.Tasks;72using Microsoft.Coyote.Actors;73using Microsoft.Coyote.Runtime;74using Microsoft.Coyote.Specifications;75using Microsoft.Coyote.Tasks;76{77    {

Suppress

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Actors;5using Microsoft.Coyote.Runtime;6{7    {8        public static void Main(string[] args)9        {10            var runtime = RuntimeFactory.Create();11            runtime.RegisterMonitor(typeof(Monitor1));12            runtime.CreateActor(typeof(Actor1));13            runtime.Wait();14        }15    }16    {17        protected override Task OnInitializeAsync(Event initialEvent)18        {19            this.SendEvent(this.Id, new E1());20            this.SendEvent(this.Id, new E2());21            this.SendEvent(this.Id, new E3());22            return Task.CompletedTask;23        }24    }25    {26        [OnEventDoAction(typeof(E1), nameof(HandleE1))]27        [OnEventDoAction(typeof(E2), nameof(HandleE2))]28        [OnEventDoAction(typeof(E3), nameof(HandleE3))]29        private class Init : MonitorState { }30        private void HandleE1()31        {32            SchedulingPoint.Suppress(this);33        }34        private void HandleE2()35        {36            SchedulingPoint.Suppress(this);37        }38        private void HandleE3()39        {40            SchedulingPoint.Suppress(this);41        }42    }43    public class E1 : Event { }44    public class E2 : Event { }45    public class E3 : Event { }46}

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.