Revise VSCode protocol events parsing.

diff --git a/test-suite/NetcoreDbgTest/VSCode/VSCodeDebugger.cs b/test-suite/NetcoreDbgTest/VSCode/VSCodeDebugger.cs
index a25cc304ca789daf813d7f39ad3f75a1f20c4e37..65bdadd277f0eae06633637ab9ea3b4bbf181cf8 100644 (file)
--- a/test-suite/NetcoreDbgTest/VSCode/VSCodeDebugger.cs
+++ b/test-suite/NetcoreDbgTest/VSCode/VSCodeDebugger.cs
@@ -54,7 +54,6 @@ namespace NetcoreDbgTest.VSCode
         }
         public VSCodeResult Request(Request command, int timeout = -1)
         {
-            EventsAddedOnLastRequestPos = -1;
             string stringJSON = JsonConvert.SerializeObject(command,
                                                             Formatting.None,
                                                             new JsonSerializerSettings { 
@@ -80,22 +79,13 @@ namespace NetcoreDbgTest.VSCode
                     return new VSCodeResult((bool)GetResponsePropertyValue(line, "success"), line);
                 } else {
                     Logger.LogLine("<- (E) " + line);
-                    if (EventsAddedOnLastRequestPos == -1) {
-                        EventsAddedOnLastRequestPos = EventList.Count;
-                    }
-                    EventList.Add(line);
+                    EventQueue.Enqueue(line);
                 }
             }
         }
 
-        public string Receive(int timeout = -1)
+        void ReceiveEvents(int timeout = -1)
         {
-            if (EventsAddedOnLastRequestPos != -1 && EventsAddedOnLastRequestPos < EventList.Count) {
-                string line = EventList[EventsAddedOnLastRequestPos];
-                EventsAddedOnLastRequestPos++;
-                return line;
-            }
-
             while (true) {
                 string[] response = Debuggee.DebuggerClient.Receive(timeout);
                 if (response == null) {
@@ -104,18 +94,35 @@ namespace NetcoreDbgTest.VSCode
                 string line = response[0];
 
                 Logger.LogLine("<- (E) " + line);
-                EventList.Add(line);
+                EventQueue.Enqueue(line);
 
                 foreach (var Event in StopEvents) {
                     if (isResponseContainProperty(line, "event", Event)) {
-                        return line;
+                        return;
                     }
                 }
             }
         }
 
-        public List<string> EventList = new List<string>();
-        int EventsAddedOnLastRequestPos = -1;
+        public bool IsEventReceived(Func<string, bool> filter)
+        {
+            // check previously received events first
+            while (EventQueue.Count > 0) {
+                if (filter(EventQueue.Dequeue()))
+                    return true;
+            }
+
+            // receive new events and check them
+            ReceiveEvents();
+            while (EventQueue.Count > 0) {
+                if (filter(EventQueue.Dequeue()))
+                    return true;
+            }
+
+            return false;
+        }
+
+        Queue<string> EventQueue = new Queue<string>();
         string[] StopEvents = {"stopped",
                                "terminated"};
     }

diff --git a/test-suite/NetcoreDbgTest/VSCode/VSCodeProtocolEvent.cs b/test-suite/NetcoreDbgTest/VSCode/VSCodeProtocolEvent.cs
index 136e9310535315f80dcdfca6a123c47ee92826eb..2d50059aa016e2531664b33c61f3a9e3f148f3f7 100644 (file)
--- a/test-suite/NetcoreDbgTest/VSCode/VSCodeProtocolEvent.cs
+++ b/test-suite/NetcoreDbgTest/VSCode/VSCodeProtocolEvent.cs
@@ -27,4 +27,12 @@ namespace NetcoreDbgTest.VSCode
         public string text;
         public bool ?allThreadsStopped;
     }
+
+    public class ExitedEvent : Event {
+        public ExitedEventBody body;
+    }
+
+    public class ExitedEventBody {
+        public int exitCode;
+    }
 }

