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

How to use ReceiveEventAsync method of Microsoft.Coyote.Actors.Mocks.MockEventQueue class

Best Coyote code snippet using Microsoft.Coyote.Actors.Mocks.MockEventQueue.ReceiveEventAsync

ActorExecutionContext.cs

Source:ActorExecutionContext.cs

...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.672        /// </summary>673        protected virtual void Dispose(bool disposing)674        {675            if (disposing)676            {677                this.ActorMap.Clear();678            }679        }680        /// <inheritdoc/>681        public void Dispose()682        {683            this.Dispose(true);684            GC.SuppressFinalize(this);685        }686        /// <summary>687        /// The mocked execution context of an actor program.688        /// </summary>689        internal sealed class Mock : ActorExecutionContext690        {691            /// <summary>692            /// Map that stores all unique names and their corresponding actor ids.693            /// </summary>694            private readonly ConcurrentDictionary<string, ActorId> NameValueToActorId;695            /// <summary>696            /// Map of program counters used for state-caching to distinguish697            /// scheduling from non-deterministic choices.698            /// </summary>699            private readonly ConcurrentDictionary<ActorId, int> ProgramCounterMap;700            /// <summary>701            /// If true, the actor execution is controlled, else false.702            /// </summary>703            internal override bool IsExecutionControlled => true;704            /// <summary>705            /// Initializes a new instance of the <see cref="Mock"/> class.706            /// </summary>707            internal Mock(Configuration configuration, CoyoteRuntime runtime, OperationScheduler scheduler,708                SpecificationEngine specificationEngine, IRandomValueGenerator valueGenerator, LogWriter logWriter)709                : base(configuration, runtime, scheduler, specificationEngine, valueGenerator, logWriter)710            {711                this.NameValueToActorId = new ConcurrentDictionary<string, ActorId>();712                this.ProgramCounterMap = new ConcurrentDictionary<ActorId, int>();713            }714            /// <inheritdoc/>715            public override ActorId CreateActorIdFromName(Type type, string name)716            {717                // It is important that all actor ids use the monotonically incrementing718                // value as the id during testing, and not the unique name.719                return this.NameValueToActorId.GetOrAdd(name, key => this.CreateActorId(type, key));720            }721            /// <inheritdoc/>722            public override ActorId CreateActor(Type type, Event initialEvent = null, EventGroup eventGroup = null) =>723                this.CreateActor(null, type, null, initialEvent, eventGroup);724            /// <inheritdoc/>725            public override ActorId CreateActor(Type type, string name, Event initialEvent = null, EventGroup eventGroup = null) =>726                this.CreateActor(null, type, name, initialEvent, eventGroup);727            /// <inheritdoc/>728            public override ActorId CreateActor(ActorId id, Type type, Event initialEvent = null, EventGroup eventGroup = null)729            {730                this.Assert(id != null, "Cannot create an actor using a null actor id.");731                return this.CreateActor(id, type, null, initialEvent, eventGroup);732            }733            /// <inheritdoc/>734            public override Task<ActorId> CreateActorAndExecuteAsync(Type type, Event initialEvent = null, EventGroup eventGroup = null) =>735                this.CreateActorAndExecuteAsync(null, type, null, initialEvent, eventGroup);736            /// <inheritdoc/>737            public override Task<ActorId> CreateActorAndExecuteAsync(Type type, string name, Event initialEvent = null, EventGroup eventGroup = null) =>738                this.CreateActorAndExecuteAsync(null, type, name, initialEvent, eventGroup);739            /// <inheritdoc/>740            public override Task<ActorId> CreateActorAndExecuteAsync(ActorId id, Type type, Event initialEvent = null, EventGroup eventGroup = null)741            {742                this.Assert(id != null, "Cannot create an actor using a null actor id.");743                return this.CreateActorAndExecuteAsync(id, type, null, initialEvent, eventGroup);744            }745            /// <summary>746            /// Creates a new actor of the specified <see cref="Type"/> and name, using the specified747            /// unbound actor id, and passes the specified optional <see cref="Event"/>. This event748            /// can only be used to access its payload, and cannot be handled.749            /// </summary>750            internal ActorId CreateActor(ActorId id, Type type, string name, Event initialEvent = null, EventGroup eventGroup = null)751            {752                var creatorOp = this.Scheduler.GetExecutingOperation<ActorOperation>();753                return this.CreateActor(id, type, name, initialEvent, creatorOp?.Actor, eventGroup);754            }755            /// <summary>756            /// Creates a new <see cref="Actor"/> of the specified <see cref="Type"/>.757            /// </summary>758            internal override ActorId CreateActor(ActorId id, Type type, string name, Event initialEvent, Actor creator, EventGroup eventGroup)759            {760                this.AssertExpectedCallerActor(creator, "CreateActor");761                Actor actor = this.CreateActor(id, type, name, creator, eventGroup);762                this.RunActorEventHandler(actor, initialEvent, true, null);763                return actor.Id;764            }765            /// <summary>766            /// Creates a new actor of the specified <see cref="Type"/> and name, using the specified767            /// unbound actor id, and passes the specified optional <see cref="Event"/>. This event768            /// can only be used to access its payload, and cannot be handled. The method returns only769            /// when the actor is initialized and the <see cref="Event"/> (if any) is handled.770            /// </summary>771            internal Task<ActorId> CreateActorAndExecuteAsync(ActorId id, Type type, string name, Event initialEvent = null,772                EventGroup eventGroup = null)773            {774                var creatorOp = this.Scheduler.GetExecutingOperation<ActorOperation>();775                return this.CreateActorAndExecuteAsync(id, type, name, initialEvent, creatorOp?.Actor, eventGroup);776            }777            /// <summary>778            /// Creates a new <see cref="Actor"/> of the specified <see cref="Type"/>. The method779            /// returns only when the actor is initialized and the <see cref="Event"/> (if any)780            /// is handled.781            /// </summary>782            internal override async Task<ActorId> CreateActorAndExecuteAsync(ActorId id, Type type, string name, Event initialEvent,783                Actor creator, EventGroup eventGroup)784            {785                this.AssertExpectedCallerActor(creator, "CreateActorAndExecuteAsync");786                this.Assert(creator != null, "Only an actor can call 'CreateActorAndExecuteAsync': avoid calling " +787                    "it directly from the test method; instead call it through a test driver actor.");788                Actor actor = this.CreateActor(id, type, name, creator, eventGroup);789                this.RunActorEventHandler(actor, initialEvent, true, creator);790                // Wait until the actor reaches quiescence.791                await creator.ReceiveEventAsync(typeof(QuiescentEvent), rev => (rev as QuiescentEvent).ActorId == actor.Id);792                return await Task.FromResult(actor.Id);793            }794            /// <summary>795            /// Creates a new <see cref="Actor"/> of the specified <see cref="Type"/>.796            /// </summary>797            internal override Actor CreateActor(ActorId id, Type type, string name, Actor creator, EventGroup eventGroup)798            {799                this.Assert(type.IsSubclassOf(typeof(Actor)), "Type '{0}' is not an actor.", type.FullName);800                // Using ulong.MaxValue because a Create operation cannot specify801                // the id of its target, because the id does not exist yet.802                this.Scheduler.ScheduleNextOperation(AsyncOperationType.Create);803                this.ResetProgramCounter(creator);804                if (id is null)805                {806                    id = this.CreateActorId(type, name);807                }808                else809                {810                    this.Assert(id.Runtime is null || id.Runtime == this, "Unbound actor id '{0}' was created by another runtime.", id.Value);811                    this.Assert(id.Type == type.FullName, "Cannot bind actor id '{0}' of type '{1}' to an actor of type '{2}'.",812                        id.Value, id.Type, type.FullName);813                    id.Bind(this);814                }815                // If a group was not provided, inherit the current event group from the creator (if any).816                if (eventGroup is null && creator != null)817                {818                    eventGroup = creator.EventGroup;819                }820                Actor actor = ActorFactory.Create(type);821                ActorOperation op = new ActorOperation(id.Value, id.Name, actor, this.Scheduler);822                IEventQueue eventQueue = new MockEventQueue(actor);823                actor.Configure(this, id, op, eventQueue, eventGroup);824                actor.SetupEventHandlers();825                if (this.Configuration.ReportActivityCoverage)826                {827                    actor.ReportActivityCoverage(this.CoverageInfo);828                }829                bool result = this.Scheduler.RegisterOperation(op);830                this.Assert(result, "Actor id '{0}' is used by an existing or previously halted actor.", id.Value);831                if (actor is StateMachine)832                {833                    this.LogWriter.LogCreateStateMachine(id, creator?.Id.Name, creator?.Id.Type);834                }835                else836                {837                    this.LogWriter.LogCreateActor(id, creator?.Id.Name, creator?.Id.Type);838                }839                return actor;840            }841            /// <inheritdoc/>842            public override void SendEvent(ActorId targetId, Event initialEvent, EventGroup eventGroup = default, SendOptions options = null)843            {844                var senderOp = this.Scheduler.GetExecutingOperation<ActorOperation>();845                this.SendEvent(targetId, initialEvent, senderOp?.Actor, eventGroup, options);846            }847            /// <inheritdoc/>848            public override Task<bool> SendEventAndExecuteAsync(ActorId targetId, Event initialEvent,849                EventGroup eventGroup = null, SendOptions options = null)850            {851                var senderOp = this.Scheduler.GetExecutingOperation<ActorOperation>();852                return this.SendEventAndExecuteAsync(targetId, initialEvent, senderOp?.Actor, eventGroup, options);853            }854            /// <summary>855            /// Sends an asynchronous <see cref="Event"/> to an actor.856            /// </summary>857            internal override void SendEvent(ActorId targetId, Event e, Actor sender, EventGroup eventGroup, SendOptions options)858            {859                if (e is null)860                {861                    string message = sender != null ?862                        string.Format("{0} is sending a null event.", sender.Id.ToString()) :863                        "Cannot send a null event.";864                    this.Assert(false, message);865                }866                if (sender != null)867                {868                    this.Assert(targetId != null, "{0} is sending event {1} to a null actor.", sender.Id, e);869                }870                else871                {872                    this.Assert(targetId != null, "Cannot send event {1} to a null actor.", e);873                }874                this.AssertExpectedCallerActor(sender, "SendEvent");875                EnqueueStatus enqueueStatus = this.EnqueueEvent(targetId, e, sender, eventGroup, options, out Actor target);876                if (enqueueStatus is EnqueueStatus.EventHandlerNotRunning)877                {878                    this.RunActorEventHandler(target, null, false, null);879                }880            }881            /// <summary>882            /// Sends an asynchronous <see cref="Event"/> to an actor. Returns immediately if the target was883            /// already running. Otherwise blocks until the target handles the event and reaches quiescense.884            /// </summary>885            internal override async Task<bool> SendEventAndExecuteAsync(ActorId targetId, Event e, Actor sender,886                EventGroup eventGroup, SendOptions options)887            {888                this.Assert(sender is StateMachine, "Only an actor can call 'SendEventAndExecuteAsync': avoid " +889                    "calling it directly from the test method; instead call it through a test driver actor.");890                this.Assert(e != null, "{0} is sending a null event.", sender.Id);891                this.Assert(targetId != null, "{0} is sending event {1} to a null actor.", sender.Id, e);892                this.AssertExpectedCallerActor(sender, "SendEventAndExecuteAsync");893                EnqueueStatus enqueueStatus = this.EnqueueEvent(targetId, e, sender, eventGroup, options, out Actor target);894                if (enqueueStatus is EnqueueStatus.EventHandlerNotRunning)895                {896                    this.RunActorEventHandler(target, null, false, sender as StateMachine);897                    // Wait until the actor reaches quiescence.898                    await (sender as StateMachine).ReceiveEventAsync(typeof(QuiescentEvent), rev => (rev as QuiescentEvent).ActorId == targetId);899                    return true;900                }901                // EnqueueStatus.EventHandlerNotRunning is not returned by EnqueueEvent902                // (even when the actor was previously inactive) when the event e requires903                // no action by the actor (i.e., it implicitly handles the event).904                return enqueueStatus is EnqueueStatus.Dropped || enqueueStatus is EnqueueStatus.NextEventUnavailable;905            }906            /// <summary>907            /// Enqueues an event to the actor with the specified id.908            /// </summary>909            private EnqueueStatus EnqueueEvent(ActorId targetId, Event e, Actor sender, EventGroup eventGroup,910                SendOptions options, out Actor target)911            {912                target = this.Scheduler.GetOperationWithId<ActorOperation>(targetId.Value)?.Actor;913                this.Assert(target != null,914                    "Cannot send event '{0}' to actor id '{1}' that is not bound to an actor instance.",915                    e.GetType().FullName, targetId.Value);916                this.Scheduler.ScheduleNextOperation(AsyncOperationType.Send);917                this.ResetProgramCounter(sender as StateMachine);918                // If no group is provided we default to passing along the group from the sender.919                if (eventGroup is null && sender != null)920                {921                    eventGroup = sender.EventGroup;922                }923                if (target.IsHalted)924                {925                    Guid groupId = eventGroup is null ? Guid.Empty : eventGroup.Id;926                    this.LogWriter.LogSendEvent(targetId, sender?.Id.Name, sender?.Id.Type,927                        (sender as StateMachine)?.CurrentStateName ?? default, e, groupId, isTargetHalted: true);928                    this.Assert(options is null || !options.MustHandle,929                        "A must-handle event '{0}' was sent to {1} which has halted.", e.GetType().FullName, targetId);930                    this.HandleDroppedEvent(e, targetId);931                    return EnqueueStatus.Dropped;932                }933                EnqueueStatus enqueueStatus = this.EnqueueEvent(target, e, sender, eventGroup, options);934                if (enqueueStatus == EnqueueStatus.Dropped)935                {936                    this.HandleDroppedEvent(e, targetId);937                }938                return enqueueStatus;939            }940            /// <summary>941            /// Enqueues an event to the actor with the specified id.942            /// </summary>943            private EnqueueStatus EnqueueEvent(Actor actor, Event e, Actor sender, EventGroup eventGroup, SendOptions options)944            {945                EventOriginInfo originInfo;946                string stateName = null;947                if (sender is StateMachine senderStateMachine)948                {949                    originInfo = new EventOriginInfo(sender.Id, senderStateMachine.GetType().FullName,950                        NameResolver.GetStateNameForLogging(senderStateMachine.CurrentState));951                    stateName = senderStateMachine.CurrentStateName;952                }953                else if (sender is Actor senderActor)954                {955                    originInfo = new EventOriginInfo(sender.Id, senderActor.GetType().FullName, string.Empty);956                }957                else958                {959                    // Message comes from the environment.960                    originInfo = new EventOriginInfo(null, "Env", "Env");961                }962                EventInfo eventInfo = new EventInfo(e, originInfo)963                {964                    MustHandle = options?.MustHandle ?? false,965                    Assert = options?.Assert ?? -1966                };967                Guid opId = eventGroup is null ? Guid.Empty : eventGroup.Id;968                this.LogWriter.LogSendEvent(actor.Id, sender?.Id.Name, sender?.Id.Type, stateName,969                    e, opId, isTargetHalted: false);970                return actor.Enqueue(e, eventGroup, eventInfo);971            }972            /// <summary>973            /// Runs a new asynchronous event handler for the specified actor.974            /// This is a fire and forget invocation.975            /// </summary>976            /// <param name="actor">The actor that executes this event handler.</param>977            /// <param name="initialEvent">Optional event for initializing the actor.</param>978            /// <param name="isFresh">If true, then this is a new actor.</param>979            /// <param name="syncCaller">Caller actor that is blocked for quiscence.</param>980            private void RunActorEventHandler(Actor actor, Event initialEvent, bool isFresh, Actor syncCaller)981            {982                var op = actor.Operation;983                Task task = new Task(async () =>984                {985                    try986                    {987                        // Update the current asynchronous control flow with this runtime instance,988                        // allowing future retrieval in the same asynchronous call stack.989                        CoyoteRuntime.AssignAsyncControlFlowRuntime(this.Runtime);990                        this.Scheduler.StartOperation(op);991                        if (isFresh)992                        {993                            await actor.InitializeAsync(initialEvent);994                        }995                        await actor.RunEventHandlerAsync();996                        if (syncCaller != null)997                        {998                            this.EnqueueEvent(syncCaller, new QuiescentEvent(actor.Id), actor, actor.CurrentEventGroup, null);999                        }1000                        if (!actor.IsHalted)1001                        {1002                            this.ResetProgramCounter(actor);1003                        }1004                        IODebug.WriteLine("<ScheduleDebug> Completed operation {0} on task '{1}'.", actor.Id, Task.CurrentId);1005                        op.OnCompleted();1006                        // The actor is inactive or halted, schedule the next enabled operation.1007                        this.Scheduler.ScheduleNextOperation(AsyncOperationType.Stop);1008                    }1009                    catch (Exception ex)1010                    {1011                        this.ProcessUnhandledExceptionInOperation(op, ex);1012                    }1013                });1014                task.Start();1015                this.Scheduler.WaitOperationStart(op);1016            }1017            /// <summary>1018            /// Creates a new timer that sends a <see cref="TimerElapsedEvent"/> to its owner actor.1019            /// </summary>1020            internal override IActorTimer CreateActorTimer(TimerInfo info, Actor owner)1021            {1022                var id = this.CreateActorId(typeof(MockStateMachineTimer));1023                this.CreateActor(id, typeof(MockStateMachineTimer), new TimerSetupEvent(info, owner, this.Configuration.TimeoutDelay));1024                return this.Scheduler.GetOperationWithId<ActorOperation>(id.Value).Actor as MockStateMachineTimer;1025            }1026            /// <inheritdoc/>1027            public override EventGroup GetCurrentEventGroup(ActorId currentActorId)1028            {1029                var callerOp = this.Scheduler.GetExecutingOperation<ActorOperation>();1030                this.Assert(callerOp != null && currentActorId == callerOp.Actor.Id,1031                    "Trying to access the event group id of {0}, which is not the currently executing actor.",1032                    currentActorId);1033                return callerOp.Actor.CurrentEventGroup;1034            }1035            /// <summary>1036            /// Returns a controlled nondeterministic boolean choice.1037            /// </summary>1038            internal override bool GetNondeterministicBooleanChoice(int maxValue, string callerName, string callerType)1039            {1040                var caller = this.Scheduler.GetExecutingOperation<ActorOperation>()?.Actor;1041                if (caller is Actor callerActor)1042                {1043                    this.IncrementActorProgramCounter(callerActor.Id);1044                }1045                var choice = this.Scheduler.GetNextNondeterministicBooleanChoice(maxValue);1046                this.LogWriter.LogRandom(choice, callerName ?? caller?.Id.Name, callerType ?? caller?.Id.Type);1047                return choice;1048            }1049            /// <summary>1050            /// Returns a controlled nondeterministic integer choice.1051            /// </summary>1052            internal override int GetNondeterministicIntegerChoice(int maxValue, string callerName, string callerType)1053            {1054                var caller = this.Scheduler.GetExecutingOperation<ActorOperation>()?.Actor;1055                if (caller is Actor callerActor)1056                {1057                    this.IncrementActorProgramCounter(callerActor.Id);1058                }1059                var choice = this.Scheduler.GetNextNondeterministicIntegerChoice(maxValue);1060                this.LogWriter.LogRandom(choice, callerName ?? caller?.Id.Name, callerType ?? caller?.Id.Type);1061                return choice;1062            }1063            /// <inheritdoc/>1064            internal override void LogInvokedAction(Actor actor, MethodInfo action, string handlingStateName, string currentStateName) =>1065                this.LogWriter.LogExecuteAction(actor.Id, handlingStateName, currentStateName, action.Name);1066            /// <inheritdoc/>1067            [MethodImpl(MethodImplOptions.AggressiveInlining)]1068            internal override void LogEnqueuedEvent(Actor actor, Event e, EventGroup eventGroup, EventInfo eventInfo) =>1069                this.LogWriter.LogEnqueueEvent(actor.Id, e);1070            /// <inheritdoc/>1071            internal override void LogDequeuedEvent(Actor actor, Event e, EventInfo eventInfo, bool isFreshDequeue)1072            {1073                if (!isFreshDequeue)1074                {1075                    // Skip the scheduling point, as this is the first dequeue of the event handler,1076                    // to avoid unecessery context switches.1077                    this.Scheduler.ScheduleNextOperation(AsyncOperationType.Receive);1078                    this.ResetProgramCounter(actor);1079                }1080                string stateName = actor is StateMachine stateMachine ? stateMachine.CurrentStateName : null;1081                this.LogWriter.LogDequeueEvent(actor.Id, stateName, e);1082            }1083            /// <inheritdoc/>1084            internal override void LogDefaultEventDequeued(Actor actor)1085            {1086                this.Scheduler.ScheduleNextOperation(AsyncOperationType.Receive);1087                this.ResetProgramCounter(actor);1088            }1089            /// <inheritdoc/>1090            [MethodImpl(MethodImplOptions.AggressiveInlining)]1091            internal override void LogDefaultEventHandlerCheck(Actor actor) => this.Scheduler.ScheduleNextOperation();1092            /// <inheritdoc/>1093            internal override void LogRaisedEvent(Actor actor, Event e, EventGroup eventGroup, EventInfo eventInfo)1094            {1095                string stateName = actor is StateMachine stateMachine ? stateMachine.CurrentStateName : null;1096                this.LogWriter.LogRaiseEvent(actor.Id, stateName, e);1097            }1098            /// <inheritdoc/>1099            internal override void LogHandleRaisedEvent(Actor actor, Event e)1100            {1101                string stateName = actor is StateMachine stateMachine ? stateMachine.CurrentStateName : null;1102                this.LogWriter.LogHandleRaisedEvent(actor.Id, stateName, e);1103            }1104            /// <inheritdoc/>1105            [MethodImpl(MethodImplOptions.AggressiveInlining)]1106            internal override void LogReceiveCalled(Actor actor) => this.AssertExpectedCallerActor(actor, "ReceiveEventAsync");1107            /// <inheritdoc/>1108            internal override void LogReceivedEvent(Actor actor, Event e, EventInfo eventInfo)1109            {1110                string stateName = actor is StateMachine stateMachine ? stateMachine.CurrentStateName : null;1111                this.LogWriter.LogReceiveEvent(actor.Id, stateName, e, wasBlocked: true);1112            }1113            /// <inheritdoc/>1114            internal override void LogReceivedEventWithoutWaiting(Actor actor, Event e, EventInfo eventInfo)1115            {1116                string stateName = actor is StateMachine stateMachine ? stateMachine.CurrentStateName : null;1117                this.LogWriter.LogReceiveEvent(actor.Id, stateName, e, wasBlocked: false);1118                this.Scheduler.ScheduleNextOperation(AsyncOperationType.Receive);1119                this.ResetProgramCounter(actor);1120            }...

