[lldb-dap] In DAP unit tests, add helpers for loading a CoreFile.

This allows us to have a SBTarget and SBProcess for creating unit tests.

Author: ashgti

lldb/tools/lldb-dap/Protocol/ProtocolBase.h

@@ -141,6 +141,11 @@ using Message = std::variant<Request, Response, Event>;
 bool fromJSON(const llvm::json::Value &, Message &, llvm::json::Path);
 llvm::json::Value toJSON(const Message &);
 
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Message &V) {
+  OS << toJSON(V);
+  return OS;
+}
+
 /// On error (whenever `success` is false), the body can provide more details.
 struct ErrorResponseBody {
   /// A structured error message.

lldb/unittests/DAP/CMakeLists.txt

@@ -10,8 +10,16 @@ add_lldb_unittest(DAPTests
   VariablesTest.cpp
 
   LINK_LIBS
+    liblldb
     lldbDAP
+    lldbUtilityHelpers
     LLVMTestingSupport
   LINK_COMPONENTS
     Support
   )
+
+set(test_inputs
+  linux-x86_64.out
+  linux-x86_64.core
+  )
+add_unittest_inputs(DAPTests "${test_inputs}")

lldb/unittests/DAP/Handler/DisconnectTest.cpp

@@ -10,7 +10,10 @@
 #include "Handler/RequestHandler.h"
 #include "Protocol/ProtocolBase.h"
 #include "TestBase.h"
+#include "lldb/API/SBDefines.h"
+#include "lldb/lldb-enumerations.h"
 #include "llvm/Testing/Support/Error.h"
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <memory>
 #include <optional>
@@ -23,13 +26,38 @@ using namespace lldb_dap::protocol;
 
 class DisconnectRequestHandlerTest : public DAPTestBase {};
 
-TEST_F(DisconnectRequestHandlerTest, DisconnectingTriggersTerminated) {
+TEST_F(DisconnectRequestHandlerTest, DisconnectTriggersTerminated) {
   DisconnectRequestHandler handler(*dap);
   EXPECT_FALSE(dap->disconnecting);
   ASSERT_THAT_ERROR(handler.Run(std::nullopt), Succeeded());
   EXPECT_TRUE(dap->disconnecting);
   std::vector<Message> messages = DrainOutput();
   EXPECT_THAT(messages,
               testing::Contains(testing::VariantWith<Event>(testing::FieldsAre(
-                  /*event=*/"terminated", /*body=*/std::nullopt))));
+                  /*event=*/"terminated", /*body=*/testing::_))));
+}
+
+TEST_F(DisconnectRequestHandlerTest, DisconnectTriggersTerminateCommands) {
+  CreateDebugger();
+
+  if (!GetDebuggerSupportsTarget("X86"))
+    GTEST_SKIP() << "Unsupported platform";
+
+  LoadCore(DAPTestBase::k_linux_binary, DAPTestBase::k_linux_core);
+
+  DisconnectRequestHandler handler(*dap);
+
+  EXPECT_FALSE(dap->disconnecting);
+  dap->configuration.terminateCommands = {"?script print(1)",
+                                          "script print(2)"};
+  EXPECT_EQ(dap->target.GetProcess().GetState(), lldb::eStateStopped);
+  ASSERT_THAT_ERROR(handler.Run(std::nullopt), Succeeded());
+  EXPECT_TRUE(dap->disconnecting);
+  std::vector<Message> messages = DrainOutput();
+  EXPECT_THAT(messages, testing::ElementsAre(
+                            OutputMatcher("Running terminateCommands:\n"),
+                            OutputMatcher("(lldb) script print(2)\n"),
+                            OutputMatcher("2\n"),
+                            testing::VariantWith<Event>(testing::FieldsAre(
+                                /*event=*/"terminated", /*body=*/testing::_))));
 }

lldb/unittests/DAP/Inputs/linux-x86_64.core

