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

How to use OperationGroup method of Microsoft.Coyote.Runtime.OperationGroup class

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

PrioritizationStrategy.cs

Source:PrioritizationStrategy.cs

...18    {19        /// <summary>20        /// List of prioritized operation groups.21        /// </summary>22        private readonly List<OperationGroup> PrioritizedOperationGroups;23        /// <summary>24        /// Scheduling points in the current execution where a priority change should occur.25        /// </summary>26        private readonly HashSet<int> PriorityChangePoints;27        /// <summary>28        /// Number of potential priority change points in the current iteration.29        /// </summary>30        private int NumPriorityChangePoints;31        /// <summary>32        /// Max number of potential priority change points across all iterations.33        /// </summary>34        private int MaxPriorityChangePoints;35        /// <summary>36        /// Max number of priority changes per iteration.37        /// </summary>38        private readonly int MaxPriorityChanges;39        /// <summary>40        /// Initializes a new instance of the <see cref="PrioritizationStrategy"/> class.41        /// </summary>42        internal PrioritizationStrategy(Configuration configuration, IRandomValueGenerator generator, bool isFair)43            : base(configuration, generator, isFair)44        {45            this.PrioritizedOperationGroups = new List<OperationGroup>();46            this.PriorityChangePoints = new HashSet<int>();47            this.NumPriorityChangePoints = 0;48            this.MaxPriorityChangePoints = 0;49            this.MaxPriorityChanges = configuration.StrategyBound;50        }51        /// <inheritdoc/>52        internal override bool InitializeNextIteration(uint iteration)53        {54            // The first iteration has no knowledge of the execution, so only initialize from the second55            // iteration and onwards. Note that although we could initialize the first length based on a56            // heuristic, its not worth it, as the strategy will typically explore thousands of iterations,57            // plus its also interesting to explore a schedule with no forced priority switch points.58            if (iteration > 0)59            {60                this.PrioritizedOperationGroups.Clear();61                this.PriorityChangePoints.Clear();62                this.MaxPriorityChangePoints = Math.Max(63                    this.MaxPriorityChangePoints, this.NumPriorityChangePoints);64                if (this.MaxPriorityChanges > 0)65                {66                    var priorityChanges = this.RandomValueGenerator.Next(this.MaxPriorityChanges) + 1;67                    var range = Enumerable.Range(0, this.MaxPriorityChangePoints);68                    foreach (int point in this.Shuffle(range).Take(priorityChanges))69                    {70                        this.PriorityChangePoints.Add(point);71                    }72                }73                this.DebugPrintPriorityChangePoints();74            }75            this.NumPriorityChangePoints = 0;76            return base.InitializeNextIteration(iteration);77        }78        /// <inheritdoc/>79        internal override bool NextOperation(IEnumerable<ControlledOperation> ops, ControlledOperation current,80            bool isYielding, out ControlledOperation next)81        {82            if (this.IsFair && this.StepCount >= this.Configuration.MaxUnfairSchedulingSteps)83            {84                return base.NextOperation(ops, current, isYielding, out next);85            }86            // Set the priority of any new operation groups.87            this.SetNewOperationGroupPriorities(ops, current);88            // Check if there are at least two operation groups that can be scheduled,89            // otherwise skip the priority checking and changing logic.90            if (ops.Select(op => op.Group).Distinct().Skip(1).Any())91            {92                // Try to change the priority of the highest priority operation group.93                // If the shared-state reduction is enabled, check if there is at least94                // one 'WRITE' operation, before trying to change the priority.95                if (!this.Configuration.IsSharedStateReductionEnabled ||96                    ops.Any(op => op.LastSchedulingPoint is SchedulingPointType.Write))97                {98                    this.TryPrioritizeNextOperationGroup(ops);99                }100                // Get the operations that belong to the highest priority group.101                OperationGroup nextGroup = this.GetOperationGroupWithHighestPriority(ops);102                ops = ops.Where(op => nextGroup.IsMember(op));103            }104            int idx = this.RandomValueGenerator.Next(ops.Count());105            next = ops.ElementAt(idx);106            return true;107        }108        /// <summary>109        /// Returns the operation group with the highest priority.110        /// </summary>111        private OperationGroup GetOperationGroupWithHighestPriority(IEnumerable<ControlledOperation> ops)112        {113            foreach (var group in this.PrioritizedOperationGroups)114            {115                if (ops.Any(op => op.Group == group))116                {117                    return group;118                }119            }120            return null;121        }122        /// <summary>123        /// Sets a random priority to any new operation groups.124        /// </summary>125        private void SetNewOperationGroupPriorities(IEnumerable<ControlledOperation> ops, ControlledOperation current)126        {127            int count = this.PrioritizedOperationGroups.Count;128            if (count is 0)129            {130                this.PrioritizedOperationGroups.Add(current.Group);131            }132            // Randomize the priority of all new operation groups.133            foreach (var group in ops.Select(op => op.Group).Where(g => !this.PrioritizedOperationGroups.Contains(g)))134            {135                // Randomly choose a priority for this group.136                int index = this.RandomValueGenerator.Next(this.PrioritizedOperationGroups.Count) + 1;137                this.PrioritizedOperationGroups.Insert(index, group);138                Debug.WriteLine("[coyote::strategy] Assigned priority '{0}' for operation group '{1}'.", index, group);139            }140            if (this.PrioritizedOperationGroups.Count > count)141            {142                this.DebugPrintOperationPriorityList();143            }144        }145        /// <summary>146        /// Reduces the priority of highest priority operation group, if there is a priority147        /// change point installed on the current execution step.148        /// </summary>149        private bool TryPrioritizeNextOperationGroup(IEnumerable<ControlledOperation> ops)150        {151            OperationGroup group = null;152            if (this.PriorityChangePoints.Contains(this.NumPriorityChangePoints))153            {154                // This scheduling step was chosen as a priority change point.155                group = this.GetOperationGroupWithHighestPriority(ops);156                Debug.WriteLine("[coyote::strategy] Reduced the priority of operation group '{0}'.", group);157            }158            this.NumPriorityChangePoints++;159            if (group != null)160            {161                // Reduce the priority of the group by putting it in the end of the list.162                this.PrioritizedOperationGroups.Remove(group);163                this.PrioritizedOperationGroups.Add(group);164                return true;165            }166            return false;167        }168        /// <inheritdoc/>169        internal override string GetDescription() =>170            $"prioritization[fair:{this.IsFair},bound:{this.MaxPriorityChanges},seed:{this.RandomValueGenerator.Seed}]";171        /// <summary>172        /// Shuffles the specified range using the Fisher-Yates algorithm.173        /// </summary>174        /// <remarks>175        /// See https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle.176        /// </remarks>177        private IList<int> Shuffle(IEnumerable<int> range)178        {179            var result = new List<int>(range);180            for (int idx = result.Count - 1; idx >= 1; idx--)181            {182                int point = this.RandomValueGenerator.Next(result.Count);183                int temp = result[idx];184                result[idx] = result[point];185                result[point] = temp;186            }187            return result;188        }189        /// <inheritdoc/>190        internal override void Reset()191        {192            this.NumPriorityChangePoints = 0;193            this.PrioritizedOperationGroups.Clear();194            this.PriorityChangePoints.Clear();195            base.Reset();196        }197        /// <summary>198        /// Print the operation group priority list, if debug is enabled.199        /// </summary>200        private void DebugPrintOperationPriorityList()201        {202            if (Debug.IsEnabled)203            {204                Debug.WriteLine("[coyote::strategy] Updated operation group priority list: ");205                for (int idx = 0; idx < this.PrioritizedOperationGroups.Count; idx++)206                {207                    var group = this.PrioritizedOperationGroups[idx];208                    if (group.Any(m => m.Status is OperationStatus.Enabled))209                    {210                        Debug.WriteLine("  |_ [{0}] operation group with id '{1}' [enabled]", idx, group);211                    }212                    else if (group.Any(m => m.Status != OperationStatus.Completed))213                    {214                        Debug.WriteLine("  |_ [{0}] operation group with id '{1}'", idx, group);215                    }216                }217            }218        }219        /// <summary>220        /// Print the priority change points, if debug is enabled.221        /// </summary>...

ControlledOperation.cs

Source:ControlledOperation.cs

...30        /// <summary>31        /// The group where this operation has membership. This can be used32        /// by the scheduler to optimize exploration.33        /// </summary>34        internal readonly OperationGroup Group;35        /// <summary>36        /// Queue of continuations that this operation must execute before it completes.37        /// </summary>38        private readonly Queue<Action> Continuations;39        /// <summary>40        /// Dependency that must get resolved before this operation can resume executing.41        /// </summary>42        private Func<bool> Dependency;43        /// <summary>44        /// Synchronization mechanism for controlling the execution of this operation.45        /// </summary>46        private ManualResetEventSlim SyncEvent;47        /// <summary>48        /// The type of the last encountered scheduling point.49        /// </summary>50        internal SchedulingPointType LastSchedulingPoint;51        /// <summary>52        /// A value that represents the hashed program state when this operation last executed.53        /// </summary>54        internal int LastHashedProgramState;55        /// <summary>56        /// A value that represents the shared state being accessed when this57        /// operation last executed, if there was any such state access.58        /// </summary>59        internal string LastAccessedSharedState;60        /// <summary>61        /// True if the source of this operation is uncontrolled, else false.62        /// </summary>63        internal bool IsSourceUncontrolled;64        /// <summary>65        /// True if the dependency is uncontrolled, else false.66        /// </summary>67        internal bool IsDependencyUncontrolled;68        /// <summary>69        /// True if this is the root operation, else false.70        /// </summary>71        internal bool IsRoot => this.Id is 0;72        /// <summary>73        /// True if this operation is currently paused, else false.74        /// </summary>75        internal bool IsPaused =>76            this.Status is OperationStatus.Paused ||77            this.Status is OperationStatus.PausedOnDelay ||78            this.Status is OperationStatus.PausedOnResource ||79            this.Status is OperationStatus.PausedOnReceive;80        /// <summary>81        /// Initializes a new instance of the <see cref="ControlledOperation"/> class.82        /// </summary>83        internal ControlledOperation(ulong operationId, string name, OperationGroup group, CoyoteRuntime runtime)84        {85            this.Runtime = runtime;86            this.Id = operationId;87            this.Name = name;88            this.Status = OperationStatus.None;89            this.Group = group ?? OperationGroup.Create(this);90            this.Continuations = new Queue<Action>();91            this.SyncEvent = new ManualResetEventSlim(false);92            this.LastSchedulingPoint = SchedulingPointType.Start;93            this.LastHashedProgramState = 0;94            this.LastAccessedSharedState = string.Empty;95            this.IsSourceUncontrolled = false;96            this.IsDependencyUncontrolled = false;97            // Register this operation with the runtime.98            this.Runtime.RegisterNewOperation(this);99        }100        /// <summary>101        /// Executes all continuations of this operation in order, if there are any.102        /// </summary>103        internal void ExecuteContinuations()...

OperationGroup.cs

Source:OperationGroup.cs

...8{9    /// <summary>10    /// Represents a group of controlled operations that can be scheduled together during testing.11    /// </summary>12    internal class OperationGroup : IEnumerable<ControlledOperation>, IEquatable<OperationGroup>13    {14        /// <summary>15        /// Provides access to the operation group associated with each async local context,16        /// or null if the current async local context has no associated group.17        /// </summary>18        private protected static readonly AsyncLocal<OperationGroup> AsyncLocalGroup =19            new AsyncLocal<OperationGroup>();20        /// <summary>21        /// The operation group associated with the current execution context, if any.22        /// </summary>23        internal static OperationGroup Current => AsyncLocalGroup.Value;24        /// <summary>25        /// The unique id of this group.26        /// </summary>27        internal readonly Guid Id;28        /// <summary>29        /// The controlled operation that owns this group.30        /// </summary>31        internal readonly ControlledOperation Owner;32        /// <summary>33        /// The controlled operations that are members of this group.34        /// </summary>35        private readonly HashSet<ControlledOperation> Members;36        /// <summary>37        /// Initializes a new instance of the <see cref="OperationGroup"/> class.38        /// </summary>39        private OperationGroup(Guid? id, ControlledOperation owner)40        {41            this.Id = id ?? Guid.NewGuid();42            this.Owner = owner;43            this.Members = new HashSet<ControlledOperation>();44        }45        /// <summary>46        /// Creates a new <see cref="OperationGroup"/> instance.47        /// </summary>48        internal static OperationGroup Create(ControlledOperation owner) => Create(null, owner);49        /// <summary>50        /// Creates a new <see cref="OperationGroup"/> instance with the specified id.51        /// </summary>52        internal static OperationGroup Create(Guid? id, ControlledOperation owner) => new OperationGroup(id, owner);53        /// <summary>54        /// Registers the specified operation as a member of this group.55        /// </summary>56        internal void RegisterMember(ControlledOperation member) => this.Members.Add(member);57        /// <summary>58        /// Returns an enumerator that iterates through the members of this group.59        /// </summary>60        public IEnumerator<ControlledOperation> GetEnumerator()61        {62            foreach (ControlledOperation op in this.Members)63            {64                yield return op;65            }66        }67        /// <summary>68        /// Returns an enumerator that iterates through the members of this group.69        /// </summary>70        IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();71        /// <summary>72        /// Returns true if the specified operation is a member of this group, else false.73        /// </summary>74        internal bool IsMember(ControlledOperation operation) => this.Members.Contains(operation);75        /// <summary>76        /// Associates the specified operation group with the currently executing thread,77        /// allowing future retrieval in the same thread, as well as across threads that78        /// share the same asynchronous control flow.79        /// </summary>80        internal static void SetCurrent(OperationGroup group)81        {82            if (group != null)83            {84                AsyncLocalGroup.Value = group;85            }86        }87        /// <summary>88        /// Determines whether the specified object is equal to the current object.89        /// </summary>90        public override bool Equals(object obj)91        {92            if (obj is OperationGroup op)93            {94                return this.Id == op.Id;95            }96            return false;97        }98        /// <summary>99        /// Returns the hash code for this instance.100        /// </summary>101        public override int GetHashCode() => this.Id.GetHashCode();102        /// <summary>103        /// Returns a string that represents the current group id.104        /// </summary>105        public override string ToString() => this.Id.ToString();106        /// <summary>107        /// Indicates whether the specified <see cref="OperationGroup"/> is equal108        /// to the current <see cref="OperationGroup"/>.109        /// </summary>110        public bool Equals(OperationGroup other) => this.Equals((object)other);111        /// <summary>112        /// Indicates whether the specified <see cref="OperationGroup"/> is equal113        /// to the current <see cref="OperationGroup"/>.114        /// </summary>115        bool IEquatable<OperationGroup>.Equals(OperationGroup other) => this.Equals(other);116        /// <summary>117        /// Removes this operation group from the local context.118        /// </summary>119        internal static void RemoveFromContext()120        {121            AsyncLocalGroup.Value = null;122        }123    }124}...

OperationGroup

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Actors;5using Microsoft.Coyote.Runtime;6{7    {8        static void Main(string[] args)9        {10            RunAsync().Wait();11        }12        static async Task RunAsync()13        {14            var group = OperationGroup.Create();15            Task task1 = Task.Run(() => DoWork(group, 1000));16            Task task2 = Task.Run(() => DoWork(group, 5000));17            await Task.WhenAll(task1, task2);18        }19        static void DoWork(OperationGroup group, int milliseconds)20        {21            group.Perform(() =>22            {23                Console.WriteLine("Starting work...");24                Task.Delay(milliseconds).Wait();25                Console.WriteLine("Finished work.");26            });27        }28    }29}30using System;31using System.Threading.Tasks;32using Microsoft.Coyote;33using Microsoft.Coyote.Actors;34using Microsoft.Coyote.Runtime;35{36    {37        static void Main(string[] args)38        {39            RunAsync().Wait();40        }41        static async Task RunAsync()42        {43            var group = OperationGroup.Create();44            Task task1 = Task.Run(() => DoWork(group, 1000));45            Task task2 = Task.Run(() => DoWork(group, 5000));46            await Task.WhenAll(task1, task2);47        }48        static void DoWork(OperationGroup group, int milliseconds)49        {50            group.Perform(() =>51            {52                Console.WriteLine("Starting work...");53                Task.Delay(milliseconds).Wait();54                Console.WriteLine("Finished work.");55            });56        }57    }58}59using System;60using System.Threading.Tasks;61using Microsoft.Coyote;62using Microsoft.Coyote.Actors;63using Microsoft.Coyote.Runtime;

OperationGroup

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 group = new OperationGroup();11            var task1 = Task.Run(async () =>12            {13                await group.RunAsync(async () =>14                {15                    await Task.Delay(1000);16                    Console.WriteLine("Task 1");17                });18            });19            var task2 = Task.Run(async () =>20            {21                await group.RunAsync(async () =>22                {23                    await Task.Delay(1000);24                    Console.WriteLine("Task 2");25                });26            });27            var task3 = Task.Run(async () =>28            {29                await group.RunAsync(async () =>30                {31                    await Task.Delay(1000);32                    Console.WriteLine("Task 3");33                });34            });35            Task.WaitAll(task1, task2, task3);36        }37    }38}39using System;40using System.Threading.Tasks;41using Microsoft.Coyote;42using Microsoft.Coyote.Actors;43using Microsoft.Coyote.Runtime;44{45    {46        public static void Main(string[] args)47        {48            var group = new OperationGroup();49            var task1 = Task.Run(async () =>50            {51                await group.RunAsync(async () =>52                {53                    await Task.Delay(1000);54                    Console.WriteLine("Task 1");55                });56            });57            var task2 = Task.Run(async () =>58            {59                await group.RunAsync(async () =>60                {61                    await Task.Delay(1000);62                    Console.WriteLine("Task 2");63                });64            });

OperationGroup

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Actors;5using Microsoft.Coyote.Runtime;6{7    {8        static void Main(string[] args)9        {10            Console.WriteLine("Hello World!");11            var options = Configuration.Create();12            options.WithVerbosityEnabled(Verbosity.Verbose);13            options.WithRandomSchedulingEnabled();14            options.WithMaxSchedulingSteps(1000);15            options.WithTestingIterations(1000);16            options.WithMaxFairSchedulingSteps(1000);17            options.WithMaxStepsFromBugFinding(1000);18            options.WithMaxUnfairSchedulingSteps(1000);19            options.WithMaxStepsFromAnyBugFinding(1000);20            options.WithMaxStepsFromLivelockFinding(1000);

OperationGroup

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Actors;5using Microsoft.Coyote.SystematicTesting;6{7    {8        public static void Main(string[] args)9        {10            var configuration = Configuration.Create();11            configuration.MaxSchedulingSteps = 100;12            configuration.MaxFairSchedulingSteps = 100;13            configuration.TestingIterations = 10;14            configuration.Verbose = 1;15            configuration.SchedulingStrategy = SchedulingStrategy.FairPCT;16            configuration.EnableCycleDetection = true;17            configuration.EnableDataRaceDetection = true;18            configuration.EnableHotStateDetection = true;19            configuration.EnableLivelockDetection = true;20            configuration.EnableDeadlockDetection = true;21            configuration.EnableOperationStackTraces = true;22            configuration.EnableActorTaskStackTraces = true;23            configuration.EnableBuggyActorStateTracking = true;

OperationGroup

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Actors;5using Microsoft.Coyote.Runtime;6using Microsoft.Coyote.Specifications;7{8    {9        [OnEventDoAction(typeof(UnitEvent), nameof(DoWork))]10        {11        }12        private void DoWork()13        {14            OperationGroup.Start("MyGrou

OperationGroup

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote.Actors;4using Microsoft.Coyote.Runtime;5{6    {7        private static async Task Main(string[] args)8        {9            var runtime = RuntimeFactory.Create();10            await runtime.CreateActor(typeof(Actor1));11            await runtime.CreateActor(typeof(Actor2));12            await runtime.CreateActor(typeof(Actor3));13            await runtime.CreateActor(typeof(Actor4));14            await runtime.CreateActor(typeof(Actor5));15            await runtime.CreateActor(typeof(Actor6));16            await runtime.CreateActor(typeof(Actor7));17            await runtime.CreateActor(typeof(Actor8));18            await runtime.CreateActor(typeof(Actor9));19            await runtime.CreateActor(typeof(Actor10));20            await runtime.CreateActor(typeof(Actor11));21            await runtime.CreateActor(typeof(Actor12));22            await runtime.CreateActor(typeof(Actor13));23            await runtime.CreateActor(typeof(Actor14));24            await runtime.CreateActor(typeof(Actor15));25            await runtime.CreateActor(typeof(Actor16));26            await runtime.CreateActor(typeof(Actor17));27            await runtime.CreateActor(typeof(Actor18));28            await runtime.CreateActor(typeof(Actor19));29            await runtime.CreateActor(typeof(Actor20));30            await runtime.CreateActor(typeof(Actor21));31            await runtime.CreateActor(typeof(Actor22));32            await runtime.CreateActor(typeof(Actor23));33            await runtime.CreateActor(typeof(Actor24));34            await runtime.CreateActor(typeof(Actor25));35            await runtime.CreateActor(typeof(Actor26));36            await runtime.CreateActor(typeof(Actor27));37            await runtime.CreateActor(typeof(Actor28));38            await runtime.CreateActor(typeof(Actor29));39            await runtime.CreateActor(typeof(Actor30));40            await runtime.CreateActor(typeof(Actor31));41            await runtime.CreateActor(typeof(Actor32));42            await runtime.CreateActor(typeof(Actor33));43            await runtime.CreateActor(typeof(Actor34));44            await runtime.CreateActor(typeof(Actor35));45            await runtime.CreateActor(typeof(Actor36));46            await runtime.CreateActor(typeof(Actor37));47            await runtime.CreateActor(typeof(Actor38));48            await runtime.CreateActor(typeof(Actor39));49            await runtime.CreateActor(typeof(Actor40));50            await runtime.CreateActor(typeof(Actor41));51            await runtime.CreateActor(typeof(Actor42));52            await runtime.CreateActor(typeof(Actor43));53            await runtime.CreateActor(typeof(

OperationGroup

Using AI Code Generation

1using Microsoft.Coyote.Runtime;2{3    {4        static void Main(string[] args)5        {6            OperationGroup group = new OperationGroup();7            group.Start();8            group.Stop();9        }10    }11}12using Microsoft.Coyote.Runtime;13{14    {15        static void Main(string[] args)16        {17            OperationGroup group = new OperationGroup();18            group.Start();19            group.AddOperation(1);20            group.AddOperation(2);21            group.AddOperation(3);22            group.AddOperation(4);23            group.AddOperation(5);24            group.Stop();25        }26    }27}

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.