diff --git a/test-suite/VSCodeExampleTest/Program.cs b/test-suite/VSCodeExampleTest/Program.cs
index 70ea8593f1e391f0c2c2ce027da01d363526c683..437ee5a9a31b106dd77c4e748e78aba5d45e0600 100644 (file)
--- a/test-suite/VSCodeExampleTest/Program.cs
+++ b/test-suite/VSCodeExampleTest/Program.cs
@@ -52,23 +52,42 @@ namespace NetcoreDbgTest.Script
 
         public static void WasEntryPointHit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "entry")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
-                    break;
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void WasExit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated"));
+            bool wasExited = false;
+            int ?exitCode = null;
+            bool wasTerminated = false;
+
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "exited")) {
+                    wasExited = true;
+                    ExitedEvent exitedEvent = JsonConvert.DeserializeObject<ExitedEvent>(resJSON);
+                    exitCode = exitedEvent.body.exitCode;
+                }
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated")) {
+                    wasTerminated = true;
+                }
+                if (wasExited && exitCode == 0 && wasTerminated)
+                    return true;
+
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void DebuggerExit()
@@ -104,16 +123,17 @@ namespace NetcoreDbgTest.Script
 
         public static void WasBreakpointHit(Breakpoint breakpoint)
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "breakpoint")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
 
             StackTraceRequest stackTraceRequest = new StackTraceRequest();
             stackTraceRequest.arguments.threadId = threadId;

diff --git a/test-suite/VSCodeTestAttach/Program.cs b/test-suite/VSCodeTestAttach/Program.cs
index 63cb5d542bab98c3e7fdd5b8095a6f5fe2d95ffe..b515206c5807c3462412d84a7129ebda5270c7ad 100644 (file)
--- a/test-suite/VSCodeTestAttach/Program.cs
+++ b/test-suite/VSCodeTestAttach/Program.cs
@@ -49,8 +49,27 @@ namespace NetcoreDbgTest.Script
 
         public static void WasExit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated"));
+            bool wasExited = false;
+            int ?exitCode = null;
+            bool wasTerminated = false;
+
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "exited")) {
+                    wasExited = true;
+                    ExitedEvent exitedEvent = JsonConvert.DeserializeObject<ExitedEvent>(resJSON);
+                    exitCode = exitedEvent.body.exitCode;
+                }
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated")) {
+                    wasTerminated = true;
+                }
+                if (wasExited && exitCode == 0 && wasTerminated)
+                    return true;
+
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void DebuggerExit()
@@ -86,16 +105,17 @@ namespace NetcoreDbgTest.Script
 
         public static void WasBreakpointHit(Breakpoint breakpoint)
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "breakpoint")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
 
             StackTraceRequest stackTraceRequest = new StackTraceRequest();
             stackTraceRequest.arguments.threadId = threadId;

diff --git a/test-suite/VSCodeTestBreakpoint/Program.cs b/test-suite/VSCodeTestBreakpoint/Program.cs
index 2e17ae3530ec9a56e48aa0d7702df74028674035..3663008919d5c0c6cbc2974404483098680a73d7 100644 (file)
--- a/test-suite/VSCodeTestBreakpoint/Program.cs
+++ b/test-suite/VSCodeTestBreakpoint/Program.cs
@@ -50,23 +50,42 @@ namespace NetcoreDbgTest.Script
 
         public static void WasEntryPointHit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "entry")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
-                    break;
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void WasExit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated"));
+            bool wasExited = false;
+            int ?exitCode = null;
+            bool wasTerminated = false;
+
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "exited")) {
+                    wasExited = true;
+                    ExitedEvent exitedEvent = JsonConvert.DeserializeObject<ExitedEvent>(resJSON);
+                    exitCode = exitedEvent.body.exitCode;
+                }
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated")) {
+                    wasTerminated = true;
+                }
+                if (wasExited && exitCode == 0 && wasTerminated)
+                    return true;
+
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void DebuggerExit()
@@ -112,16 +131,17 @@ namespace NetcoreDbgTest.Script
 
         public static void WasBreakpointHit(Breakpoint breakpoint)
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "breakpoint")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
 
             StackTraceRequest stackTraceRequest = new StackTraceRequest();
             stackTraceRequest.arguments.threadId = threadId;