@@ -8,9 +8,16 @@
 
 #include "TestBase.h"
 #include "Protocol/ProtocolBase.h"
+#include "TestingSupport/TestUtilities.h"
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBStructuredData.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/Pipe.h"
+#include "lldb/lldb-forward.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Testing/Support/Error.h"
+#include "gtest/gtest.h"
+#include <memory>
 
 using namespace llvm;
 using namespace lldb;
@@ -55,6 +62,43 @@ void DAPTestBase::SetUp() {
       /*transport=*/*to_dap);
 }
 
+void DAPTestBase::SetUpTestSuite() {
+  lldb::SBError error = SBDebugger::InitializeWithErrorHandling();
+  EXPECT_TRUE(error.Success());
+}
+void DAPTestBase::TeatUpTestSuite() { SBDebugger::Terminate(); }
+
+bool DAPTestBase::GetDebuggerSupportsTarget(llvm::StringRef platform) {
+  EXPECT_TRUE(dap->debugger);
+
+  lldb::SBStructuredData data = dap->debugger.GetBuildConfiguration()
+                                    .GetValueForKey("targets")
+                                    .GetValueForKey("value");
+  for (size_t i = 0; i < data.GetSize(); i++) {
+    char buf[100] = {0};
+    size_t size = data.GetItemAtIndex(i).GetStringValue(buf, sizeof(buf));
+    if (llvm::StringRef(buf, size) == platform)
+      return true;
+  }
+
+  return false;
+}
+
+void DAPTestBase::CreateDebugger() {
+  dap->debugger = lldb::SBDebugger::Create();
+  ASSERT_TRUE(dap->debugger);
+}
+
+void DAPTestBase::LoadCore(llvm::StringRef binary, llvm::StringRef core) {
+  ASSERT_TRUE(dap->debugger);
+  dap->target =
+      dap->debugger.CreateTarget(lldb_private::GetInputFilePath(binary).data());
+  ASSERT_TRUE(dap->target);
+  SBProcess process =
+      dap->target.LoadCore(lldb_private::GetInputFilePath(core).data());
+  ASSERT_TRUE(process);
+}
+
 std::vector<Message> DAPTestBase::DrainOutput() {
   std::vector<Message> msgs;
   output.CloseWriteFileDescriptor();

lldb/unittests/DAP/Inputs/linux-x86_64.out

@@ -10,6 +10,8 @@
 #include "Protocol/ProtocolBase.h"
 #include "Transport.h"
 #include "lldb/Host/Pipe.h"
+#include "llvm/ADT/StringRef.h"
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace lldb_dap_tests {
@@ -33,13 +35,30 @@ class TransportBase : public PipeBase {
   void SetUp() override;
 };
 
+/// Matches an "output" event.
+inline auto OutputMatcher(const llvm::StringRef output,
+                          const llvm::StringRef category = "console") {
+  return testing::VariantWith<lldb_dap::protocol::Event>(testing::FieldsAre(
+      /*event=*/"output", /*body=*/testing::Optional<llvm::json::Value>(
+          llvm::json::Object{{"category", category}, {"output", output}})));
+}
+
 /// A base class for tests that interact with a `lldb_dap::DAP` instance.
 class DAPTestBase : public TransportBase {
 protected:
   std::unique_ptr<lldb_dap::DAP> dap;
 
+  static constexpr llvm::StringLiteral k_linux_binary = "linux-x86_64.out";
+  static constexpr llvm::StringLiteral k_linux_core = "linux-x86_64.core";
+
+  static void SetUpTestSuite();
+  static void TeatUpTestSuite();
   void SetUp() override;
 
+  bool GetDebuggerSupportsTarget(llvm::StringRef platform);
+  void CreateDebugger();
+  void LoadCore(llvm::StringRef binary, llvm::StringRef core);
+
   /// Closes the DAP output pipe and returns the remaining protocol messages in
   /// the buffer.
   std::vector<lldb_dap::protocol::Message> DrainOutput();