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

How to use SetLogger method of Microsoft.Coyote.Actors.ActorExecutionContext class

Best Coyote code snippet using Microsoft.Coyote.Actors.ActorExecutionContext.SetLogger

CoyoteRuntime.cs

Source:CoyoteRuntime.cs

...107        /// Responsible for writing to all registered <see cref="IActorRuntimeLog"/> objects.108        /// </summary>109        internal LogWriter LogWriter { get; private set; }110        /// <summary>111        /// Used to log text messages. Use <see cref="ICoyoteRuntime.SetLogger"/>112        /// to replace the logger with a custom one.113        /// </summary>114        internal ILogger Logger115        {116            get { return this.LogWriter.Logger; }117            set { using var v = this.LogWriter.SetLogger(value); }118        }119        /// <summary>120        /// Callback that is fired when an exception is thrown that includes failed assertions.121        /// </summary>122        internal event OnFailureHandler OnFailure;123        /// <summary>124        /// Initializes a new instance of the <see cref="CoyoteRuntime"/> class.125        /// </summary>126        internal CoyoteRuntime(Configuration configuration, IRandomValueGenerator valueGenerator)127            : this(configuration, null, valueGenerator)128        {129        }130        /// <summary>131        /// Initializes a new instance of the <see cref="CoyoteRuntime"/> class....

ActorExecutionContext.cs

Source:ActorExecutionContext.cs