diff --git a/test-suite/VSCodeTestDisconnect/Program.cs b/test-suite/VSCodeTestDisconnect/Program.cs
index daf47aa1e2e5a703ee2b1d8154b0ff26ffdb523e..48a6c085610aec0479da87f11107793884d16247 100644 (file)
--- a/test-suite/VSCodeTestDisconnect/Program.cs
+++ b/test-suite/VSCodeTestDisconnect/Program.cs
@@ -50,17 +50,17 @@ namespace NetcoreDbgTest.Script
 
         public static void WasEntryPointHit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "entry")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
-                    break;
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void Continue()
@@ -96,16 +96,26 @@ namespace NetcoreDbgTest.Script
         public static void WasExit()
         {
             bool wasExited = false;
+            int ?exitCode = null;
             bool wasTerminated = false;
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "exited")) {
+
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "exited")) {
                     wasExited = true;
+                    ExitedEvent exitedEvent = JsonConvert.DeserializeObject<ExitedEvent>(resJSON);
+                    exitCode = exitedEvent.body.exitCode;
                 }
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "terminated")) {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated")) {
                     wasTerminated = true;
                 }
-            }
-            Assert.True(wasExited && wasTerminated);
+                if (wasExited && exitCode == 0 && wasTerminated)
+                    return true;
+
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void DebuggerExit()

diff --git a/test-suite/VSCodeTestEvaluate/Program.cs b/test-suite/VSCodeTestEvaluate/Program.cs
index c10d678f1764fb610093649a86d22166ba6c2245..1540d5de66f37943421d8ac9dc551da8e2db7ee3 100644 (file)
--- a/test-suite/VSCodeTestEvaluate/Program.cs
+++ b/test-suite/VSCodeTestEvaluate/Program.cs
@@ -50,23 +50,42 @@ namespace NetcoreDbgTest.Script
 
         public static void WasEntryPointHit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "entry")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
-                    break;
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void WasExit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated"));
+            bool wasExited = false;
+            int ?exitCode = null;
+            bool wasTerminated = false;
+
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "exited")) {
+                    wasExited = true;
+                    ExitedEvent exitedEvent = JsonConvert.DeserializeObject<ExitedEvent>(resJSON);
+                    exitCode = exitedEvent.body.exitCode;
+                }
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated")) {
+                    wasTerminated = true;
+                }
+                if (wasExited && exitCode == 0 && wasTerminated)
+                    return true;
+
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void DebuggerExit()
@@ -102,16 +121,17 @@ namespace NetcoreDbgTest.Script
 
         public static void WasBreakpointHit(Breakpoint breakpoint)
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "breakpoint")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
 
             StackTraceRequest stackTraceRequest = new StackTraceRequest();
             stackTraceRequest.arguments.threadId = threadId;

diff --git a/test-suite/VSCodeTestFuncBreak/Program.cs b/test-suite/VSCodeTestFuncBreak/Program.cs
index da9bf38ded325593a771250960968cc335ee983e..e66af304df75e31df17dd3f80c171e5ca814ef66 100644 (file)
--- a/test-suite/VSCodeTestFuncBreak/Program.cs
+++ b/test-suite/VSCodeTestFuncBreak/Program.cs
@@ -50,23 +50,42 @@ namespace NetcoreDbgTest.Script
 
         public static void WasEntryPointHit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "entry")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
-                    break;
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void WasExit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated"));
+            bool wasExited = false;
+            int ?exitCode = null;
+            bool wasTerminated = false;
+
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "exited")) {
+                    wasExited = true;
+                    ExitedEvent exitedEvent = JsonConvert.DeserializeObject<ExitedEvent>(resJSON);
+                    exitCode = exitedEvent.body.exitCode;
+                }
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated")) {
+                    wasTerminated = true;
+                }
+                if (wasExited && exitCode == 0 && wasTerminated)
+                    return true;
+
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void DebuggerExit()
@@ -96,16 +115,17 @@ namespace NetcoreDbgTest.Script
 
         public static void WasBreakpointHit(Breakpoint breakpoint)
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "breakpoint")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
 
             StackTraceRequest stackTraceRequest = new StackTraceRequest();
             stackTraceRequest.arguments.threadId = threadId;

