blob: 97455a2275f19acc2c2d809c658fbfbe8380d7ae [file] [log] [blame]
//===-- EditlineTest.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 "lldb/Host/Config.h"
#if LLDB_ENABLE_LIBEDIT
#define EDITLINE_TEST_DUMP_OUTPUT 0
#include <stdio.h>
#include <unistd.h>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <memory>
#include <thread>
#include "TestingSupport/SubsystemRAII.h"
#include "lldb/Host/Editline.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Host/Pipe.h"
#include "lldb/Host/PseudoTerminal.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/StringList.h"
using namespace lldb_private;
namespace {
const size_t TIMEOUT_MILLIS = 5000;
}
class FilePointer {
public:
FilePointer() = delete;
FilePointer(const FilePointer &) = delete;
FilePointer(FILE *file_p) : _file_p(file_p) {}
~FilePointer() {
if (_file_p != nullptr) {
const int close_result = fclose(_file_p);
EXPECT_EQ(0, close_result);
}
}
operator FILE *() { return _file_p; }
private:
FILE *_file_p;
};
/**
Wraps an Editline class, providing a simple way to feed
input (as if from the keyboard) and receive output from Editline.
*/
class EditlineAdapter {
public:
EditlineAdapter();
void CloseInput();
bool IsValid() const { return _editline_sp != nullptr; }
lldb_private::Editline &GetEditline() { return *_editline_sp; }
bool SendLine(const std::string &line);
bool SendLines(const std::vector<std::string> &lines);
bool GetLine(std::string &line, bool &interrupted, size_t timeout_millis);
bool GetLines(lldb_private::StringList &lines, bool &interrupted,
size_t timeout_millis);
void ConsumeAllOutput();
private:
bool IsInputComplete(lldb_private::Editline *editline,
lldb_private::StringList &lines);
std::unique_ptr<lldb_private::Editline> _editline_sp;
PseudoTerminal _pty;
int _pty_primary_fd;
int _pty_secondary_fd;
std::unique_ptr<FilePointer> _el_secondary_file;
};
EditlineAdapter::EditlineAdapter()
: _editline_sp(), _pty(), _pty_primary_fd(-1), _pty_secondary_fd(-1),
_el_secondary_file() {
lldb_private::Status error;
// Open the first primary pty available.
EXPECT_THAT_ERROR(_pty.OpenFirstAvailablePrimary(O_RDWR), llvm::Succeeded());
// Grab the primary fd. This is a file descriptor we will:
// (1) write to when we want to send input to editline.
// (2) read from when we want to see what editline sends back.
_pty_primary_fd = _pty.GetPrimaryFileDescriptor();
// Open the corresponding secondary pty.
EXPECT_THAT_ERROR(_pty.OpenSecondary(O_RDWR), llvm::Succeeded());
_pty_secondary_fd = _pty.GetSecondaryFileDescriptor();
_el_secondary_file.reset(new FilePointer(fdopen(_pty_secondary_fd, "rw")));
EXPECT_FALSE(nullptr == *_el_secondary_file);
if (*_el_secondary_file == nullptr)
return;
// Create an Editline instance.
_editline_sp.reset(new lldb_private::Editline(
"gtest editor", *_el_secondary_file, *_el_secondary_file,
*_el_secondary_file, false));
_editline_sp->SetPrompt("> ");
// Hookup our input complete callback.
auto input_complete_cb = [this](Editline *editline, StringList &lines) {
return this->IsInputComplete(editline, lines);
};
_editline_sp->SetIsInputCompleteCallback(input_complete_cb);
}
void EditlineAdapter::CloseInput() {
if (_el_secondary_file != nullptr)
_el_secondary_file.reset(nullptr);
}
bool EditlineAdapter::SendLine(const std::string &line) {
// Ensure we're valid before proceeding.
if (!IsValid())
return false;
// Write the line out to the pipe connected to editline's input.
ssize_t input_bytes_written =
::write(_pty_primary_fd, line.c_str(),
line.length() * sizeof(std::string::value_type));
const char *eoln = "\n";
const size_t eoln_length = strlen(eoln);
input_bytes_written =
::write(_pty_primary_fd, eoln, eoln_length * sizeof(char));
EXPECT_NE(-1, input_bytes_written) << strerror(errno);
EXPECT_EQ(eoln_length * sizeof(char), size_t(input_bytes_written));
return eoln_length * sizeof(char) == size_t(input_bytes_written);
}
bool EditlineAdapter::SendLines(const std::vector<std::string> &lines) {
for (auto &line : lines) {
#if EDITLINE_TEST_DUMP_OUTPUT
printf("<stdin> sending line \"%s\"\n", line.c_str());
#endif
if (!SendLine(line))
return false;
}
return true;
}
// We ignore the timeout for now.
bool EditlineAdapter::GetLine(std::string &line, bool &interrupted,
size_t /* timeout_millis */) {
// Ensure we're valid before proceeding.
if (!IsValid())
return false;
_editline_sp->GetLine(line, interrupted);
return true;
}
bool EditlineAdapter::GetLines(lldb_private::StringList &lines,
bool &interrupted, size_t /* timeout_millis */) {
// Ensure we're valid before proceeding.
if (!IsValid())
return false;
_editline_sp->GetLines(1, lines, interrupted);
return true;
}
bool EditlineAdapter::IsInputComplete(lldb_private::Editline *editline,
lldb_private::StringList &lines) {
// We'll call ourselves complete if we've received a balanced set of braces.
int start_block_count = 0;
int brace_balance = 0;
for (const std::string &line : lines) {
for (auto ch : line) {
if (ch == '{') {
++start_block_count;
++brace_balance;
} else if (ch == '}')
--brace_balance;
}
}
return (start_block_count > 0) && (brace_balance == 0);
}
void EditlineAdapter::ConsumeAllOutput() {
FilePointer output_file(fdopen(_pty_primary_fd, "r"));
int ch;
while ((ch = fgetc(output_file)) != EOF) {
#if EDITLINE_TEST_DUMP_OUTPUT
char display_str[] = {0, 0, 0};
switch (ch) {
case '\t':
display_str[0] = '\\';
display_str[1] = 't';
break;
case '\n':
display_str[0] = '\\';
display_str[1] = 'n';
break;
case '\r':
display_str[0] = '\\';
display_str[1] = 'r';
break;
default:
display_str[0] = ch;
break;
}
printf("<stdout> 0x%02x (%03d) (%s)\n", ch, ch, display_str);
// putc(ch, stdout);
#endif
}
}
class EditlineTestFixture : public ::testing::Test {
SubsystemRAII<FileSystem> subsystems;
EditlineAdapter _el_adapter;
std::shared_ptr<std::thread> _sp_output_thread;
public:
static void SetUpTestCase() {
// We need a TERM set properly for editline to work as expected.
setenv("TERM", "vt100", 1);
}
void SetUp() override {
// Validate the editline adapter.
EXPECT_TRUE(_el_adapter.IsValid());
if (!_el_adapter.IsValid())
return;
// Dump output.
_sp_output_thread =
std::make_shared<std::thread>([&] { _el_adapter.ConsumeAllOutput(); });
}
void TearDown() override {
_el_adapter.CloseInput();
if (_sp_output_thread)
_sp_output_thread->join();
}
EditlineAdapter &GetEditlineAdapter() { return _el_adapter; }
};
TEST_F(EditlineTestFixture, EditlineReceivesSingleLineText) {
// Send it some text via our virtual keyboard.
const std::string input_text("Hello, world");
EXPECT_TRUE(GetEditlineAdapter().SendLine(input_text));
// Verify editline sees what we put in.
std::string el_reported_line;
bool input_interrupted = false;
const bool received_line = GetEditlineAdapter().GetLine(
el_reported_line, input_interrupted, TIMEOUT_MILLIS);
EXPECT_TRUE(received_line);
EXPECT_FALSE(input_interrupted);
EXPECT_EQ(input_text, el_reported_line);
}
TEST_F(EditlineTestFixture, EditlineReceivesMultiLineText) {
// Send it some text via our virtual keyboard.
std::vector<std::string> input_lines;
input_lines.push_back("int foo()");
input_lines.push_back("{");
input_lines.push_back("printf(\"Hello, world\");");
input_lines.push_back("}");
input_lines.push_back("");
EXPECT_TRUE(GetEditlineAdapter().SendLines(input_lines));
// Verify editline sees what we put in.
lldb_private::StringList el_reported_lines;
bool input_interrupted = false;
EXPECT_TRUE(GetEditlineAdapter().GetLines(el_reported_lines,
input_interrupted, TIMEOUT_MILLIS));
EXPECT_FALSE(input_interrupted);
// Without any auto indentation support, our output should directly match our
// input.
std::vector<std::string> reported_lines;
for (const std::string &line : el_reported_lines)
reported_lines.push_back(line);
EXPECT_THAT(reported_lines, testing::ContainerEq(input_lines));
}
#endif