...69        {70            get => this.LogWriter.Logger;71            set72            {73                using var v = this.LogWriter.SetLogger(value);74            }75        }76        /// <summary>77        /// True if the actor program is running, else false.78        /// </summary>79        internal bool IsRunning => this.Scheduler.IsProgramExecuting;80        /// <summary>81        /// If true, the actor execution is controlled, else false.82        /// </summary>83        internal virtual bool IsExecutionControlled => false;84        /// <inheritdoc/>85        public event OnEventDroppedHandler OnEventDropped;86        /// <inheritdoc/>87        public event OnFailureHandler OnFailure88        {89            add90            {91                lock (OnFailureSyncObject)92                {93                    this.Runtime.OnFailure += value;94                }95            }96            remove97            {98                lock (OnFailureSyncObject)99                {100                    this.Runtime.OnFailure -= value;101                }102            }103        }104        /// <summary>105        /// Initializes a new instance of the <see cref="ActorExecutionContext"/> class.106        /// </summary>107        internal ActorExecutionContext(Configuration configuration, CoyoteRuntime runtime, OperationScheduler scheduler,108            SpecificationEngine specificationEngine, IRandomValueGenerator valueGenerator, LogWriter logWriter)109        {110            this.Configuration = configuration;111            this.Runtime = runtime;112            this.Scheduler = scheduler;113            this.SpecificationEngine = specificationEngine;114            this.ActorMap = new ConcurrentDictionary<ActorId, Actor>();115            this.CoverageInfo = new CoverageInfo();116            this.ValueGenerator = valueGenerator;117            this.LogWriter = logWriter;118        }119        /// <inheritdoc/>120        public ActorId CreateActorId(Type type, string name = null) => new ActorId(type, this.GetNextOperationId(), name, this);121        /// <inheritdoc/>122        public virtual ActorId CreateActorIdFromName(Type type, string name) => new ActorId(type, 0, name, this, true);123        /// <inheritdoc/>124        public virtual ActorId CreateActor(Type type, Event initialEvent = null, EventGroup eventGroup = null) =>125            this.CreateActor(null, type, null, initialEvent, null, eventGroup);126        /// <inheritdoc/>127        public virtual ActorId CreateActor(Type type, string name, Event initialEvent = null, EventGroup eventGroup = null) =>128            this.CreateActor(null, type, name, initialEvent, null, eventGroup);129        /// <inheritdoc/>130        public virtual ActorId CreateActor(ActorId id, Type type, Event initialEvent = null, EventGroup eventGroup = null) =>131            this.CreateActor(id, type, null, initialEvent, null, eventGroup);132        /// <inheritdoc/>133        public virtual Task<ActorId> CreateActorAndExecuteAsync(Type type, Event initialEvent = null, EventGroup eventGroup = null) =>134            this.CreateActorAndExecuteAsync(null, type, null, initialEvent, null, eventGroup);135        /// <inheritdoc/>136        public virtual Task<ActorId> CreateActorAndExecuteAsync(Type type, string name, Event initialEvent = null, EventGroup eventGroup = null) =>137            this.CreateActorAndExecuteAsync(null, type, name, initialEvent, null, eventGroup);138        /// <inheritdoc/>139        public virtual Task<ActorId> CreateActorAndExecuteAsync(ActorId id, Type type, Event initialEvent = null, EventGroup eventGroup = null) =>140            this.CreateActorAndExecuteAsync(id, type, null, initialEvent, null, eventGroup);141        /// <summary>142        /// Creates a new <see cref="Actor"/> of the specified <see cref="Type"/>.143        /// </summary>144        internal virtual ActorId CreateActor(ActorId id, Type type, string name, Event initialEvent, Actor creator, EventGroup eventGroup)145        {146            Actor actor = this.CreateActor(id, type, name, creator, eventGroup);147            if (actor is StateMachine)148            {149                this.LogWriter.LogCreateStateMachine(actor.Id, creator?.Id.Name, creator?.Id.Type);150            }151            else152            {153                this.LogWriter.LogCreateActor(actor.Id, creator?.Id.Name, creator?.Id.Type);154            }155            this.RunActorEventHandler(actor, initialEvent, true);156            return actor.Id;157        }158        /// <summary>159        /// Creates a new <see cref="Actor"/> of the specified <see cref="Type"/>. The method160        /// returns only when the actor is initialized and the <see cref="Event"/> (if any)161        /// is handled.162        /// </summary>163        internal virtual async Task<ActorId> CreateActorAndExecuteAsync(ActorId id, Type type, string name, Event initialEvent,164            Actor creator, EventGroup eventGroup)165        {166            Actor actor = this.CreateActor(id, type, name, creator, eventGroup);167            if (actor is StateMachine)168            {169                this.LogWriter.LogCreateStateMachine(actor.Id, creator?.Id.Name, creator?.Id.Type);170            }171            else172            {173                this.LogWriter.LogCreateActor(actor.Id, creator?.Id.Name, creator?.Id.Type);174            }175            await this.RunActorEventHandlerAsync(actor, initialEvent, true);176            return actor.Id;177        }178        /// <summary>179        /// Creates a new <see cref="Actor"/> of the specified <see cref="Type"/>.180        /// </summary>181        internal virtual Actor CreateActor(ActorId id, Type type, string name, Actor creator, EventGroup eventGroup)182        {183            if (!type.IsSubclassOf(typeof(Actor)))184            {185                this.Assert(false, "Type '{0}' is not an actor.", type.FullName);186            }187            if (id is null)188            {189                id = this.CreateActorId(type, name);190            }191            else if (id.Runtime != null && id.Runtime != this)192            {193                this.Assert(false, "Unbound actor id '{0}' was created by another runtime.", id.Value);194            }195            else if (id.Type != type.FullName)196            {197                this.Assert(false, "Cannot bind actor id '{0}' of type '{1}' to an actor of type '{2}'.",198                    id.Value, id.Type, type.FullName);199            }200            else201            {202                id.Bind(this);203            }204            // If no event group is provided then inherit the current group from the creator.205            if (eventGroup is null && creator != null)206            {207                eventGroup = creator.EventGroup;208            }209            Actor actor = ActorFactory.Create(type);210            IEventQueue eventQueue = new EventQueue(actor);211            actor.Configure(this, id, null, eventQueue, eventGroup);212            actor.SetupEventHandlers();213            if (!this.ActorMap.TryAdd(id, actor))214            {215                this.Assert(false, $"An actor with id '{id.Value}' was already created by another runtime instance.");216            }217            return actor;218        }219        /// <inheritdoc/>220        public virtual void SendEvent(ActorId targetId, Event initialEvent, EventGroup eventGroup = default, SendOptions options = null) =>221            this.SendEvent(targetId, initialEvent, null, eventGroup, options);222        /// <inheritdoc/>223        public virtual Task<bool> SendEventAndExecuteAsync(ActorId targetId, Event initialEvent,224            EventGroup eventGroup = null, SendOptions options = null) =>225            this.SendEventAndExecuteAsync(targetId, initialEvent, null, eventGroup, options);226        /// <summary>227        /// Sends an asynchronous <see cref="Event"/> to an actor.228        /// </summary>229        internal virtual void SendEvent(ActorId targetId, Event e, Actor sender, EventGroup eventGroup, SendOptions options)230        {231            EnqueueStatus enqueueStatus = this.EnqueueEvent(targetId, e, sender, eventGroup, out Actor target);232            if (enqueueStatus is EnqueueStatus.EventHandlerNotRunning)233            {234                this.RunActorEventHandler(target, null, false);235            }236        }237        /// <summary>238        /// Sends an asynchronous <see cref="Event"/> to an actor. Returns immediately if the target was239        /// already running. Otherwise blocks until the target handles the event and reaches quiescense.240        /// </summary>241        internal virtual async Task<bool> SendEventAndExecuteAsync(ActorId targetId, Event e, Actor sender,242            EventGroup eventGroup, SendOptions options)243        {244            EnqueueStatus enqueueStatus = this.EnqueueEvent(targetId, e, sender, eventGroup, out Actor target);245            if (enqueueStatus is EnqueueStatus.EventHandlerNotRunning)246            {247                await this.RunActorEventHandlerAsync(target, null, false);248                return true;249            }250            return enqueueStatus is EnqueueStatus.Dropped;251        }252        /// <summary>253        /// Enqueues an event to the actor with the specified id.254        /// </summary>255        private EnqueueStatus EnqueueEvent(ActorId targetId, Event e, Actor sender, EventGroup eventGroup, out Actor target)256        {257            if (e is null)258            {259                string message = sender != null ?260                    string.Format("{0} is sending a null event.", sender.Id.ToString()) :261                    "Cannot send a null event.";262                this.Assert(false, message);263            }264            if (targetId is null)265            {266                string message = (sender != null) ?267                    string.Format("{0} is sending event {1} to a null actor.", sender.Id.ToString(), e.ToString())268                    : string.Format("Cannot send event {0} to a null actor.", e.ToString());269                this.Assert(false, message);270            }271            target = this.GetActorWithId<Actor>(targetId);272            // If no group is provided we default to passing along the group from the sender.273            if (eventGroup is null && sender != null)274            {275                eventGroup = sender.EventGroup;276            }277            Guid opId = eventGroup is null ? Guid.Empty : eventGroup.Id;278            if (target is null || target.IsHalted)279            {280                this.LogWriter.LogSendEvent(targetId, sender?.Id.Name, sender?.Id.Type,281                    (sender as StateMachine)?.CurrentStateName ?? default, e, opId, isTargetHalted: true);282                this.HandleDroppedEvent(e, targetId);283                return EnqueueStatus.Dropped;284            }285            this.LogWriter.LogSendEvent(targetId, sender?.Id.Name, sender?.Id.Type,286                (sender as StateMachine)?.CurrentStateName ?? default, e, opId, isTargetHalted: false);287            EnqueueStatus enqueueStatus = target.Enqueue(e, eventGroup, null);288            if (enqueueStatus == EnqueueStatus.Dropped)289            {290                this.HandleDroppedEvent(e, targetId);291            }292            return enqueueStatus;293        }294        /// <summary>295        /// Runs a new asynchronous actor event handler.296        /// This is a fire and forget invocation.297        /// </summary>298        private void RunActorEventHandler(Actor actor, Event initialEvent, bool isFresh)299        {300            Task.Run(async () =>301            {302                try303                {304                    if (isFresh)305                    {306                        await actor.InitializeAsync(initialEvent);307                    }308                    await actor.RunEventHandlerAsync();309                }310                catch (Exception ex)311                {312                    this.Scheduler.IsProgramExecuting = false;313                    this.RaiseOnFailureEvent(ex);314                }315                finally316                {317                    if (actor.IsHalted)318                    {319                        this.ActorMap.TryRemove(actor.Id, out Actor _);320                    }321                }322            });323        }324        /// <summary>325        /// Runs a new asynchronous actor event handler.326        /// </summary>327        private async Task RunActorEventHandlerAsync(Actor actor, Event initialEvent, bool isFresh)328        {329            try330            {331                if (isFresh)332                {333                    await actor.InitializeAsync(initialEvent);334                }335                await actor.RunEventHandlerAsync();336            }337            catch (Exception ex)338            {339                this.Scheduler.IsProgramExecuting = false;340                this.RaiseOnFailureEvent(ex);341                return;342            }343        }344        /// <summary>345        /// Creates a new timer that sends a <see cref="TimerElapsedEvent"/> to its owner actor.346        /// </summary>347        internal virtual IActorTimer CreateActorTimer(TimerInfo info, Actor owner) => new ActorTimer(info, owner);348        /// <inheritdoc/>349        public virtual EventGroup GetCurrentEventGroup(ActorId currentActorId)350        {351            Actor actor = this.GetActorWithId<Actor>(currentActorId);352            return actor?.CurrentEventGroup;353        }354        /// <summary>355        /// Gets the actor of type <typeparamref name="TActor"/> with the specified id,356        /// or null if no such actor exists.357        /// </summary>358        internal TActor GetActorWithId<TActor>(ActorId id)359            where TActor : Actor =>360            id != null && this.ActorMap.TryGetValue(id, out Actor value) &&361            value is TActor actor ? actor : null;362        /// <summary>363        /// Returns the next available unique operation id.364        /// </summary>365        /// <returns>Value representing the next available unique operation id.</returns>366        internal ulong GetNextOperationId() => this.Runtime.GetNextOperationId();367        /// <inheritdoc/>368        public bool RandomBoolean() => this.GetNondeterministicBooleanChoice(2, null, null);369        /// <inheritdoc/>370        public bool RandomBoolean(int maxValue) => this.GetNondeterministicBooleanChoice(maxValue, null, null);371        /// <summary>372        /// Returns a controlled nondeterministic boolean choice.373        /// </summary>374        internal virtual bool GetNondeterministicBooleanChoice(int maxValue, string callerName, string callerType)375        {376            bool result = false;377            if (this.ValueGenerator.Next(maxValue) is 0)378            {379                result = true;380            }381            this.LogWriter.LogRandom(result, callerName, callerType);382            return result;383        }384        /// <inheritdoc/>385        public int RandomInteger(int maxValue) => this.GetNondeterministicIntegerChoice(maxValue, null, null);386        /// <summary>387        /// Returns a controlled nondeterministic integer choice.388        /// </summary>389        internal virtual int GetNondeterministicIntegerChoice(int maxValue, string callerName, string callerType)390        {391            var result = this.ValueGenerator.Next(maxValue);392            this.LogWriter.LogRandom(result, callerName, callerType);393            return result;394        }395        /// <summary>396        /// Logs that the specified actor invoked an action.397        /// </summary>398        internal virtual void LogInvokedAction(Actor actor, MethodInfo action, string handlingStateName, string currentStateName)399        {400            if (this.Configuration.IsVerbose)401            {402                this.LogWriter.LogExecuteAction(actor.Id, handlingStateName, currentStateName, action.Name);403            }404        }405        /// <summary>406        /// Logs that the specified actor enqueued an <see cref="Event"/>.407        /// </summary>408        internal virtual void LogEnqueuedEvent(Actor actor, Event e, EventGroup eventGroup, EventInfo eventInfo)409        {410            if (this.Configuration.IsVerbose)411            {412                this.LogWriter.LogEnqueueEvent(actor.Id, e);413            }414        }415        /// <summary>416        /// Logs that the specified actor dequeued an <see cref="Event"/>.417        /// </summary>418        internal virtual void LogDequeuedEvent(Actor actor, Event e, EventInfo eventInfo, bool isFreshDequeue)419        {420            if (this.Configuration.IsVerbose)421            {422                string stateName = actor is StateMachine stateMachine ? stateMachine.CurrentStateName : default;423                this.LogWriter.LogDequeueEvent(actor.Id, stateName, e);424            }425        }426        /// <summary>427        /// Logs that the specified actor dequeued the default <see cref="Event"/>.428        /// </summary>429        [MethodImpl(MethodImplOptions.AggressiveInlining)]430        internal virtual void LogDefaultEventDequeued(Actor actor)431        {432        }433        /// <summary>434        /// Notifies that the inbox of the specified actor is about to be435        /// checked to see if the default event handler should fire.436        /// </summary>437        [MethodImpl(MethodImplOptions.AggressiveInlining)]438        internal virtual void LogDefaultEventHandlerCheck(Actor actor)439        {440        }441        /// <summary>442        /// Logs that the specified actor raised an <see cref="Event"/>.443        /// </summary>444        internal virtual void LogRaisedEvent(Actor actor, Event e, EventGroup eventGroup, EventInfo eventInfo)445        {446            if (this.Configuration.IsVerbose)447            {448                string stateName = actor is StateMachine stateMachine ? stateMachine.CurrentStateName : default;449                this.LogWriter.LogRaiseEvent(actor.Id, stateName, e);450            }451        }452        /// <summary>453        /// Logs that the specified actor is handling a raised <see cref="Event"/>.454        /// </summary>455        [MethodImpl(MethodImplOptions.AggressiveInlining)]456        internal virtual void LogHandleRaisedEvent(Actor actor, Event e)457        {458        }459        /// <summary>460        /// Logs that the specified actor called <see cref="Actor.ReceiveEventAsync(Type[])"/>461        /// or one of its overloaded methods.462        /// </summary>463        [MethodImpl(MethodImplOptions.AggressiveInlining)]464        internal virtual void LogReceiveCalled(Actor actor)465        {466        }467        /// <summary>468        /// Logs that the specified actor enqueued an event that it was waiting to receive.469        /// </summary>470        internal virtual void LogReceivedEvent(Actor actor, Event e, EventInfo eventInfo)471        {472            if (this.Configuration.IsVerbose)473            {474                string stateName = actor is StateMachine stateMachine ? stateMachine.CurrentStateName : default;475                this.LogWriter.LogReceiveEvent(actor.Id, stateName, e, wasBlocked: true);476            }477        }478        /// <summary>479        /// Logs that the specified actor received an event without waiting because the event480        /// was already in the inbox when the actor invoked the receive statement.481        /// </summary>482        internal virtual void LogReceivedEventWithoutWaiting(Actor actor, Event e, EventInfo eventInfo)483        {484            if (this.Configuration.IsVerbose)485            {486                string stateName = actor is StateMachine stateMachine ? stateMachine.CurrentStateName : default;487                this.LogWriter.LogReceiveEvent(actor.Id, stateName, e, wasBlocked: false);488            }489        }490        /// <summary>491        /// Logs that the specified actor is waiting to receive an event of one of the specified types.492        /// </summary>493        internal virtual void LogWaitEvent(Actor actor, IEnumerable<Type> eventTypes)494        {495            if (this.Configuration.IsVerbose)496            {497                string stateName = actor is StateMachine stateMachine ? stateMachine.CurrentStateName : default;498                var eventWaitTypesArray = eventTypes.ToArray();499                if (eventWaitTypesArray.Length is 1)500                {501                    this.LogWriter.LogWaitEvent(actor.Id, stateName, eventWaitTypesArray[0]);502                }503                else504                {505                    this.LogWriter.LogWaitEvent(actor.Id, stateName, eventWaitTypesArray);506                }507            }508        }509        /// <summary>510        /// Logs that the specified state machine entered a state.511        /// </summary>512        internal virtual void LogEnteredState(StateMachine stateMachine)513        {514            if (this.Configuration.IsVerbose)515            {516                this.LogWriter.LogStateTransition(stateMachine.Id, stateMachine.CurrentStateName, isEntry: true);517            }518        }519        /// <summary>520        /// Logs that the specified state machine exited a state.521        /// </summary>522        internal virtual void LogExitedState(StateMachine stateMachine)523        {524            if (this.Configuration.IsVerbose)525            {526                this.LogWriter.LogStateTransition(stateMachine.Id, stateMachine.CurrentStateName, isEntry: false);527            }528        }529        /// <summary>530        /// Logs that the specified state machine invoked pop.531        /// </summary>532        [MethodImpl(MethodImplOptions.AggressiveInlining)]533        internal virtual void LogPopState(StateMachine stateMachine)534        {535        }536        /// <summary>537        /// Logs that the specified state machine invoked an action.538        /// </summary>539        internal virtual void LogInvokedOnEntryAction(StateMachine stateMachine, MethodInfo action)540        {541            if (this.Configuration.IsVerbose)542            {543                this.LogWriter.LogExecuteAction(stateMachine.Id, stateMachine.CurrentStateName,544                    stateMachine.CurrentStateName, action.Name);545            }546        }547        /// <summary>548        /// Logs that the specified state machine invoked an action.549        /// </summary>550        internal virtual void LogInvokedOnExitAction(StateMachine stateMachine, MethodInfo action)551        {552            if (this.Configuration.IsVerbose)553            {554                this.LogWriter.LogExecuteAction(stateMachine.Id, stateMachine.CurrentStateName,555                    stateMachine.CurrentStateName, action.Name);556            }557        }558        /// <summary>559        /// Builds the coverage graph information, if any. This information is only available560        /// when <see cref="Configuration.ReportActivityCoverage"/> is enabled.561        /// </summary>562        internal CoverageInfo BuildCoverageInfo()563        {564            var result = this.CoverageInfo;565            if (result != null)566            {567                var builder = this.LogWriter.GetLogsOfType<ActorRuntimeLogGraphBuilder>().FirstOrDefault();568                if (builder != null)569                {570                    result.CoverageGraph = builder.SnapshotGraph(this.Configuration.IsDgmlBugGraph);571                }572                var eventCoverage = this.LogWriter.GetLogsOfType<ActorRuntimeLogEventCoverage>().FirstOrDefault();573                if (eventCoverage != null)574                {575                    result.EventInfo = eventCoverage.EventCoverage;576                }577            }578            return result;579        }580        /// <summary>581        /// Returns the current hashed state of the actors.582        /// </summary>583        /// <remarks>584        /// The hash is updated in each execution step.585        /// </remarks>586        internal virtual int GetHashedActorState() => 0;587        /// <summary>588        /// Returns the program counter of the specified actor.589        /// </summary>590        [MethodImpl(MethodImplOptions.AggressiveInlining)]591        internal virtual int GetActorProgramCounter(ActorId actorId) => 0;592        /// <inheritdoc/>593        public void RegisterMonitor<T>()594            where T : Monitor =>595            this.TryCreateMonitor(typeof(T));596        /// <inheritdoc/>597        public void Monitor<T>(Event e)598            where T : Monitor599        {600            // If the event is null then report an error and exit.601            this.Assert(e != null, "Cannot monitor a null event.");602            this.InvokeMonitor(typeof(T), e, null, null, null);603        }604        /// <summary>605        /// Tries to create a new <see cref="Specifications.Monitor"/> of the specified <see cref="Type"/>.606        /// </summary>607        protected bool TryCreateMonitor(Type type) => this.SpecificationEngine.TryCreateMonitor(608            type, this.CoverageInfo, this.LogWriter);609        /// <summary>610        /// Invokes the specified <see cref="Specifications.Monitor"/> with the specified <see cref="Event"/>.611        /// </summary>612        internal void InvokeMonitor(Type type, Event e, string senderName, string senderType, string senderStateName) =>613            this.SpecificationEngine.InvokeMonitor(type, e, senderName, senderType, senderStateName);614        /// <inheritdoc/>615        [MethodImpl(MethodImplOptions.AggressiveInlining)]616        public void Assert(bool predicate) => this.SpecificationEngine.Assert(predicate);617        /// <inheritdoc/>618        [MethodImpl(MethodImplOptions.AggressiveInlining)]619        public void Assert(bool predicate, string s, object arg0) => this.SpecificationEngine.Assert(predicate, s, arg0);620        /// <inheritdoc/>621        [MethodImpl(MethodImplOptions.AggressiveInlining)]622        public void Assert(bool predicate, string s, object arg0, object arg1) => this.SpecificationEngine.Assert(predicate, s, arg0, arg1);623        /// <inheritdoc/>624        [MethodImpl(MethodImplOptions.AggressiveInlining)]625        public void Assert(bool predicate, string s, object arg0, object arg1, object arg2) =>626            this.SpecificationEngine.Assert(predicate, s, arg0, arg1, arg2);627        /// <inheritdoc/>628        [MethodImpl(MethodImplOptions.AggressiveInlining)]629        public void Assert(bool predicate, string s, params object[] args) => this.SpecificationEngine.Assert(predicate, s, args);630        /// <summary>631        /// Asserts that the actor calling an actor method is also the actor that is currently executing.632        /// </summary>633        [MethodImpl(MethodImplOptions.AggressiveInlining)]634        internal virtual void AssertExpectedCallerActor(Actor caller, string calledAPI)635        {636        }637        /// <summary>638        /// Raises the <see cref="OnFailure"/> event with the specified <see cref="Exception"/>.639        /// </summary>640        internal void RaiseOnFailureEvent(Exception exception) => this.Runtime.RaiseOnFailureEvent(exception);641        /// <summary>642        /// Handle the specified dropped <see cref="Event"/>.643        /// </summary>644        internal void HandleDroppedEvent(Event e, ActorId id) => this.OnEventDropped?.Invoke(e, id);645        /// <summary>646        /// Throws an <see cref="AssertionFailureException"/> exception containing the specified exception.647        /// </summary>648#if !DEBUG649        [DebuggerHidden]650#endif651        internal void WrapAndThrowException(Exception exception, string s, params object[] args) =>652            this.SpecificationEngine.WrapAndThrowException(exception, s, args);653        /// <inheritdoc/>654        [Obsolete("Please set the Logger property directory instead of calling this method.")]655        public TextWriter SetLogger(TextWriter logger)656        {657            var result = this.LogWriter.SetLogger(new TextWriterLogger(logger));658            if (result != null)659            {660                return result.TextWriter;661            }662            return null;663        }664        /// <inheritdoc/>665        public void RegisterLog(IActorRuntimeLog log) => this.LogWriter.RegisterLog(log);666        /// <inheritdoc/>667        public void RemoveLog(IActorRuntimeLog log) => this.LogWriter.RemoveLog(log);668        /// <inheritdoc/>669        public void Stop() => this.Scheduler.ForceStop();670        /// <summary>671        /// Disposes runtime resources....