diff --git a/test-suite/VSCodeTestPause/Program.cs b/test-suite/VSCodeTestPause/Program.cs
index f7433fd41c0eded19951eed9f4fb3e4cd8a56000..9f0a8ffe8e529bfe725b9f29442e7a5b5827c38a 100644 (file)
--- a/test-suite/VSCodeTestPause/Program.cs
+++ b/test-suite/VSCodeTestPause/Program.cs
@@ -46,23 +46,42 @@ namespace NetcoreDbgTest.Script
 
         public static void WasEntryPointHit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "entry")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
-                    break;
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void WasExit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated"));
+            bool wasExited = false;
+            int ?exitCode = null;
+            bool wasTerminated = false;
+
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "exited")) {
+                    wasExited = true;
+                    ExitedEvent exitedEvent = JsonConvert.DeserializeObject<ExitedEvent>(resJSON);
+                    exitCode = exitedEvent.body.exitCode;
+                }
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated")) {
+                    wasTerminated = true;
+                }
+                if (wasExited && exitCode == 0 && wasTerminated)
+                    return true;
+
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void DebuggerExit()
@@ -89,13 +108,16 @@ namespace NetcoreDbgTest.Script
 
         public static void WasPaused()
         {
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "pause")) {
-                    return;
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "pause")) {
+                    return true;
                 }
-            }
-            throw new NetcoreDbgTestCore.ResultNotSuccessException();
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         static VSCodeDebugger VSCodeDebugger = new VSCodeDebugger();

diff --git a/test-suite/VSCodeTestStepping/Program.cs b/test-suite/VSCodeTestStepping/Program.cs
index 8bf83228d748cdf4bdc0c663969b640ce2726a7f..95c4ba5f50b12a673725f92262d6e6395c7ebd26 100644 (file)
--- a/test-suite/VSCodeTestStepping/Program.cs
+++ b/test-suite/VSCodeTestStepping/Program.cs
@@ -50,23 +50,42 @@ namespace NetcoreDbgTest.Script
 
         public static void WasEntryPointHit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "entry")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
-                    break;
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void WasExit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated"));
+            bool wasExited = false;
+            int ?exitCode = null;
+            bool wasTerminated = false;
+
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "exited")) {
+                    wasExited = true;
+                    ExitedEvent exitedEvent = JsonConvert.DeserializeObject<ExitedEvent>(resJSON);
+                    exitCode = exitedEvent.body.exitCode;
+                }
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated")) {
+                    wasTerminated = true;
+                }
+                if (wasExited && exitCode == 0 && wasTerminated)
+                    return true;
+
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void DebuggerExit()
@@ -102,16 +121,19 @@ namespace NetcoreDbgTest.Script
 
         public static void WasStopped(string Reason, Breakpoint breakpoint)
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", Reason));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "breakpoint")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", Reason)) {
+                    if (Reason == "breakpoint")
+                        threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
 
             StackTraceRequest stackTraceRequest = new StackTraceRequest();
             stackTraceRequest.arguments.threadId = threadId;

diff --git a/test-suite/VSCodeTestThreads/Program.cs b/test-suite/VSCodeTestThreads/Program.cs
index 92db54a4bd33a640aed0c7fdb287d2ca8da3aa6e..5c5a517babdc67317c75495753a596f7a68162b1 100644 (file)
--- a/test-suite/VSCodeTestThreads/Program.cs
+++ b/test-suite/VSCodeTestThreads/Program.cs
@@ -50,27 +50,47 @@ namespace NetcoreDbgTest.Script
             Assert.True(VSCodeDebugger.Request(configurationDoneRequest).Success);
         }
 
-        public static void WasEntryPointHit()
+        public static void WasEntryPointHitWithProperThreadID()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry"));
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
+                }
+                return false;
+            };
 
             threadId = -1;
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "entry")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
-                    break;
-                }
-            }
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
+
             Assert.True(isThredInThreadsList(threadId));
         }
 
         public static void WasExit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated"));
