Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use ThrowUncontrolledInvocationException method of Microsoft.Coyote.Runtime.ExceptionProvider class

Best Coyote code snippet using Microsoft.Coyote.Runtime.ExceptionProvider.ThrowUncontrolledInvocationException

Parallel.cs

Source:Parallel.cs

...30        /// Executes each of the provided actions, possibly in parallel.31        /// </summary>32        public static void Invoke(params Action[] actions)33        {34            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.Invoke));35            SystemParallel.Invoke(actions);36        }37        /// <summary>38        /// Executes each of the provided actions, possibly in parallel, unless the operation is cancelled by the user.39        /// </summary>40        public static void Invoke(SystemParallelOptions parallelOptions, params Action[] actions)41        {42            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.Invoke));43            SystemParallel.Invoke(parallelOptions, actions);44        }45        /// <summary>46        /// Executes a for loop in which iterations may run in parallel.47        /// </summary>48        public static SystemParallelLoopResult For(int fromInclusive, int toExclusive, Action<int> body)49        {50            if (CoyoteRuntime.IsExecutionControlled)51            {52                return For(fromInclusive, toExclusive, new SystemParallelOptions(), body);53            }54            return SystemParallel.For(fromInclusive, toExclusive, body);55        }56        /// <summary>57        /// Executes a for loop in which iterations may run in parallel and loop options58        /// can be configured.59        /// </summary>60        public static SystemParallelLoopResult For(int fromInclusive, int toExclusive,61            SystemParallelOptions parallelOptions, Action<int> body)62        {63            if (CoyoteRuntime.IsExecutionControlled)64            {65                return SystemParallel.For(fromInclusive, toExclusive, new SystemParallelOptions()66                {67                    CancellationToken = parallelOptions.CancellationToken,68                    MaxDegreeOfParallelism = MaxDegreeOfParallelism,69                    TaskScheduler = CoyoteRuntime.Current.ControlledTaskScheduler70                }, body);71            }72            return SystemParallel.For(fromInclusive, toExclusive, parallelOptions, body);73        }74        /// <summary>75        /// Executes a for loop in which iterations may run in parallel and the state of76        /// the loop can be monitored and manipulated.77        /// </summary>78        public static SystemParallelLoopResult For(int fromInclusive, int toExclusive,79            Action<int, SystemParallelLoopState> body)80        {81            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For));82            return SystemParallel.For(fromInclusive, toExclusive, body);83        }84        /// <summary>85        /// Executes a for loop in which iterations may run in parallel, loop options can86        /// be configured, and the state of the loop can be monitored and manipulated.87        /// </summary>88        public static SystemParallelLoopResult For(int fromInclusive, int toExclusive,89            SystemParallelOptions parallelOptions, Action<int, SystemParallelLoopState> body)90        {91            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For));92            return SystemParallel.For(fromInclusive, toExclusive, parallelOptions, body);93        }94        /// <summary>95        /// Executes a for loop with 64-bit indexes in which iterations may run in parallel.96        /// </summary>97        public static SystemParallelLoopResult For(long fromInclusive, long toExclusive, Action<long> body)98        {99            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For));100            return SystemParallel.For(fromInclusive, toExclusive, body);101        }102        /// <summary>103        /// Executes a for loop with 64-bit indexes in which iterations may run in parallel104        /// and loop options can be configured.105        /// </summary>106        public static SystemParallelLoopResult For(long fromInclusive, long toExclusive,107            SystemParallelOptions parallelOptions, Action<long> body)108        {109            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For));110            return SystemParallel.For(fromInclusive, toExclusive, parallelOptions, body);111        }112        /// <summary>113        /// Executes a for loop with 64-bit indexes in which iterations may run in parallel114        /// and the state of the loop can be monitored and manipulated.115        /// </summary>116        public static SystemParallelLoopResult For(long fromInclusive, long toExclusive,117            Action<long, SystemParallelLoopState> body)118        {119            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For));120            return SystemParallel.For(fromInclusive, toExclusive, body);121        }122        /// <summary>123        /// Executes a for loop with 64-bit indexes in which iterations may run in parallel, loop124        /// options can be configured, and the state of the loop can be monitored and manipulated.125        /// </summary>126        public static SystemParallelLoopResult For(long fromInclusive, long toExclusive,127            SystemParallelOptions parallelOptions, Action<long, SystemParallelLoopState> body)128        {129            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For));130            return SystemParallel.For(fromInclusive, toExclusive, parallelOptions, body);131        }132        /// <summary>133        /// Executes a for loop with thread-local data in which iterations may run in parallel,134        /// and the state of the loop can be monitored and manipulated.135        /// </summary>136        public static SystemParallelLoopResult For<TLocal>(int fromInclusive, int toExclusive, Func<TLocal> localInit,137            Func<int, SystemParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)138        {139            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For));140            return SystemParallel.For(fromInclusive, toExclusive, localInit, body, localFinally);141        }142        /// <summary>143        /// Executes a for loop with thread-local data in which iterations may run in parallel, loop144        /// options can be configured, and the state of the loop can be monitored and manipulated.145        /// </summary>146        public static SystemParallelLoopResult For<TLocal>(int fromInclusive, int toExclusive,147            SystemParallelOptions parallelOptions, Func<TLocal> localInit,148            Func<int, SystemParallelLoopState, TLocal, TLocal> body,149            Action<TLocal> localFinally)150        {151            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For));152            return SystemParallel.For(fromInclusive, toExclusive, parallelOptions, localInit, body, localFinally);153        }154        /// <summary>155        /// Executes a for loop with 64-bit indexes and thread-local data in which iterations156        /// may run in parallel, and the state of the loop can be monitored and manipulated.157        /// </summary>158        public static SystemParallelLoopResult For<TLocal>(long fromInclusive, long toExclusive,159            Func<TLocal> localInit, Func<long, SystemParallelLoopState, TLocal, TLocal> body,160            Action<TLocal> localFinally)161        {162            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For));163            return SystemParallel.For(fromInclusive, toExclusive, localInit, body, localFinally);164        }165        /// <summary>166        /// Executes a for loop with 64-bit indexes and thread-local data in which iterations167        /// may run in parallel, loop options can be configured, and the state of the loop168        /// can be monitored and manipulated.169        /// </summary>170        public static SystemParallelLoopResult For<TLocal>(long fromInclusive, long toExclusive,171            SystemParallelOptions parallelOptions, Func<TLocal> localInit,172            Func<long, SystemParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)173        {174            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For));175            return SystemParallel.For(fromInclusive, toExclusive, parallelOptions, localInit, body, localFinally);176        }177        /// <summary>178        /// Executes a foreach operation on a <see cref="System.Collections.IEnumerable"/>179        /// in which iterations may run in parallel.180        /// </summary>181        public static SystemParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, Action<TSource> body)182        {183            if (CoyoteRuntime.IsExecutionControlled)184            {185                return ForEach(source, new SystemParallelOptions(), body);186            }187            return SystemParallel.ForEach(source, body);188        }189        /// <summary>190        /// Executes a foreach operation on a <see cref="System.Collections.IEnumerable"/>191        /// in which iterations may run in parallel and loop options can be configured.192        /// </summary>193        public static SystemParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source,194            SystemParallelOptions parallelOptions, Action<TSource> body)195        {196            if (CoyoteRuntime.IsExecutionControlled)197            {198                return SystemParallel.ForEach(source, new SystemParallelOptions()199                {200                    CancellationToken = parallelOptions.CancellationToken,201                    MaxDegreeOfParallelism = MaxDegreeOfParallelism,202                    TaskScheduler = CoyoteRuntime.Current.ControlledTaskScheduler203                }, body);204            }205            return SystemParallel.ForEach(source, parallelOptions, body);206        }207        /// <summary>208        /// Executes a foreach operation on a <see cref="Partitioner"/> in which iterations may run in parallel.209        /// </summary>210        public static SystemParallelLoopResult ForEach<TSource>(Partitioner<TSource> source, Action<TSource> body)211        {212            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));213            return SystemParallel.ForEach(source, body);214        }215        /// <summary>216        /// Executes a foreach operation on a <see cref="Partitioner"/> in which iterations may run217        /// in parallel and loop options can be configured.218        /// </summary>219        public static SystemParallelLoopResult ForEach<TSource>(Partitioner<TSource> source,220            SystemParallelOptions parallelOptions, Action<TSource> body)221        {222            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));223            return SystemParallel.ForEach(source, parallelOptions, body);224        }225        /// <summary>226        /// Executes a foreach operation on a <see cref="System.Collections.IEnumerable"/> in which iterations227        /// may run in parallel, and the state of the loop can be monitored and manipulated.228        /// </summary>229        public static SystemParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source,230            Action<TSource, SystemParallelLoopState> body)231        {232            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));233            return SystemParallel.ForEach(source, body);234        }235        /// <summary>236        /// Executes a foreach operation on a <see cref="System.Collections.IEnumerable"/> in which iterations237        /// may run in parallel, loop options can be configured, and the state of the loop can be monitored and238        /// manipulated.239        /// </summary>240        public static SystemParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source,241            SystemParallelOptions parallelOptions, Action<TSource, SystemParallelLoopState> body)242        {243            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));244            return SystemParallel.ForEach(source, parallelOptions, body);245        }246        /// <summary>247        /// Executes a foreach operation on a <see cref="Partitioner"/> in which iterations may run in parallel,248        /// and the state of the loop can be monitored and manipulated.249        /// </summary>250        public static SystemParallelLoopResult ForEach<TSource>(Partitioner<TSource> source,251            Action<TSource, SystemParallelLoopState> body)252        {253            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));254            return SystemParallel.ForEach(source, body);255        }256        /// <summary>257        /// Executes a foreach operation on a <see cref="Partitioner"/> in which iterations may run in parallel,258        /// loop options can be configured, and the state of the loop can be monitored and manipulated.259        /// </summary>260        public static SystemParallelLoopResult ForEach<TSource>(Partitioner<TSource> source,261            SystemParallelOptions parallelOptions, Action<TSource, SystemParallelLoopState> body)262        {263            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));264            return SystemParallel.ForEach(source, parallelOptions, body);265        }266        /// <summary>267        /// Executes a foreach operation with 64-bit indexes on a <see cref="System.Collections.IEnumerable"/>268        /// in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.269        /// </summary>270        public static SystemParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source,271            Action<TSource, SystemParallelLoopState, long> body)272        {273            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));274            return SystemParallel.ForEach(source, body);275        }276        /// <summary>277        /// Executes a foreach operation with 64-bit indexes on a <see cref="System.Collections.IEnumerable"/>278        /// in which iterations may run in parallel, loop options can be configured, and the state of the loop279        /// can be monitored and manipulated.280        /// </summary>281        public static SystemParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source,282            SystemParallelOptions parallelOptions, Action<TSource, SystemParallelLoopState, long> body)283        {284            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));285            return SystemParallel.ForEach(source, parallelOptions, body);286        }287        /// <summary>288        /// Executes a foreach operation on a <see cref="OrderablePartitioner{TSource}"/> in which iterations289        /// may run in parallel and the state of the loop can be monitored and manipulated.290        /// </summary>291        public static SystemParallelLoopResult ForEach<TSource>(OrderablePartitioner<TSource> source,292            Action<TSource, SystemParallelLoopState, long> body)293        {294            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));295            return SystemParallel.ForEach(source, body);296        }297        /// <summary>298        /// Executes a foreach operation on a <see cref="OrderablePartitioner{TSource}"/>299        /// in which iterations may run in parallel, loop options can be configured, and300        /// the state of the loop can be monitored and manipulated.301        /// </summary>302        public static SystemParallelLoopResult ForEach<TSource>(OrderablePartitioner<TSource> source,303            SystemParallelOptions parallelOptions, Action<TSource, SystemParallelLoopState, long> body)304        {305            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));306            return SystemParallel.ForEach(source, parallelOptions, body);307        }308        /// <summary>309        /// Executes a foreach operation with thread-local data on a <see cref="System.Collections.IEnumerable"/>310        /// in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.311        /// </summary>312        public static SystemParallelLoopResult ForEach<TSource, TLocal>(IEnumerable<TSource> source, Func<TLocal> localInit,313            Func<TSource, SystemParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)314        {315            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));316            return SystemParallel.ForEach(source, localInit, body, localFinally);317        }318        /// <summary>319        /// Executes a foreach operation with thread-local data on a <see cref="System.Collections.IEnumerable"/>320        /// in which iterations may run in parallel, loop options can be configured, and the state of the loop321        /// can be monitored and manipulated.322        /// </summary>323        public static SystemParallelLoopResult ForEach<TSource, TLocal>(IEnumerable<TSource> source,324            SystemParallelOptions parallelOptions, Func<TLocal> localInit,325            Func<TSource, SystemParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally)326        {327            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));328            return SystemParallel.ForEach(source, parallelOptions, localInit, body, localFinally);329        }330        /// <summary>331        /// Executes a foreach operation with thread-local data on a <see cref="Partitioner"/> in which332        /// iterations may run in parallel and the state of the loop can be monitored and manipulated.333        /// </summary>334        public static SystemParallelLoopResult ForEach<TSource, TLocal>(Partitioner<TSource> source,335            Func<TLocal> localInit, Func<TSource, SystemParallelLoopState, TLocal, TLocal> body,336            Action<TLocal> localFinally)337        {338            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));339            return SystemParallel.ForEach(source, localInit, body, localFinally);340        }341        /// <summary>342        /// Executes a foreach operation with thread-local data on a <see cref="Partitioner"/> in which343        /// iterations may run in parallel, loop options can be configured, and the state of the loop344        /// can be monitored and manipulated.345        /// </summary>346        public static SystemParallelLoopResult ForEach<TSource, TLocal>(Partitioner<TSource> source,347            SystemParallelOptions parallelOptions, Func<TLocal> localInit,348            Func<TSource, SystemParallelLoopState, TLocal, TLocal> body,349            Action<TLocal> localFinally)350        {351            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));352            return SystemParallel.ForEach(source, parallelOptions, localInit, body, localFinally);353        }354        /// <summary>355        /// Executes a foreach operation with thread-local data on a <see cref="System.Collections.IEnumerable"/>356        /// in which iterations may run in parallel and the state of the loop can be monitored and manipulated.357        /// </summary>358        public static SystemParallelLoopResult ForEach<TSource, TLocal>(IEnumerable<TSource> source,359            Func<TLocal> localInit, Func<TSource, SystemParallelLoopState, long, TLocal, TLocal> body,360            Action<TLocal> localFinally)361        {362            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));363            return SystemParallel.ForEach(source, localInit, body, localFinally);364        }365        /// <summary>366        /// Executes a foreach operation with thread-local data and 64-bit indexes on a367        /// <see cref="System.Collections.IEnumerable"/> in which iterations may run in368        /// parallel, loop options can be configured, and the state of the loop can be369        /// monitored and manipulated.370        /// </summary>371        public static SystemParallelLoopResult ForEach<TSource, TLocal>(IEnumerable<TSource> source,372            SystemParallelOptions parallelOptions, Func<TLocal> localInit,373            Func<TSource, SystemParallelLoopState, long, TLocal, TLocal> body,374            Action<TLocal> localFinally)375        {376            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));377            return SystemParallel.ForEach(source, parallelOptions, localInit, body, localFinally);378        }379        /// <summary>380        /// Executes a foreach operation with thread-local data on a <see cref="OrderablePartitioner{TSource}"/>381        /// in which iterations may run in parallel, loop options can be configured, and the state of the loop382        /// can be monitored and manipulated.383        /// </summary>384        public static SystemParallelLoopResult ForEach<TSource, TLocal>(OrderablePartitioner<TSource> source,385            Func<TLocal> localInit, Func<TSource, SystemParallelLoopState, long, TLocal, TLocal> body,386            Action<TLocal> localFinally)387        {388            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));389            return SystemParallel.ForEach(source, localInit, body, localFinally);390        }391        /// <summary>392        /// Executes a foreach operation with 64-bit indexes and with thread-local data on393        /// a <see cref="OrderablePartitioner{TSource}"/> in which iterations may run in394        /// parallel , loop options can be configured, and the state of the loop can be395        /// monitored and manipulated.396        /// </summary>397        public static SystemParallelLoopResult ForEach<TSource, TLocal>(OrderablePartitioner<TSource> source,398            SystemParallelOptions parallelOptions, Func<TLocal> localInit,399            Func<TSource, SystemParallelLoopState, long, TLocal, TLocal> body,400            Action<TLocal> localFinally)401        {402            ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach));403            return SystemParallel.ForEach(source, parallelOptions, localInit, body, localFinally);404        }405    }406}...