SetLogger

Using AI Code Generation

1using System;2using System.Collections.Generic;3using System.Linq;4using System.Text;5using System.Threading.Tasks;6using Microsoft.Coyote.Actors;7{8    {9        static void Main(string[] args)10        {11            var runtime = RuntimeFactory.Create();12            var logger = new Logger();13            runtime.SetLogger(logger);14            runtime.CreateActor(typeof(MyActor));15            runtime.Wait();16        }17    }18}19using System;20using System.Collections.Generic;21using System.Linq;22using System.Text;23using System.Threading.Tasks;24using Microsoft.Coyote.Actors;25{26    {27        static void Main(string[] args)28        {29            var runtime = RuntimeFactory.Create();30            var logger = new Logger();31            runtime.SetLogger(logger);32            runtime.CreateActor(typeof(MyActor));33            runtime.Wait();34        }35    }36}37using System;38using System.Collections.Generic;39using System.Linq;40using System.Text;41using System.Threading.Tasks;42using Microsoft.Coyote.Actors;43{44    {45        static void Main(string[] args)46        {47            var runtime = RuntimeFactory.Create();48            var logger = new Logger();49            runtime.SetLogger(logger);50            runtime.CreateActor(typeof(MyActor));51            runtime.Wait();52        }53    }54}55using System;56using System.Collections.Generic;57using System.Linq;58using System.Text;59using System.Threading.Tasks;60using Microsoft.Coyote.Actors;61{62    {63        static void Main(string[] args)64        {65            var runtime = RuntimeFactory.Create();66            var logger = new Logger();67            runtime.SetLogger(logger);68            runtime.CreateActor(typeof(MyActor));69            runtime.Wait();70        }71    }72}73using System;74using System.Collections.Generic;75using System.Linq;76using System.Text;77using System.Threading.Tasks;78using Microsoft.Coyote.Actors;79{80    {

SetLogger

Using AI Code Generation

1using Microsoft.Coyote.Actors;2using Microsoft.Coyote.Actors.Timers;3using System;4using System.Collections.Generic;5using System.Linq;6using System.Text;7using System.Threading.Tasks;8{9    {10        static void Main(string[] args)11        {12            ActorId actor = ActorId.CreateRandom();13            var logger = new Coyote.Actors.Logging.ConsoleLogger();14            ActorExecutionContext.SetLogger(actor, logger);15            var machine = new Machine1(actor);16            machine.RunAsync().Wait();17            Console.ReadLine();18        }19    }20    {21        [OnEntry(nameof(EntryInit))]22        [OnEventGotoState(typeof(Event1), typeof(State1))]23        {24        }25        void EntryInit()26        {27            this.Send(this.Id, new Event1(1));28        }29        [OnEntry(nameof(EntryState1))]30        {31        }32        void EntryState1()33        {34            this.Send(this.Id, new Event1(2));35        }36    }37    {38        public int Value;39        public Event1(int value)40        {41            this.Value = value;42        }43    }44}45[2020-07-14 03:25:37.976] [INFO] [Machine1] [Machine1] [Init] [EntryInit] [Event1(1)] [State1] [EntryState1] [Event1(2)]

SetLogger

Using AI Code Generation

1using Microsoft.Coyote.Actors;2using Microsoft.Coyote.Actors.Logging;3using Microsoft.Coyote.Runtime;4using Microsoft.Coyote.SystematicTesting;5using Microsoft.Coyote.SystematicTesting.Logging;6using System;7using System.Threading.Tasks;8{9    {10        static async Task Main(string[] args)11        {12            var config = Configuration.Create();13            config.SetLogger(new MyLogger());14            ActorRuntime.SetLogger(new MyLogger());15            var test = new SystematicTestingEngine(config);16            test.SetLogger(new MyLogger());17            await test.RunAsync();18        }19    }20    {21        public void Log(string message)22        {23            Console.WriteLine("MyLogger: " + message);24        }25        public void Log(string message, ConsoleColor color)26        {27            Console.WriteLine("MyLogger: " + message);28        }29    }30}31using Microsoft.Coyote.Actors;32using Microsoft.Coyote.Actors.Logging;33using Microsoft.Coyote.Runtime;34using Microsoft.Coyote.SystematicTesting;35using Microsoft.Coyote.SystematicTesting.Logging;36using System;37using System.Threading.Tasks;38{39    {40        static async Task Main(string[] args)41        {42            var config = Configuration.Create();43            ActorRuntime.SetLogger(new MyLogger());44            var test = new SystematicTestingEngine(config);45            test.SetLogger(new MyLogger());46            await test.RunAsync();47        }48    }49    {50        public void Log(string message)51        {52            Console.WriteLine("MyLogger: " + message);53        }54        public void Log(string message, ConsoleColor color)55        {56            Console.WriteLine("MyLogger: " + message);57        }58    }59}60using Microsoft.Coyote.Actors;61using Microsoft.Coyote.Actors.Logging;62using Microsoft.Coyote.Runtime;63using Microsoft.Coyote.SystematicTesting;64using Microsoft.Coyote.SystematicTesting.Logging;65using System;

SetLogger

Using AI Code Generation

1using Microsoft.Coyote;2using Microsoft.Coyote.Actors;3using System;4using System.Threading.Tasks;5{6    {7        static void Main(string[] args)8        {9            ActorExecutionContext.SetLogger(new Logger());10            var runtime = RuntimeFactory.Create();11            runtime.CreateActor(typeof(Actor1));12            runtime.Run();13        }14    }15    {16        public void Log(string message)17        {18            Console.WriteLine(message);19        }20        public void Log(string format, params object[] args)21        {22            Console.WriteLine(format, args);23        }24    }25    {26        protected override async Task OnInitializeAsync(Event initialEvent)27        {28            this.Assert(false, "Assert failed");29        }

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.