+            bool wasExited = false;
+            int ?exitCode = null;
+            bool wasTerminated = false;
+
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "exited")) {
+                    wasExited = true;
+                    ExitedEvent exitedEvent = JsonConvert.DeserializeObject<ExitedEvent>(resJSON);
+                    exitCode = exitedEvent.body.exitCode;
+                }
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated")) {
+                    wasTerminated = true;
+                }
+                if (wasExited && exitCode == 0 && wasTerminated)
+                    return true;
+
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void DebuggerExit()
@@ -104,19 +124,21 @@ namespace NetcoreDbgTest.Script
             Assert.True(VSCodeDebugger.Request(setBreakpointsRequest).Success);
         }
 
-        public static void WasBreakpointHit(Breakpoint breakpoint)
+        public static void WasBreakpointHitWithProperThreadID(Breakpoint breakpoint)
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint"));
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
+                }
+                return false;
+            };
 
             threadId = -1;
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "breakpoint")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
-                }
-            }
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
+
             Assert.True(isThredInThreadsList(threadId));
 
             StackTraceRequest stackTraceRequest = new StackTraceRequest();
@@ -191,14 +213,14 @@ namespace VSCodeTestThreads
                 Context.AddBreakpoint("bp");
                 Context.SetBreakpoints();
                 Context.PrepareEnd();
-                Context.WasEntryPointHit();
+                Context.WasEntryPointHitWithProperThreadID();
                 Context.Continue();
             });
 
             Console.WriteLine("A breakpoint \"bp\" is set on this line"); Label.Breakpoint("bp");
 
             Label.Checkpoint("bp_test", "finish", () => {
-                Context.WasBreakpointHit(DebuggeeInfo.Breakpoints["bp"]);
+                Context.WasBreakpointHitWithProperThreadID(DebuggeeInfo.Breakpoints["bp"]);
                 Context.Continue();
             });
 

diff --git a/test-suite/VSCodeTestVariables/Program.cs b/test-suite/VSCodeTestVariables/Program.cs
index 99892484cf375de8c2a046bccda68e318765ef42..1e079a67afa36e155e2d55758fdcd162cf3d205a 100644 (file)
--- a/test-suite/VSCodeTestVariables/Program.cs
+++ b/test-suite/VSCodeTestVariables/Program.cs
@@ -50,23 +50,42 @@ namespace NetcoreDbgTest.Script
 
         public static void WasEntryPointHit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "entry")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
-                    break;
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "entry")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void WasExit()
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated"));
+            bool wasExited = false;
+            int ?exitCode = null;
+            bool wasTerminated = false;
+
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "exited")) {
+                    wasExited = true;
+                    ExitedEvent exitedEvent = JsonConvert.DeserializeObject<ExitedEvent>(resJSON);
+                    exitCode = exitedEvent.body.exitCode;
+                }
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "terminated")) {
+                    wasTerminated = true;
+                }
+                if (wasExited && exitCode == 0 && wasTerminated)
+                    return true;
+
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
         }
 
         public static void DebuggerExit()
@@ -102,16 +121,17 @@ namespace NetcoreDbgTest.Script
 
         public static void WasBreakpointHit(Breakpoint breakpoint)
         {
-            string resJSON = VSCodeDebugger.Receive(-1);
-            Assert.True(VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
-                        && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint"));
-
-            foreach (var Event in VSCodeDebugger.EventList) {
-                if (VSCodeDebugger.isResponseContainProperty(Event, "event", "stopped")
-                    && VSCodeDebugger.isResponseContainProperty(Event, "reason", "breakpoint")) {
-                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(Event, "threadId"));
+            Func<string, bool> filter = (resJSON) => {
+                if (VSCodeDebugger.isResponseContainProperty(resJSON, "event", "stopped")
+                    && VSCodeDebugger.isResponseContainProperty(resJSON, "reason", "breakpoint")) {
+                    threadId = Convert.ToInt32(VSCodeDebugger.GetResponsePropertyValue(resJSON, "threadId"));
+                    return true;
                 }
-            }
+                return false;
+            };
+
+            if (!VSCodeDebugger.IsEventReceived(filter))
+                throw new NetcoreDbgTestCore.ResultNotSuccessException();
 
             StackTraceRequest stackTraceRequest = new StackTraceRequest();
             stackTraceRequest.arguments.threadId = threadId;