UncontrolledInvocationRewritingPass.cs

Source:UncontrolledInvocationRewritingPass.cs

...52                {53                    Debug.WriteLine($"............. [+] injected uncontrolled '{invocationName}' invocation exception");54                    var providerType = this.Method.Module.ImportReference(typeof(ExceptionProvider)).Resolve();55                    MethodReference providerMethod = providerType.Methods.FirstOrDefault(56                        m => m.Name is nameof(ExceptionProvider.ThrowUncontrolledInvocationException));57                    providerMethod = this.Method.Module.ImportReference(providerMethod);58                    this.Processor.InsertBefore(instruction, Instruction.Create(OpCodes.Ldstr, invocationName));59                    this.Processor.InsertBefore(instruction, Instruction.Create(OpCodes.Call, providerMethod));60                    this.IsMethodBodyModified = true;61                }62            }63            catch (AssemblyResolutionException)64            {65                // Skip this instruction, we are only interested in types that can be resolved.66            }67            return instruction;68        }69        /// <summary>70        /// Checks if the specified type is not controlled. If the optional method is specified,...

ExceptionProvider.cs

Source:ExceptionProvider.cs

...31        /// <summary>32        /// Throws an exception for the specified uncontrolled method invocation.33        /// </summary>34        /// <param name="methodName">The name of the invoked method that is not controlled.</param>35        public static void ThrowUncontrolledInvocationException(string methodName) =>36            CoyoteRuntime.Current?.NotifyUncontrolledInvocation(methodName);37        /// <summary>38        /// Throws an exception if the task returned by the method with the specified name39        /// is not controlled during systematic testing.40        /// </summary>41        /// <param name="task">The task to check if it is controlled or not.</param>42        /// <param name="methodName">The name of the method returning the task.</param>43        public static Task ThrowIfReturnedTaskNotControlled(Task task, string methodName)44        {45            CoyoteRuntime.Current?.CheckIfReturnedTaskIsUncontrolled(task, methodName);46            return task;47        }48        /// <summary>49        /// Throws an exception if the task returned by the method with the specified name...