MockEventQueue.cs

Source:MockEventQueue.cs

...198            this.RaisedEvent = (e, eventGroup, info);199            this.OnRaiseEvent(e, eventGroup, info);200        }201        /// <inheritdoc/>202        public Task<Event> ReceiveEventAsync(Type eventType, Func<Event, bool> predicate = null)203        {204            var eventWaitTypes = new Dictionary<Type, Func<Event, bool>>205            {206                { eventType, predicate }207            };208            return this.ReceiveEventAsync(eventWaitTypes);209        }210        /// <inheritdoc/>211        public Task<Event> ReceiveEventAsync(params Type[] eventTypes)212        {213            var eventWaitTypes = new Dictionary<Type, Func<Event, bool>>();214            foreach (var type in eventTypes)215            {216                eventWaitTypes.Add(type, null);217            }218            return this.ReceiveEventAsync(eventWaitTypes);219        }220        /// <inheritdoc/>221        public Task<Event> ReceiveEventAsync(params Tuple<Type, Func<Event, bool>>[] events)222        {223            var eventWaitTypes = new Dictionary<Type, Func<Event, bool>>();224            foreach (var e in events)225            {226                eventWaitTypes.Add(e.Item1, e.Item2);227            }228            return this.ReceiveEventAsync(eventWaitTypes);229        }230        /// <summary>231        /// Waits for an event to be enqueued.232        /// </summary>233        private Task<Event> ReceiveEventAsync(Dictionary<Type, Func<Event, bool>> eventWaitTypes)234        {235            this.OnReceiveInvoked();236            (Event e, EventGroup eventGroup, EventInfo info) receivedEvent = default;237            var node = this.Queue.First;238            while (node != null)239            {240                // Dequeue the first event that the caller waits to receive, if there is one in the queue.241                if (eventWaitTypes.TryGetValue(node.Value.e.GetType(), out Func<Event, bool> predicate) &&242                    (predicate is null || predicate(node.Value.e)))243                {244                    receivedEvent = node.Value;245                    this.Queue.Remove(node);246                    break;247                }248                node = node.Next;249            }250            if (receivedEvent == default)251            {252                this.ReceiveCompletionSource = new TaskCompletionSource<Event>();253                this.EventWaitTypes = eventWaitTypes;254                this.OnWaitEvent(this.EventWaitTypes.Keys);255                return this.ReceiveCompletionSource.Task;256            }257            this.OnReceiveEventWithoutWaiting(receivedEvent.e, receivedEvent.eventGroup, receivedEvent.info);258            return Task.FromResult(receivedEvent.e);259        }260        /// <summary>261        /// Checks if the specified event is currently ignored.262        /// </summary>263        [MethodImpl(MethodImplOptions.AggressiveInlining)]264        protected virtual bool IsEventIgnored(Event e) => this.Owner.IsEventIgnored(e);265        /// <summary>266        /// Checks if the specified event is currently deferred.267        /// </summary>268        [MethodImpl(MethodImplOptions.AggressiveInlining)]269        protected virtual bool IsEventDeferred(Event e) => this.Owner.IsEventDeferred(e);270        /// <summary>271        /// Checks if a default handler is currently available.272        /// </summary>273        [MethodImpl(MethodImplOptions.AggressiveInlining)]274        protected virtual bool IsDefaultHandlerAvailable()275        {276            bool result = this.Owner.IsDefaultHandlerInstalled();277            if (result)278            {279                this.Owner.Context.Scheduler.ScheduleNextOperation();280            }281            return result;282        }283        /// <summary>284        /// Notifies the actor that an event has been enqueued.285        /// </summary>286        [MethodImpl(MethodImplOptions.AggressiveInlining)]287        protected virtual void OnEnqueueEvent(Event e, EventGroup eventGroup, EventInfo eventInfo) =>288            this.Owner.OnEnqueueEvent(e, eventGroup, eventInfo);289        /// <summary>290        /// Notifies the actor that an event has been raised.291        /// </summary>292        [MethodImpl(MethodImplOptions.AggressiveInlining)]293        protected virtual void OnRaiseEvent(Event e, EventGroup eventGroup, EventInfo eventInfo) =>294            this.Owner.OnRaiseEvent(e, eventGroup, eventInfo);295        /// <summary>296        /// Notifies the actor that it is waiting to receive an event of one of the specified types.297        /// </summary>298        [MethodImpl(MethodImplOptions.AggressiveInlining)]299        protected virtual void OnWaitEvent(IEnumerable<Type> eventTypes) => this.Owner.OnWaitEvent(eventTypes);300        /// <summary>301        /// Notifies the actor that an event it was waiting to receive has been enqueued.302        /// </summary>303        [MethodImpl(MethodImplOptions.AggressiveInlining)]304        protected virtual void OnReceiveEvent(Event e, EventGroup eventGroup, EventInfo eventInfo) =>305            this.Owner.OnReceiveEvent(e, eventGroup, eventInfo);306        /// <summary>307        /// Notifies the actor that an event it was waiting to receive was already in the308        /// event queue when the actor invoked the receive statement.309        /// </summary>310        [MethodImpl(MethodImplOptions.AggressiveInlining)]311        protected virtual void OnReceiveEventWithoutWaiting(Event e, EventGroup eventGroup, EventInfo eventInfo) =>312            this.Owner.OnReceiveEventWithoutWaiting(e, eventGroup, eventInfo);313        /// <summary>314        /// Notifies the actor that <see cref="ReceiveEventAsync(Type[])"/> or one of its overloaded methods was invoked.315        /// </summary>316        [MethodImpl(MethodImplOptions.AggressiveInlining)]317        protected virtual void OnReceiveInvoked() => this.Owner.OnReceiveInvoked();318        /// <summary>319        /// Notifies the actor that an event has been ignored.320        /// </summary>321        [MethodImpl(MethodImplOptions.AggressiveInlining)]322        protected virtual void OnIgnoreEvent(Event e, EventGroup eventGroup, EventInfo eventInfo) => this.Owner.OnIgnoreEvent(e);323        /// <summary>324        /// Notifies the actor that an event has been deferred.325        /// </summary>326        [MethodImpl(MethodImplOptions.AggressiveInlining)]327        protected virtual void OnDeferEvent(Event e, EventGroup eventGroup, EventInfo eventInfo) => this.Owner.OnDeferEvent(e);328        /// <summary>...

