mirror of
https://github.com/intel/llvm.git
synced 2026-01-13 19:08:21 +08:00
8ae30a3fac
This adds a new Binding helper class to allow mapping of incoming and outgoing requests / events to specific handlers. This should make it easier to create new protocol implementations and allow us to create a relay in the lldb-mcp binary.
138 lines
4.7 KiB
C++
138 lines
4.7 KiB
C++
//===-- TestBase.cpp ------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "TestBase.h"
|
|
#include "DAPLog.h"
|
|
#include "TestingSupport/TestUtilities.h"
|
|
#include "lldb/API/SBDefines.h"
|
|
#include "lldb/API/SBStructuredData.h"
|
|
#include "lldb/Host/MainLoop.h"
|
|
#include "lldb/Host/Pipe.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/Support/Error.h"
|
|
#include "llvm/Testing/Support/Error.h"
|
|
#include "gtest/gtest.h"
|
|
#include <cstdio>
|
|
#include <memory>
|
|
#include <system_error>
|
|
|
|
using namespace llvm;
|
|
using namespace lldb;
|
|
using namespace lldb_dap;
|
|
using namespace lldb_dap::protocol;
|
|
using namespace lldb_dap_tests;
|
|
using lldb_private::File;
|
|
using lldb_private::FileSpec;
|
|
using lldb_private::FileSystem;
|
|
using lldb_private::MainLoop;
|
|
using lldb_private::Pipe;
|
|
|
|
void TransportBase::SetUp() {
|
|
std::tie(to_client, to_server) = TestDAPTransport::createPair();
|
|
|
|
std::error_code EC;
|
|
log = std::make_unique<Log>("-", EC);
|
|
dap = std::make_unique<DAP>(
|
|
/*log=*/log.get(),
|
|
/*default_repl_mode=*/ReplMode::Auto,
|
|
/*pre_init_commands=*/std::vector<std::string>(),
|
|
/*no_lldbinit=*/false,
|
|
/*client_name=*/"test_client",
|
|
/*transport=*/*to_client, /*loop=*/loop);
|
|
|
|
auto server_handle = to_server->RegisterMessageHandler(loop, *dap.get());
|
|
EXPECT_THAT_EXPECTED(server_handle, Succeeded());
|
|
handles[0] = std::move(*server_handle);
|
|
|
|
auto client_handle = to_client->RegisterMessageHandler(loop, client);
|
|
EXPECT_THAT_EXPECTED(client_handle, Succeeded());
|
|
handles[1] = std::move(*client_handle);
|
|
}
|
|
|
|
void TransportBase::Run() {
|
|
loop.AddPendingCallback(
|
|
[](lldb_private::MainLoopBase &loop) { loop.RequestTermination(); });
|
|
EXPECT_THAT_ERROR(loop.Run().takeError(), llvm::Succeeded());
|
|
}
|
|
|
|
void DAPTestBase::SetUp() { TransportBase::SetUp(); }
|
|
|
|
void DAPTestBase::TearDown() {
|
|
if (core)
|
|
ASSERT_THAT_ERROR(core->discard(), Succeeded());
|
|
if (binary)
|
|
ASSERT_THAT_ERROR(binary->discard(), Succeeded());
|
|
}
|
|
|
|
void DAPTestBase::SetUpTestSuite() {
|
|
lldb::SBError error = SBDebugger::InitializeWithErrorHandling();
|
|
EXPECT_TRUE(error.Success());
|
|
}
|
|
void DAPTestBase::TeatUpTestSuite() { SBDebugger::Terminate(); }
|
|
|
|
bool DAPTestBase::GetDebuggerSupportsTarget(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 (StringRef(buf, size) == platform)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void DAPTestBase::CreateDebugger() {
|
|
dap->debugger = lldb::SBDebugger::Create();
|
|
ASSERT_TRUE(dap->debugger);
|
|
dap->target = dap->debugger.GetDummyTarget();
|
|
|
|
Expected<lldb::FileUP> dev_null = FileSystem::Instance().Open(
|
|
FileSpec(FileSystem::DEV_NULL), File::eOpenOptionReadWrite);
|
|
ASSERT_THAT_EXPECTED(dev_null, Succeeded());
|
|
lldb::FileSP dev_null_sp = std::move(*dev_null);
|
|
|
|
std::FILE *dev_null_stream = dev_null_sp->GetStream();
|
|
ASSERT_THAT_ERROR(dap->ConfigureIO(dev_null_stream, dev_null_stream),
|
|
Succeeded());
|
|
|
|
dap->debugger.SetInputFile(dap->in);
|
|
auto out_fd = dap->out.GetWriteFileDescriptor();
|
|
ASSERT_THAT_EXPECTED(out_fd, Succeeded());
|
|
dap->debugger.SetOutputFile(lldb::SBFile(*out_fd, "w", false));
|
|
auto err_fd = dap->out.GetWriteFileDescriptor();
|
|
ASSERT_THAT_EXPECTED(err_fd, Succeeded());
|
|
dap->debugger.SetErrorFile(lldb::SBFile(*err_fd, "w", false));
|
|
}
|
|
|
|
void DAPTestBase::LoadCore() {
|
|
ASSERT_TRUE(dap->debugger);
|
|
llvm::Expected<lldb_private::TestFile> binary_yaml =
|
|
lldb_private::TestFile::fromYamlFile(k_linux_binary);
|
|
ASSERT_THAT_EXPECTED(binary_yaml, Succeeded());
|
|
llvm::Expected<llvm::sys::fs::TempFile> binary_file =
|
|
binary_yaml->writeToTemporaryFile();
|
|
ASSERT_THAT_EXPECTED(binary_file, Succeeded());
|
|
binary = std::move(*binary_file);
|
|
dap->target = dap->debugger.CreateTarget(binary->TmpName.data());
|
|
ASSERT_TRUE(dap->target);
|
|
llvm::Expected<lldb_private::TestFile> core_yaml =
|
|
lldb_private::TestFile::fromYamlFile(k_linux_core);
|
|
ASSERT_THAT_EXPECTED(core_yaml, Succeeded());
|
|
llvm::Expected<llvm::sys::fs::TempFile> core_file =
|
|
core_yaml->writeToTemporaryFile();
|
|
ASSERT_THAT_EXPECTED(core_file, Succeeded());
|
|
this->core = std::move(*core_file);
|
|
SBProcess process = dap->target.LoadCore(this->core->TmpName.data());
|
|
ASSERT_TRUE(process);
|
|
}
|