From: Mikhail Kurinnoi <m.kurinnoi@samsung.net>
Date: Wed, 9 Oct 2019 16:26:17 +0000 (+0300)
Subject: Revise VSCode protocol events parsing.
X-Git-Tag: submit/tizen/20191010.235421~2
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=5a86a61e6f611441cb60a7124c0b6f0f32d0c35c;p=sdk%2Ftools%2Fnetcoredbg.git

Revise VSCode protocol events parsing.
---

diff --git a/test-suite/NetcoreDbgTest/VSCode/VSCodeDebugger.cs b/test-suite/NetcoreDbgTest/VSCode/VSCodeDebugger.cs
index a25cc30..65bdadd 100644
--- 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 136e931..2d50059 100644
--- 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 70ea859..437ee5a 100644
--- 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 63cb5d5..b515206 100644
--- 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 2e17ae3..3663008 100644
--- 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 daf47aa..48a6c08 100644
--- 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 c10d678..1540d5d 100644
--- 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 da9bf38..e66af30 100644
--- 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 f7433fd..9f0a8ff 100644
--- 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 8bf8322..95c4ba5 100644
--- 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 92db54a..5c5a517 100644
--- 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 9989248..1e079a6 100644
--- 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;