ReceiveEventAsync

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote.Actors;4using Microsoft.Coyote.Actors.Mocks;5using Microsoft.Coyote.Actors.Timers;6using Microsoft.Coyote.Specifications;7using Microsoft.Coyote.SystematicTesting;8using Microsoft.Coyote.Tasks;9{10    {11        public static void Main(string[] args)12        {13            var runtime = RuntimeFactory.Create();14            var configuration = Configuration.Create().WithNumberOfIterations(1000);15            var tester = new SystematicTester(runtime, configuration);16            tester.RegisterMonitor(typeof(Monitor));17            tester.RegisterActor(typeof(A));18            tester.RegisterActor(typeof(B));19            tester.RegisterActor(typeof(C));20            tester.RegisterActor(typeof(D));21            tester.RegisterActor(typeof(E));22            tester.RegisterActor(typeof(F));23            tester.RegisterActor(typeof(G));24            tester.RegisterActor(typeof(H));25            tester.RegisterActor(typeof(I));26            tester.RegisterActor(typeof(J));27            tester.RegisterActor(typeof(K));28            tester.RegisterActor(typeof(L));29            tester.RegisterActor(typeof(M));30            tester.RegisterActor(typeof(N));31            tester.RegisterActor(typeof(O));32            tester.RegisterActor(typeof(P));33            tester.RegisterActor(typeof(Q));34            tester.RegisterActor(typeof(R));35            tester.RegisterActor(typeof(S));36            tester.RegisterActor(typeof(T));37            tester.RegisterActor(typeof(U));38            tester.RegisterActor(typeof(V));39            tester.RegisterActor(typeof(W));40            tester.RegisterActor(typeof(X));41            tester.RegisterActor(typeof(Y));42            tester.RegisterActor(typeof(Z));43            tester.RegisterActor(typeof(A1));44            tester.RegisterActor(typeof(B1));45            tester.RegisterActor(typeof(C1));46            tester.RegisterActor(typeof(D1));47            tester.RegisterActor(typeof(E1));48            tester.RegisterActor(typeof(F1));49            tester.RegisterActor(typeof(G1));50            tester.RegisterActor(typeof(H1));51            tester.RegisterActor(typeof(I1));52            tester.RegisterActor(typeof(J1));53            tester.RegisterActor(typeof(K1));54            tester.RegisterActor(typeof(L1));55            tester.RegisterActor(typeof(M1));56            tester.RegisterActor(typeof(N1));57            tester.RegisterActor(typeof(O1));58            tester.RegisterActor(typeof(P1));59            tester.RegisterActor(typeof(Q1));60            tester.RegisterActor(typeof(R1));61            tester.RegisterActor(typeof(S1));62            tester.RegisterActor(typeof(T1));63            tester.RegisterActor(typeof(U1));64            tester.RegisterActor(typeof(V1));65            tester.RegisterActor(typeof(W1));66            tester.RegisterActor(typeof(X1));

ReceiveEventAsync

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Actors;5using Microsoft.Coyote.Actors.Mocks;6using Microsoft.Coyote.Testing;7using Microsoft.Coyote.TestingServices;8using Microsoft.Coyote.TestingServices.Runtime;9using Microsoft.Coyote.TestingServices.SchedulingStrategies;10using Microsoft.Coyote.TestingServices.Threading;11using Microsoft.Coyote.TestingServices.Tracing.Schedule;12using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default;13using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies;14using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.DPOR;15using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.Fuzzing;16using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomExecution;17using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomExecutionWithFairScheduling;18using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomExecutionWithWeightedRandomScheduling;19using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomScheduling;20using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomSchedulingWithFairScheduling;21using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomSchedulingWithWeightedRandomScheduling;22using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.StateExploration;23using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.StateExplorationWithFairScheduling;24using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.StateExplorationWithWeightedRandomScheduling;25using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.WeightedRandomExecution;26using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.WeightedRandomExecutionWithFairScheduling;27using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.WeightedRandomExecutionWithWeightedRandomScheduling;28using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.WeightedRandomScheduling;29using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.WeightedRandomSchedulingWithFairScheduling;30using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.WeightedRandomSchedulingWithWeightedRandomScheduling;

ReceiveEventAsync

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote.Actors;4using Microsoft.Coyote.Actors.Mocks;5using Microsoft.Coyote.Specifications;6using Microsoft.Coyote.Tasks;7using Microsoft.Coyote.TestingServices;8using Microsoft.Coyote.TestingServices.Runtime;9using Microsoft.Coyote.TestingServices.Scheduling;10using Microsoft.Coyote.TestingServices.SchedulingStrategies;11using Microsoft.Coyote.TestingServices.Tracing.Schedule;12using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default;13using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies;14using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.DPOR;15using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.Fuzzing;16using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.PCT;17using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.Probabilistic;18using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.Random;19using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomExploration;20using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomProbabilistic;21using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomProbabilisticExploration;22using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomProbabilisticWithFairScheduling;23using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomWithFairScheduling;24using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomWithFairSchedulingExploration;25using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomWithFairSchedulingProbabilistic;26using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.RandomWithFairSchedulingProbabilisticExploration;27using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.SchedulingPolicy;28using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.SchedulingPolicyExploration;29using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.StateGraph;30using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.StateGraphExploration;31using Microsoft.Coyote.TestingServices.Tracing.Schedule.Default.Strategies.StateGraphWithFairScheduling;

ReceiveEventAsync

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote.Actors;4using Microsoft.Coyote.Actors.Mocks;5using Microsoft.Coyote.Specifications;6{7    {8        public static async Task Main(string[] args)9        {10            var config = Configuration.Create().WithTestingIterations(100);11            var runtime = RuntimeFactory.Create(config);12            var queue = new MockEventQueue();13            var actor = new ActorId();14            queue.EnqueueEvent(new Event(), actor);15            var receivedEvent = await queue.ReceiveEventAsync();16            Console.WriteLine("receivedEvent: " + receivedEvent);17        }18    }19}20using System;21using System.Threading.Tasks;22using Microsoft.Coyote.Actors;23using Microsoft.Coyote.Actors.Mocks;24using Microsoft.Coyote.Specifications;25{26    {27        public static async Task Main(string[] args)28        {29            var config = Configuration.Create().WithTestingIterations(100);30            var runtime = RuntimeFactory.Create(config);31            var queue = new MockEventQueue();32            var actor = new ActorId();33            queue.EnqueueEvent(new Event(), actor);34            var receivedEvent = await queue.ReceiveEventAsync();35            Console.WriteLine("receivedEvent: " + receivedEvent);36        }37    }38}39using System;40using System.Threading.Tasks;41using Microsoft.Coyote.Actors;42using Microsoft.Coyote.Actors.Mocks;43using Microsoft.Coyote.Specifications;44{45    {46        public static async Task Main(string[] args)47        {48            var config = Configuration.Create().WithTestingIterations(100);49            var runtime = RuntimeFactory.Create(config);50            var queue = new MockEventQueue();51            var actor = new ActorId();52            queue.EnqueueEvent(new Event(), actor);53            var receivedEvent = await queue.ReceiveEventAsync();54            Console.WriteLine("receivedEvent: " + receivedEvent);55        }56    }57}58using System;

ReceiveEventAsync

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Actors;5using Microsoft.Coyote.Actors.Mocks;6{7    {8        protected override Task OnInitializeAsync(Event initialEvent)9        {10            this.SendEvent(this.Id, new MyEvent());11            return Task.CompletedTask;12        }13        protected override Task OnEventAsync(Event e)14        {15            if (e is MyEvent)16            {17                Console.WriteLine("Received MyEvent");18            }19            return Task.CompletedTask;20        }21    }22    {23    }24    {25        public static async Task Main(string[] args)26        {27            Runtime runtime = RuntimeFactory.Create();28            await runtime.CreateActorAsync(typeof(MyActor));29            MockEventQueue eventQueue = new MockEventQueue(runtime);30            await eventQueue.ReceiveEventAsync<MyEvent>(runtime.Id);31        }32    }33}34using System;35using System.Threading.Tasks;36using Microsoft.Coyote;37using Microsoft.Coyote.Actors;38using Microsoft.Coyote.Actors.Mocks;39{40    {41        protected override Task OnInitializeAsync(Event initialEvent)42        {43            this.SendEvent(this.Id, new MyEvent());44            return Task.CompletedTask;45        }46        protected override Task OnEventAsync(Event e)47        {48            if (e is MyEvent)49            {50                Console.WriteLine("Received MyEvent");51            }52            return Task.CompletedTask;53        }54    }55    {56    }57    {58        public static async Task Main(string[] args)59        {60            Runtime runtime = RuntimeFactory.Create();61            await runtime.CreateActorAsync(typeof(MyActor));62            MockEventQueue eventQueue = new MockEventQueue(runtime);63            await eventQueue.ReceiveEventAsync<MyEvent>(runtime.Id, TimeSpan.FromSeconds(3));64        }65    }66}67using System;68using System.Threading.Tasks;69using Microsoft.Coyote;70using Microsoft.Coyote.Actors;

ReceiveEventAsync

Using AI Code Generation

1using System.Threading.Tasks;2using Microsoft.Coyote;3using Microsoft.Coyote.Actors;4using Microsoft.Coyote.Actors.Mocks;5using Microsoft.Coyote.Specifications;6{7    {8        public static async Task Main(string[] args)9        {10            Configuration configuration = Configuration.Create();11            using (var runtime = RuntimeFactory.Create(configuration))12            {13                var queue = new MockEventQueue();14                var actor = new ActorId();15                runtime.CreateActor(typeof(MyActor), actor, queue);16                runtime.SendEvent(actor, new PingEvent());17                var e = await queue.ReceiveEventAsync();18                Specification.Assert(e is PingEvent, "Received unexpected event.");19            }20        }21        private class PingEvent : Event { }22        {23            [OnEventDoAction(typeof(PingEvent), nameof(SendPong))]24            private class Init : State { }25            private void SendPong()26            {27                this.SendEvent(this.Id, new PongEvent());28            }29        }30    }31}

ReceiveEventAsync

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote.Actors;4using Microsoft.Coyote.Actors.Mocks;5using Microsoft.Coyote.Specifications;6using Microsoft.Coyote.SystematicTesting;7using Microsoft.Coyote.Tasks;8using Microsoft.Coyote.Tests.Common;9{10    {11    }12    {13    }14    {15    }16    {17    }18    {19    }20    {21    }22    {23    }24    {25    }26    {27    }28    {29    }30    {31    }32    {33    }34    {35    }36    {37    }38    {39    }40    {41    }42    {43    }44    {45    }46    {47    }48    {49    }50    {51    }52    {53    }54    {55    }56    {57    }58    {59    }60    {61    }62    {63    }64    {65    }66    {67    }68    {69    }70    {71    }72    {73    }74    {75    }76    {77    }78    {79    }

ReceiveEventAsync

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using Microsoft.Coyote;4using Microsoft.Coyote.Actors;5using Microsoft.Coyote.Actors.Mocks;6using Microsoft.Coyote.Actors.Timers;7using Microsoft.Coyote.Specifications;8using Microsoft.Coyote.SystematicTesting;9using Microsoft.Coyote.Tasks;10{11    {12        public static async Task Main(string[] args)13        {14            var configuration = Configuration.Create().WithTestingIterations(100);15            var test = new SystematicTest(configuration);16            test.RegisterMonitor(typeof(MyMonitor));17            await test.RunAsync();18        }19    }20    {21        [OnEventDoAction(typeof(StartEvent), nameof(Start))]22        {23        }24        private void Start()25        {26            var actor = this.CreateActor(typeof(MyActor));27            var eventQueue = (MockEventQueue)this.GetEventQueue(actor);28            var evt = eventQueue.ReceiveEventAsync();29            this.Assert(evt != null);30        }31    }32    {33        protected override void OnInitialize(Event e)34        {35            this.SendEvent(this.Id, new MyEvent());36        }37    }38    {39    }40}41using System;42using System.Threading.Tasks;43using Microsoft.Coyote;44using Microsoft.Coyote.Actors;45using Microsoft.Coyote.Actors.Mocks;46using Microsoft.Coyote.Actors.Timers;47using Microsoft.Coyote.Specifications;48using Microsoft.Coyote.SystematicTesting;49using Microsoft.Coyote.Tasks;50{51    {52        public static async Task Main(string[] args)53        {54            var configuration = Configuration.Create().WithTestingIterations(100);55            var test = new SystematicTest(configuration);56            test.RegisterMonitor(typeof(MyMonitor));57            await test.RunAsync();58        }59    }60    {61        [OnEventDoAction(typeof(StartEvent), nameof(Start))]

ReceiveEventAsync

Using AI Code Generation

1using System;2using Microsoft.Coyote.Actors;3using Microsoft.Coyote.Actors.Mocks;4using Microsoft.Coyote.Specifications;5{6    {7        static void Main(string[] args)8        {9            var eventQueue = new MockEventQueue();10            var e = new Event();11            eventQueue.Enqueue(e);12            var receivedEvent = eventQueue.ReceiveEventAsync().Result;13            Specification.Assert(receivedEvent == e, "The received event is not the same as the enqueued event");14        }15    }16}17using System;18using Microsoft.Coyote;19using Microsoft.Coyote.Actors;20using Microsoft.Coyote.Specifications;21{22    {23        static void Main(string[] args)24        {25            Runtime.Run(new Action<Action>(entry =>26            {27                var eventQueue = new MockEventQueue();28                var e = new Event();29                eventQueue.Enqueue(e);30                var receivedEvent = eventQueue.ReceiveEventAsync().Result;31                Specification.Assert(receivedEvent == e, "The received event is not the same as the enqueued event");32            }));33        }34    }35}

ReceiveEventAsync

Using AI Code Generation

1using System;2using Microsoft.Coyote.Actors;3using Microsoft.Coyote.Actors.Mocks;4using Microsoft.Coyote.Tests.Common;5using Microsoft.Coyote.Samples.Channels;6using System.Threading.Tasks;7{8    {9        public static async Task Main()10        {11            var configuration = Configuration.Create().WithTestingIterations(1000);12            var runtime = RuntimeFactory.Create(configuration);13            var eventQueue = new MockEventQueue(runtime);14            var channel = new Channel<int>(runtime, eventQueue);15            var sendTask = Task.Run(async () =>16            {17                for (int i = 0; i < 100; i++)18                {19                    await channel.SendAsync(i);20                }21            });22            var receiveTask = Task.Run(async () =>23            {24                for (int i = 0; i < 100; i++)25                {26                    var value = await channel.ReceiveAsync();27                    Console.WriteLine(value);28                }29            });30            await Task.WhenAll(sendTask, receiveTask);31        }32    }33}

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.