Addon fix for #402 (#403)

akashlal · pdeligia · commit e409f502d125 · 2019-02-13T17:10:30.000-08:00
* Addon fix for #402 * minor edits
diff --git a/Source/Core/Runtime/Machines/Machine.cs b/Source/Core/Runtime/Machines/Machine.cs
@@ -415,7 +415,7 @@ protected void Raise(Event e)
             // If the event is null, then report an error and exit.
             this.Assert(e != null, $"Machine '{base.Id}' is raising a null event.");
             this.RaisedEvent = new EventInfo(e, new EventOriginInfo(
-                base.Id, this.GetType().Name, StateGroup.GetQualifiedStateName(this.CurrentState)));
+                base.Id, this.GetType().Name, Machine.GetStateNameForLogging(this.CurrentState)));
             base.Runtime.NotifyRaisedEvent(this, this.RaisedEvent);
         }
 
@@ -732,7 +732,7 @@ private EventInfo GetDefaultEvent()
         {
             base.Runtime.Logger.OnDefault(this.Id, this.CurrentStateName);
             return new EventInfo(new Default(), new EventOriginInfo(
-                base.Id, this.GetType().Name, StateGroup.GetQualifiedStateName(this.CurrentState)));
+                base.Id, this.GetType().Name, Machine.GetStateNameForLogging(this.CurrentState)));
         }
 
         #endregion
@@ -1122,7 +1122,7 @@ private async Task ExecuteAction(CachedAction cachedAction)
         private async Task GotoState(Type s, string onExitActionName)
         {
             this.Logger.OnGoto(this.Id, this.CurrentStateName, 
-                $"{s.DeclaringType}.{StateGroup.GetQualifiedStateName(s)}");
+                $"{s.DeclaringType}.{Machine.GetStateNameForLogging(s)}");
 
             // The machine performs the on exit action of the current state.
             await this.ExecuteCurrentStateOnExit(onExitActionName);
@@ -1694,6 +1694,14 @@ private MethodInfo GetActionWithName(string actionName)
             return method;
         }
 
+        /// <summary>
+        /// Returns the state name to be used for logging purposes.
+        /// </summary>
+        /// <param name="state">The machine state.</param>
+        /// <returns>The state name.</returns>
+        internal static string GetStateNameForLogging(Type state) =>
+            state == null ? "None" : StateGroup.GetQualifiedStateName(state);
+
         #endregion
 
         #region code coverage methods
