Test your AI Agents with the all-new Agent to Agent Testing Platform.Learn More

How to use ReportUnhandledException method of Microsoft.Coyote.Program class

Best Coyote code snippet using Microsoft.Coyote.Program.ReportUnhandledException

Actor.cs

Source:Actor.cs

...632            }633            else634            {635                // Reports the unhandled exception.636                this.ReportUnhandledException(innerException, actionName);637            }638            return Task.CompletedTask;639        }640        /// <summary>641        /// Checks if the specified event is ignored.642        /// </summary>643        internal virtual bool IsEventIgnored(Event e) =>644            e is TimerElapsedEvent timeoutEvent && !this.Timers.ContainsKey(timeoutEvent.Info);645        /// <summary>646        /// Checks if the specified event is deferred.647        /// </summary>648        internal virtual bool IsEventDeferred(Event e) => false;649        /// <summary>650        /// Checks if there is a default handler installed.651        /// </summary>652        internal virtual bool IsDefaultHandlerInstalled() => false;653        /// <summary>654        /// Returns the hashed state of this actor.655        /// </summary>656        internal virtual int GetHashedState(SchedulingPolicy policy)657        {658            unchecked659            {660                var hash = 19;661                if (policy is SchedulingPolicy.Interleaving)662                {663                    hash = (hash * 31) + this.GetType().GetHashCode();664                    hash = (hash * 31) + this.Id.Value.GetHashCode();665                    hash = (hash * 31) + this.IsHalted.GetHashCode();666                    hash = (hash * 31) + this.IsEventHandlerRunning.GetHashCode();667                    hash = (hash * 31) + this.Context.GetActorProgramCounter(this.Id);668                    hash = (hash * 31) + this.Inbox.GetCachedState();669                }670                if (this.HashedState != 0)671                {672                    // Adds the user-defined hashed state.673                    hash = (hash * 31) + this.HashedState;674                }675                return hash;676            }677        }678        /// <summary>679        /// Registers a new timer using the specified configuration.680        /// </summary>681        private protected TimerInfo RegisterTimer(TimeSpan dueTime, TimeSpan period, TimerElapsedEvent customEvent)682        {683            var info = new TimerInfo(this.Id, dueTime, period, customEvent);684            var timer = this.Context.CreateActorTimer(info, this);685            this.Context.LogWriter.LogCreateTimer(info);686            this.Timers.Add(info, timer);687            return info;688        }689        /// <summary>690        /// Unregisters the specified timer.691        /// </summary>692        private protected void UnregisterTimer(TimerInfo info)693        {694            if (!this.Timers.TryGetValue(info, out IActorTimer timer))695            {696                this.Assert(info.OwnerId == this.Id, "Timer '{0}' is already disposed.", info);697            }698            this.Context.LogWriter.LogStopTimer(info);699            this.Timers.Remove(info);700            using (timer)701            {702                // sometimes timer can be null.703            }704        }705        /// <summary>706        /// Extracts user declarations and sets up the event handlers.707        /// </summary>708        internal virtual void SetupEventHandlers()709        {710            if (!ActionCache.ContainsKey(this.GetType()))711            {712                Stack<Type> actorTypes = new Stack<Type>();713                for (var actorType = this.GetType(); typeof(Actor).IsAssignableFrom(actorType); actorType = actorType.BaseType)714                {715                    actorTypes.Push(actorType);716                }717                // process base types in reverse order, so mosts derrived type is cached first.718                while (actorTypes.Count > 0)719                {720                    this.SetupEventHandlers(actorTypes.Pop());721                }722            }723            // Now we have all derrived types cached, we can build the combined action map for this type.724            for (var actorType = this.GetType(); typeof(Actor).IsAssignableFrom(actorType); actorType = actorType.BaseType)725            {726                // Populates the map of event handlers for this actor instance.727                foreach (var kvp in ActionCache[actorType])728                {729                    // use the most derrived action handler for a given event (ignoring any base handlers defined for the same event).730                    if (!this.ActionMap.ContainsKey(kvp.Key))731                    {732                        // MethodInfo.Invoke catches the exception to wrap it in a TargetInvocationException.733                        // This unwinds the stack before the ExecuteAction exception filter is invoked, so734                        // call through a delegate instead (which is also much faster than Invoke).735                        this.ActionMap.Add(kvp.Key, new CachedDelegate(kvp.Value, this));736                    }737                }738            }739        }740        private void SetupEventHandlers(Type actorType)741        {742            // If this type has not already been setup in the ActionCache, then we need to try and grab the ActionCacheLock743            // for this type.  First make sure we have one and only one lockable object for this type.744            object syncObject = ActionCacheLocks.GetOrAdd(actorType, _ => new object());745            // Locking this syncObject ensures only one thread enters the initialization code to update746            // the ActionCache for this specific Actor type.747            lock (syncObject)748            {749                if (ActionCache.ContainsKey(actorType))750                {751                    // Note: even if we won the GetOrAdd, there is a tiny window of opportunity for another thread752                    // to slip in and lock the syncObject before us, so we have to check the ActionCache again753                    // here just in case.754                }755                else756                {757                    // Events with already declared handlers.758                    var handledEvents = new HashSet<Type>();759                    // Map containing all action bindings.760                    var actionBindings = new Dictionary<Type, ActionEventHandlerDeclaration>();761                    var doAttributes = actorType.GetCustomAttributes(typeof(OnEventDoActionAttribute), false)762                        as OnEventDoActionAttribute[];763                    foreach (var attr in doAttributes)764                    {765                        this.Assert(!handledEvents.Contains(attr.Event),766                            "{0} declared multiple handlers for event '{1}'.",767                            actorType.FullName, attr.Event);768                        actionBindings.Add(attr.Event, new ActionEventHandlerDeclaration(attr.Action));769                        handledEvents.Add(attr.Event);770                    }771                    var map = new Dictionary<Type, MethodInfo>();772                    foreach (var action in actionBindings)773                    {774                        if (!map.ContainsKey(action.Key))775                        {776                            map.Add(action.Key, this.GetActionWithName(action.Value.Name));777                        }778                    }779                    // Caches the action declarations for this actor type.780                    ActionCache.TryAdd(actorType, map);781                }782            }783        }784        /// <summary>785        /// Returns the action with the specified name.786        /// </summary>787        private protected MethodInfo GetActionWithName(string actionName)788        {789            MethodInfo action;790            Type actorType = this.GetType();791            do792            {793                BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic |794                    BindingFlags.Instance | BindingFlags.FlattenHierarchy;795                action = actorType.GetMethod(actionName, bindingFlags, Type.DefaultBinder, SingleEventTypeArray, null);796                if (action is null)797                {798                    action = actorType.GetMethod(actionName, bindingFlags, Type.DefaultBinder, Array.Empty<Type>(), null);799                }800                actorType = actorType.BaseType;801            }802            while (action is null && actorType != typeof(StateMachine) && actorType != typeof(Actor));803            this.Assert(action != null, "Cannot detect action declaration '{0}' in '{1}'.", actionName, this.GetType().FullName);804            this.AssertActionValidity(action);805            return action;806        }807        /// <summary>808        /// Reports the activity coverage of this actor.809        /// </summary>810        internal virtual void ReportActivityCoverage(CoverageInfo coverageInfo)811        {812            var name = this.GetType().FullName;813            if (coverageInfo.IsMachineDeclared(name))814            {815                return;816            }817            var fakeStateName = this.GetType().Name;818            coverageInfo.DeclareMachineState(name, fakeStateName);819            var registeredEvents = new HashSet<string>(from key in this.ActionMap.Keys select key.FullName);820            foreach (var eventId in registeredEvents)821            {822                coverageInfo.DeclareStateEvent(name, fakeStateName, eventId);823            }824        }825        /// <summary>826        /// Checks the validity of the specified action.827        /// </summary>828        private void AssertActionValidity(MethodInfo action)829        {830            Type actionType = action.DeclaringType;831            ParameterInfo[] parameters = action.GetParameters();832            this.Assert(parameters.Length is 0 ||833                (parameters.Length is 1 && parameters[0].ParameterType == typeof(Event)),834                "Action '{0}' in '{1}' must either accept no parameters or a single parameter of type 'Event'.",835                action.Name, actionType.Name);836            // Check if the action is an 'async' method.837            if (action.GetCustomAttribute(typeof(AsyncStateMachineAttribute)) != null)838            {839                this.Assert(action.ReturnType == typeof(Task),840                    "Async action '{0}' in '{1}' must have 'Task' return type.",841                    action.Name, actionType.Name);842            }843            else844            {845                this.Assert(action.ReturnType == typeof(void),846                    "Action '{0}' in '{1}' must have 'void' return type.",847                    action.Name, actionType.Name);848            }849        }850        /// <summary>851        /// Returns the formatted strint to be used with a fair nondeterministic boolean choice.852        /// </summary>853        private protected virtual string FormatFairRandom(string callerMemberName, string callerFilePath, int callerLineNumber) =>854            string.Format(CultureInfo.InvariantCulture, "{0}_{1}_{2}_{3}",855                this.Id.Name, callerMemberName, callerFilePath, callerLineNumber.ToString());856        /// <summary>857        /// Wraps the unhandled exception inside an <see cref="AssertionFailureException"/>858        /// exception, and throws it to the user.859        /// </summary>860        private protected virtual void ReportUnhandledException(Exception ex, string actionName) =>861            this.Context.WrapAndThrowException(ex, $"{0} (action '{1}')", this.Id, actionName);862        /// <summary>863        /// Invoked when an event has been enqueued.864        /// </summary>865        [MethodImpl(MethodImplOptions.AggressiveInlining)]866        internal void OnEnqueueEvent(Event e, EventGroup eventGroup, EventInfo eventInfo) =>867            this.Context.LogEnqueuedEvent(this, e, eventGroup, eventInfo);868        /// <summary>869        /// Invoked when an event has been raised.870        /// </summary>871        [MethodImpl(MethodImplOptions.AggressiveInlining)]872        internal void OnRaiseEvent(Event e, EventGroup eventGroup, EventInfo eventInfo) =>873            this.Context.LogRaisedEvent(this, e, eventGroup, eventInfo);874        /// <summary>...

Program.cs

Source:Program.cs

...256        /// Callback invoked when an unhandled exception occurs.257        /// </summary>258        private static void OnUnhandledException(object sender, UnhandledExceptionEventArgs args)259        {260            ReportUnhandledException((Exception)args.ExceptionObject);261            Environment.Exit(1);262        }263        private static void ReportUnhandledException(Exception ex)264        {265            Console.SetOut(StdOut);266            Console.SetError(StdError);267            PrintException(ex);268            for (var inner = ex.InnerException; inner != null; inner = inner.InnerException)269            {270                PrintException(inner);271            }272        }273        private static void PrintException(Exception ex)274        {275            lock (ConsoleLock)276            {277                string msg = string.Empty;...

ReportUnhandledException

Using AI Code Generation

1using Microsoft.Coyote;2using System;3{4    {5        static void Main(string[] args)6        {7            {8                throw new Exception("Test Exception");9            }10            catch (Exception ex)11            {12                Program.ReportUnhandledException(ex);13            }14        }15    }16}

ReportUnhandledException

Using AI Code Generation

1using Microsoft.Coyote;2using System;3using System.Threading.Tasks;4{5    {6        static async Task Main(string[] args)7        {8            {9                await Task.Run(() => { throw new Exception(); });10            }11            catch (Exception e)12            {13                Program.ReportUnhandledException(e);14            }15        }16    }17}18[0] Unhandled exception: System.Exception: Exception of type 'System.Exception' was thrown. ---> System.Exception: Exception of type 'System.Exception' was thrown. at ConsoleApp1.Program.Main(System.String[])+MoveNext() in 1.cs:line 19 at System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Start[[System.__Canon, System.Private.CoreLib]](System.Runtime.CompilerServices.IAsyncStateMachine) at ConsoleApp1.Program.Main(System.String[]) at System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[[System.__Canon, System.Private.CoreLib]](System.Runtime.CompilerServices.IAsyncStateMachine) at ConsoleApp1.Program.Main(System.String[]) at System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[[System.__Canon, System.Private.CoreLib]](Syste

ReportUnhandledException

Using AI Code Generation

1{2    {3        public static void ReportUnhandledException(Exception ex)4        {5            Console.WriteLine("Exception: " + ex.Message);6        }7    }8}9using Microsoft.Coyote;10{11    {12        public static void ReportUnhandledException(Exception ex)13        {14            Console.WriteLine("Exception: " + ex.Message);15        }16    }17}

ReportUnhandledException

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Actors;5{6    {7        static void Main(string[] args)8        {9            var runtime = RuntimeFactory.Create();10            runtime.RegisterMonitor(typeof(MyMonitor));11            runtime.CreateActor(typeof(MyActor));12            runtime.Wait();13        }14    }15    {16        [OnEventDoAction(typeof(MyEvent), nameof(Handle))]17        class Init : MonitorState { }18        void Handle()19        {20            this.Assert(false, "My assertion failed.");21        }22    }23    {24        [OnEventDoAction(typeof(MyEvent), nameof(Handle))]25        class Init : State { }26        void Handle()27        {28            this.RaiseEvent(new MyEvent());29        }30    }31    public class MyEvent : Event { }32}33using System;34using System.Threading.Tasks;35using Microsoft.Coyote;36using Microsoft.Coyote.Actors;37{38    {39        static void Main(string[] args)40        {41            var runtime = RuntimeFactory.Create();42            runtime.RegisterMonitor(typeof(MyMonitor));43            runtime.CreateActor(typeof(MyActor));44            runtime.Wait();45        }46    }47    {48        [OnEventDoAction(typeof(MyEvent), nameof(Handle))]49        class Init : MonitorState { }50        void Handle()51        {52            this.Assert(false, "My assertion failed.");53        }54    }55    {56        [OnEventDoAction(typeof(MyEvent), nameof(Handle))]57        class Init : State { }58        void Handle()59        {60            this.RaiseEvent(new MyEvent());61        }62    }63    public class MyEvent : Event { }64}65using System;66using System.Threading.Tasks;67using Microsoft.Coyote;68using Microsoft.Coyote.Actors;69{70    {71        static void Main(string[] args)72        {73            var runtime = RuntimeFactory.Create();74            runtime.RegisterMonitor(typeof(MyMonitor));75            runtime.CreateActor(typeof(MyActor

ReportUnhandledException

Using AI Code Generation

1catch (Exception ex)2{3    Microsoft.Coyote.Program.ReportUnhandledException(ex);4    throw;5}6catch (Exception ex)7{8    Microsoft.Coyote.Program.ReportUnhandledException(ex);9    throw;10}11catch (Exception ex)12{13    Microsoft.Coyote.Program.ReportUnhandledException(ex);14    throw;15}16catch (Exception ex)17{18    Microsoft.Coyote.Program.ReportUnhandledException(ex);19    throw;20}21catch (Exception ex)22{23    Microsoft.Coyote.Program.ReportUnhandledException(ex);24    throw;25}26catch (Exception ex)27{28    Microsoft.Coyote.Program.ReportUnhandledException(ex);29    throw;30}31catch (Exception ex)32{33    Microsoft.Coyote.Program.ReportUnhandledException(ex);34    throw;35}36catch (Exception ex)37{38    Microsoft.Coyote.Program.ReportUnhandledException(ex);39    throw;40}41catch (Exception ex)42{43    Microsoft.Coyote.Program.ReportUnhandledException(ex);44    throw;45}46catch (Exception ex)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.