diff --git a/Source/TestingServices/Runtime/TestingRuntime.cs b/Source/TestingServices/Runtime/TestingRuntime.cs
@@ -777,7 +777,7 @@ private EventInfo EnqueueEvent(Machine machine, Event e, BaseMachine sender, Gui
             if (sender != null && sender is Machine)
             {
                 originInfo = new EventOriginInfo(sender.Id, (sender as Machine).GetType().Name,
-                    this.GetStateNameForCoverageReport((sender as Machine).CurrentState));
+                    Machine.GetStateNameForLogging((sender as Machine).CurrentState));
             }
             else
             {
@@ -1504,7 +1504,7 @@ private void ReportActivityCoverageOfReceivedEvent(Machine machine, EventInfo ev
             string originState = eventInfo.OriginInfo.SenderStateName;
             string edgeLabel = eventInfo.EventType.Name;
             string destMachine = machine.GetType().Name;
-            string destState = this.GetStateNameForCoverageReport(machine.CurrentState);
+            string destState = Machine.GetStateNameForLogging(machine.CurrentState);
 
             this.CoverageInfo.AddTransition(originMachine, originState, edgeLabel, destMachine, destState);
         }
@@ -1519,12 +1519,12 @@ private void ReportActivityCoverageOfMonitorEvent(BaseMachine sender, Monitor mo
         {
             string originMachine = (sender == null) ? "Env" : sender.GetType().Name;
             string originState = (sender == null) ? "Env" :
-                (sender is Machine) ? this.GetStateNameForCoverageReport((sender as Machine).CurrentState) :
+                (sender is Machine) ? Machine.GetStateNameForLogging((sender as Machine).CurrentState) :
                 "Env";
 
             string edgeLabel = e.GetType().Name;
             string destMachine = monitor.GetType().Name;
-            string destState = this.GetStateNameForCoverageReport(monitor.CurrentState);
+            string destState = Machine.GetStateNameForLogging(monitor.CurrentState);
 
             this.CoverageInfo.AddTransition(originMachine, originState, edgeLabel, destMachine, destState);
         }
@@ -1587,31 +1587,31 @@ private void ReportActivityCoverageOfMonitor(Monitor monitor)
         private void ReportActivityCoverageOfStateTransition(Machine machine, EventInfo eventInfo)
         {
             string originMachine = machine.GetType().Name;
-            string originState = this.GetStateNameForCoverageReport(machine.CurrentState);
+            string originState = Machine.GetStateNameForLogging(machine.CurrentState);
             string destMachine = machine.GetType().Name;
 
             string edgeLabel = string.Empty;
             string destState = string.Empty;
             if (eventInfo.Event is GotoStateEvent)
             {
                 edgeLabel = "goto";
-                destState = this.GetStateNameForCoverageReport((eventInfo.Event as GotoStateEvent).State);
+                destState = Machine.GetStateNameForLogging((eventInfo.Event as GotoStateEvent).State);
             }
             else if (eventInfo.Event is PushStateEvent)
             {
                 edgeLabel = "push";
-                destState = this.GetStateNameForCoverageReport((eventInfo.Event as PushStateEvent).State);
+                destState = Machine.GetStateNameForLogging((eventInfo.Event as PushStateEvent).State);
             }
             else if (machine.GotoTransitions.ContainsKey(eventInfo.EventType))
             {
                 edgeLabel = eventInfo.EventType.Name;
-                destState = this.GetStateNameForCoverageReport(
+                destState = Machine.GetStateNameForLogging(
                     machine.GotoTransitions[eventInfo.EventType].TargetState);
             }
             else if (machine.PushTransitions.ContainsKey(eventInfo.EventType))
             {
                 edgeLabel = eventInfo.EventType.Name;
-                destState = this.GetStateNameForCoverageReport(
+                destState = Machine.GetStateNameForLogging(
                     machine.PushTransitions[eventInfo.EventType].TargetState);
             }
             else
@@ -1631,10 +1631,10 @@ private void ReportActivityCoverageOfStateTransition(Machine machine, EventInfo
         private void ReportActivityCoverageOfPopTransition(Machine machine, Type fromState, Type toState)
         {
             string originMachine = machine.GetType().Name;
-            string originState = this.GetStateNameForCoverageReport(fromState);
+            string originState = Machine.GetStateNameForLogging(fromState);
             string destMachine = machine.GetType().Name;
             string edgeLabel = "pop";
-            string destState = this.GetStateNameForCoverageReport(toState);
+            string destState = Machine.GetStateNameForLogging(toState);
 
             this.CoverageInfo.AddTransition(originMachine, originState, edgeLabel, destMachine, destState);
         }
@@ -1647,20 +1647,20 @@ private void ReportActivityCoverageOfPopTransition(Machine machine, Type fromSta
         private void ReportActivityCoverageOfMonitorTransition(Monitor monitor, Event e)
         {
             string originMachine = monitor.GetType().Name;
-            string originState = this.GetStateNameForCoverageReport(monitor.CurrentState);
+            string originState = Machine.GetStateNameForLogging(monitor.CurrentState);
             string destMachine = originMachine;
 
             string edgeLabel = string.Empty;
             string destState = string.Empty;
             if (e is GotoStateEvent)
             {
                 edgeLabel = "goto";
-                destState = this.GetStateNameForCoverageReport((e as GotoStateEvent).State);
+                destState = Machine.GetStateNameForLogging((e as GotoStateEvent).State);
             }
             else if (monitor.GotoTransitions.ContainsKey(e.GetType()))
             {
                 edgeLabel = e.GetType().Name;
-                destState = this.GetStateNameForCoverageReport(
+                destState = Machine.GetStateNameForLogging(
                     monitor.GotoTransitions[e.GetType()].TargetState);
             }
             else
@@ -1734,14 +1734,6 @@ internal Fingerprint GetProgramState()
             return fingerprint;
         }
 
-        /// <summary>
-        /// Returns the state name to be used for reporting code coverage.
-        /// </summary>
-        /// <param name="state">The machine state.</param>
-        /// <returns>The state name.</returns>
-        private string GetStateNameForCoverageReport(Type state) =>
-            state == null ? "None" : StateGroup.GetQualifiedStateName(state);
-
         #endregion
 
         #region logging
diff --git a/Tests/TestingServices.Tests.Unit/Features/OnExceptionTest.cs b/Tests/TestingServices.Tests.Unit/Features/OnExceptionTest.cs
@@ -200,7 +200,7 @@ protected override OnExceptionOutcome OnException(string method, Exception ex)
             }
         }
 
-        class Done: Event { }
+        class Done : Event { }
 
         class GetsDone : Monitor
         {
@@ -260,6 +260,27 @@ protected override void OnHalt()
             }
         }
 
+        class M6 : Machine
+        {
+            [Start]
+            class Init : MachineState { }
+
+            protected override OnExceptionOutcome OnException(string method, Exception ex)
+            {
+                try
+                {
+                    this.Assert(ex is UnhandledEventException);
+                    this.Send(this.Id, new E(this.Id));
+                    this.Raise(new E());
+                }
+                catch (Exception)
+                {
+                    this.Assert(false);
+                }
+                return OnExceptionOutcome.HandledException;
+            }
+        }
+
         [Fact]
         public void TestExceptionSuppressed1()
         {
@@ -353,5 +374,15 @@ public void TestMachineHalt2()
             AssertSucceeded(test);
         }
 
+        [Fact]
+        public void TestSendOnUnhandledEventException()
+        {
+            var test = new Action<PSharpRuntime>((r) => {
+                var m = r.CreateMachine(typeof(M6));
+                r.SendEvent(m, new E());
+            });
+
+            AssertSucceeded(test);
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -777,7 +777,7 @@ private EventInfo EnqueueEvent(Machine machine, Event e, BaseMachine sender, Gui`
`777`	`777`	`if (sender != null && sender is Machine)`
`778`	`778`	`{`
`779`	`779`	`originInfo = new EventOriginInfo(sender.Id, (sender as Machine).GetType().Name,`
`780`		`- this.GetStateNameForCoverageReport((sender as Machine).CurrentState));`
	`780`	`+ Machine.GetStateNameForLogging((sender as Machine).CurrentState));`
`781`	`781`	`}`
`782`	`782`	`else`
`783`	`783`	`{`
`@@ -1504,7 +1504,7 @@ private void ReportActivityCoverageOfReceivedEvent(Machine machine, EventInfo ev`
`1504`	`1504`	`string originState = eventInfo.OriginInfo.SenderStateName;`
`1505`	`1505`	`string edgeLabel = eventInfo.EventType.Name;`
`1506`	`1506`	`string destMachine = machine.GetType().Name;`
`1507`		`- string destState = this.GetStateNameForCoverageReport(machine.CurrentState);`
	`1507`	`+ string destState = Machine.GetStateNameForLogging(machine.CurrentState);`
`1508`	`1508`
`1509`	`1509`	`this.CoverageInfo.AddTransition(originMachine, originState, edgeLabel, destMachine, destState);`
`1510`	`1510`	`}`
`@@ -1519,12 +1519,12 @@ private void ReportActivityCoverageOfMonitorEvent(BaseMachine sender, Monitor mo`
`1519`	`1519`	`{`
`1520`	`1520`	`string originMachine = (sender == null) ? "Env" : sender.GetType().Name;`
`1521`	`1521`	`string originState = (sender == null) ? "Env" :`
`1522`		`- (sender is Machine) ? this.GetStateNameForCoverageReport((sender as Machine).CurrentState) :`
	`1522`	`+ (sender is Machine) ? Machine.GetStateNameForLogging((sender as Machine).CurrentState) :`
`1523`	`1523`	`"Env";`
`1524`	`1524`
`1525`	`1525`	`string edgeLabel = e.GetType().Name;`
`1526`	`1526`	`string destMachine = monitor.GetType().Name;`
`1527`		`- string destState = this.GetStateNameForCoverageReport(monitor.CurrentState);`
	`1527`	`+ string destState = Machine.GetStateNameForLogging(monitor.CurrentState);`
`1528`	`1528`
`1529`	`1529`	`this.CoverageInfo.AddTransition(originMachine, originState, edgeLabel, destMachine, destState);`
`1530`	`1530`	`}`
`@@ -1587,31 +1587,31 @@ private void ReportActivityCoverageOfMonitor(Monitor monitor)`
`1587`	`1587`	`private void ReportActivityCoverageOfStateTransition(Machine machine, EventInfo eventInfo)`
`1588`	`1588`	`{`
`1589`	`1589`	`string originMachine = machine.GetType().Name;`
`1590`		`- string originState = this.GetStateNameForCoverageReport(machine.CurrentState);`
	`1590`	`+ string originState = Machine.GetStateNameForLogging(machine.CurrentState);`
`1591`	`1591`	`string destMachine = machine.GetType().Name;`
`1592`	`1592`
`1593`	`1593`	`string edgeLabel = string.Empty;`
`1594`	`1594`	`string destState = string.Empty;`
`1595`	`1595`	`if (eventInfo.Event is GotoStateEvent)`
`1596`	`1596`	`{`
`1597`	`1597`	`edgeLabel = "goto";`
`1598`		`- destState = this.GetStateNameForCoverageReport((eventInfo.Event as GotoStateEvent).State);`
	`1598`	`+ destState = Machine.GetStateNameForLogging((eventInfo.Event as GotoStateEvent).State);`
`1599`	`1599`	`}`
`1600`	`1600`	`else if (eventInfo.Event is PushStateEvent)`
`1601`	`1601`	`{`
`1602`	`1602`	`edgeLabel = "push";`
`1603`		`- destState = this.GetStateNameForCoverageReport((eventInfo.Event as PushStateEvent).State);`
	`1603`	`+ destState = Machine.GetStateNameForLogging((eventInfo.Event as PushStateEvent).State);`
`1604`	`1604`	`}`
`1605`	`1605`	`else if (machine.GotoTransitions.ContainsKey(eventInfo.EventType))`
`1606`	`1606`	`{`
`1607`	`1607`	`edgeLabel = eventInfo.EventType.Name;`
`1608`		`- destState = this.GetStateNameForCoverageReport(`
	`1608`	`+ destState = Machine.GetStateNameForLogging(`
`1609`	`1609`	`machine.GotoTransitions[eventInfo.EventType].TargetState);`
`1610`	`1610`	`}`
`1611`	`1611`	`else if (machine.PushTransitions.ContainsKey(eventInfo.EventType))`
`1612`	`1612`	`{`
`1613`	`1613`	`edgeLabel = eventInfo.EventType.Name;`
`1614`		`- destState = this.GetStateNameForCoverageReport(`
	`1614`	`+ destState = Machine.GetStateNameForLogging(`
`1615`	`1615`	`machine.PushTransitions[eventInfo.EventType].TargetState);`
`1616`	`1616`	`}`
`1617`	`1617`	`else`
`@@ -1631,10 +1631,10 @@ private void ReportActivityCoverageOfStateTransition(Machine machine, EventInfo`
`1631`	`1631`	`private void ReportActivityCoverageOfPopTransition(Machine machine, Type fromState, Type toState)`
`1632`	`1632`	`{`
`1633`	`1633`	`string originMachine = machine.GetType().Name;`
`1634`		`- string originState = this.GetStateNameForCoverageReport(fromState);`
	`1634`	`+ string originState = Machine.GetStateNameForLogging(fromState);`
`1635`	`1635`	`string destMachine = machine.GetType().Name;`
`1636`	`1636`	`string edgeLabel = "pop";`
`1637`		`- string destState = this.GetStateNameForCoverageReport(toState);`
	`1637`	`+ string destState = Machine.GetStateNameForLogging(toState);`
`1638`	`1638`
`1639`	`1639`	`this.CoverageInfo.AddTransition(originMachine, originState, edgeLabel, destMachine, destState);`
`1640`	`1640`	`}`
`@@ -1647,20 +1647,20 @@ private void ReportActivityCoverageOfPopTransition(Machine machine, Type fromSta`
`1647`	`1647`	`private void ReportActivityCoverageOfMonitorTransition(Monitor monitor, Event e)`
`1648`	`1648`	`{`
`1649`	`1649`	`string originMachine = monitor.GetType().Name;`
`1650`		`- string originState = this.GetStateNameForCoverageReport(monitor.CurrentState);`
	`1650`	`+ string originState = Machine.GetStateNameForLogging(monitor.CurrentState);`
`1651`	`1651`	`string destMachine = originMachine;`
`1652`	`1652`
`1653`	`1653`	`string edgeLabel = string.Empty;`
`1654`	`1654`	`string destState = string.Empty;`
`1655`	`1655`	`if (e is GotoStateEvent)`
`1656`	`1656`	`{`
`1657`	`1657`	`edgeLabel = "goto";`
`1658`		`- destState = this.GetStateNameForCoverageReport((e as GotoStateEvent).State);`
	`1658`	`+ destState = Machine.GetStateNameForLogging((e as GotoStateEvent).State);`
`1659`	`1659`	`}`
`1660`	`1660`	`else if (monitor.GotoTransitions.ContainsKey(e.GetType()))`
`1661`	`1661`	`{`
`1662`	`1662`	`edgeLabel = e.GetType().Name;`
`1663`		`- destState = this.GetStateNameForCoverageReport(`
	`1663`	`+ destState = Machine.GetStateNameForLogging(`
`1664`	`1664`	`monitor.GotoTransitions[e.GetType()].TargetState);`
`1665`	`1665`	`}`
`1666`	`1666`	`else`
`@@ -1734,14 +1734,6 @@ internal Fingerprint GetProgramState()`
`1734`	`1734`	`return fingerprint;`
`1735`	`1735`	`}`
`1736`	`1736`
`1737`		`- /// <summary>`
`1738`		`- /// Returns the state name to be used for reporting code coverage.`
`1739`		`- /// </summary>`
`1740`		`- /// <param name="state">The machine state.</param>`
`1741`		`- /// <returns>The state name.</returns>`
`1742`		`- private string GetStateNameForCoverageReport(Type state) =>`
`1743`		`- state == null ? "None" : StateGroup.GetQualifiedStateName(state);`
`1744`		`-`
`1745`	`1737`	`#endregion`
`1746`	`1738`
`1747`	`1739`	`#region logging`
Original file line number	Diff line number	Diff line change
`@@ -200,7 +200,7 @@ protected override OnExceptionOutcome OnException(string method, Exception ex)`
`200`	`200`	`}`
`201`	`201`	`}`
`202`	`202`
`203`		`- class Done: Event { }`
	`203`	`+ class Done : Event { }`
`204`	`204`
`205`	`205`	`class GetsDone : Monitor`
`206`	`206`	`{`
`@@ -260,6 +260,27 @@ protected override void OnHalt()`
`260`	`260`	`}`
`261`	`261`	`}`
`262`	`262`
	`263`	`+ class M6 : Machine`
	`264`	`+ {`
	`265`	`+ [Start]`
	`266`	`+ class Init : MachineState { }`
	`267`	`+`
	`268`	`+ protected override OnExceptionOutcome OnException(string method, Exception ex)`
	`269`	`+ {`
	`270`	`+ try`
	`271`	`+ {`
	`272`	`+ this.Assert(ex is UnhandledEventException);`
	`273`	`+ this.Send(this.Id, new E(this.Id));`
	`274`	`+ this.Raise(new E());`
	`275`	`+ }`
	`276`	`+ catch (Exception)`
	`277`	`+ {`
	`278`	`+ this.Assert(false);`
	`279`	`+ }`
	`280`	`+ return OnExceptionOutcome.HandledException;`
	`281`	`+ }`
	`282`	`+ }`
	`283`	`+`
`263`	`284`	`[Fact]`
`264`	`285`	`public void TestExceptionSuppressed1()`
`265`	`286`	`{`
`@@ -353,5 +374,15 @@ public void TestMachineHalt2()`
`353`	`374`	`AssertSucceeded(test);`
`354`	`375`	`}`
`355`	`376`
	`377`	`+ [Fact]`
	`378`	`+ public void TestSendOnUnhandledEventException()`
	`379`	`+ {`
	`380`	`+ var test = new Action<PSharpRuntime>((r) => {`
	`381`	`+ var m = r.CreateMachine(typeof(M6));`
	`382`	`+ r.SendEvent(m, new E());`
	`383`	`+ });`
	`384`	`+`
	`385`	`+ AssertSucceeded(test);`
	`386`	`+ }`
`356`	`387`	`}`
`357`	`388`	`}`