Debian Codegraph @

lldb/unittests/Editline/EditlineTest.cpp

raw
1 //===-- EditlineTest.cpp --------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "lldb/Host/Config.h"
10 #include "lldb/Host/File.h"
11
12 #if LLDB_ENABLE_LIBEDIT
13
14 #define EDITLINE_TEST_DUMP_OUTPUT 0
15
16 #include <stdio.h>
17 #include <unistd.h>
18
19 #include "gmock/gmock.h"
20 #include "gtest/gtest.h"
21 #include <memory>
22 #include <thread>
23
24 #include "TestingSupport/SubsystemRAII.h"
25 #include "lldb/Host/Editline.h"
26 #include "lldb/Host/FileSystem.h"
27 #include "lldb/Host/Pipe.h"
28 #include "lldb/Host/PseudoTerminal.h"
29 #include "lldb/Host/StreamFile.h"
30 #include "lldb/Utility/Status.h"
31 #include "lldb/Utility/StringList.h"
32
33 using namespace lldb_private;
34
35 namespace {
36 const size_t TIMEOUT_MILLIS = 5000;
37 }
38
39 class FilePointer {
40 public:
41 FilePointer() = delete;
42
43 FilePointer(const FilePointer &) = delete;
44
45 FilePointer(FILE *file_p) : _file_p(file_p) {}
46
47 ~FilePointer() {
48 if (_file_p != nullptr) {
49 const int close_result = fclose(_file_p);
50 EXPECT_EQ(0, close_result);
51 }
52 }
53
54 operator FILE *() { return _file_p; }
55
56 private:
57 FILE *_file_p;
58 };
59
60 /**
61 Wraps an Editline class, providing a simple way to feed
62 input (as if from the keyboard) and receive output from Editline.
63 */
64 class EditlineAdapter {
65 public:
66 EditlineAdapter();
67
68 void CloseInput();
69
70 bool IsValid() const { return _editline_sp != nullptr; }
71
72 lldb_private::Editline &GetEditline() { return *_editline_sp; }
73
74 bool SendLine(const std::string &line);
75
76 bool SendLines(const std::vector<std::string> &lines);
77
78 bool GetLine(std::string &line, bool &interrupted, size_t timeout_millis);
79
80 bool GetLines(lldb_private::StringList &lines, bool &interrupted,
81 size_t timeout_millis);
82
83 void ConsumeAllOutput();
84
85 private:
86 bool IsInputComplete(lldb_private::Editline *editline,
87 lldb_private::StringList &lines);
88
89 std::recursive_mutex output_mutex;
90 std::unique_ptr<lldb_private::Editline> _editline_sp;
91
92 PseudoTerminal _pty;
93 int _pty_primary_fd = -1;
94 int _pty_secondary_fd = -1;
95
96 std::unique_ptr<FilePointer> _el_secondary_file;
97 };
98
99 EditlineAdapter::EditlineAdapter()
100 : _editline_sp(), _pty(), _el_secondary_file() {
101 lldb_private::Status error;
102
103 // Open the first primary pty available.
104 EXPECT_THAT_ERROR(_pty.OpenFirstAvailablePrimary(O_RDWR), llvm::Succeeded());
105
106 // Grab the primary fd. This is a file descriptor we will:
107 // (1) write to when we want to send input to editline.
108 // (2) read from when we want to see what editline sends back.
109 _pty_primary_fd = _pty.GetPrimaryFileDescriptor();
110
111 // Open the corresponding secondary pty.
112 EXPECT_THAT_ERROR(_pty.OpenSecondary(O_RDWR), llvm::Succeeded());
113 _pty_secondary_fd = _pty.GetSecondaryFileDescriptor();
114
115 _el_secondary_file.reset(new FilePointer(fdopen(_pty_secondary_fd, "rw")));
116 EXPECT_FALSE(nullptr == *_el_secondary_file);
117 if (*_el_secondary_file == nullptr)
118 return;
119
120 lldb::LockableStreamFileSP output_stream_sp =
121 std::make_shared<LockableStreamFile>(*_el_secondary_file,
122 NativeFile::Unowned, output_mutex);
123 lldb::LockableStreamFileSP error_stream_sp =
124 std::make_shared<LockableStreamFile>(*_el_secondary_file,
125 NativeFile::Unowned, output_mutex);
126
127 // Create an Editline instance.
128 _editline_sp.reset(new lldb_private::Editline(
129 "gtest editor", *_el_secondary_file, output_stream_sp, error_stream_sp,
130 /*color=*/false));
131 _editline_sp->SetPrompt("> ");
132
133 // Hookup our input complete callback.
134 auto input_complete_cb = [this](Editline *editline, StringList &lines) {
135 return this->IsInputComplete(editline, lines);
136 };
137 _editline_sp->SetIsInputCompleteCallback(input_complete_cb);
138 }
139
140 void EditlineAdapter::CloseInput() {
141 if (_el_secondary_file != nullptr)
142 _el_secondary_file.reset(nullptr);
143 }
144
145 bool EditlineAdapter::SendLine(const std::string &line) {
146 // Ensure we're valid before proceeding.
147 if (!IsValid())
148 return false;
149
150 // Write the line out to the pipe connected to editline's input.
151 ssize_t input_bytes_written =
152 ::write(_pty_primary_fd, line.c_str(),
153 line.length() * sizeof(std::string::value_type));
154
155 const char *eoln = "\n";
156 const size_t eoln_length = strlen(eoln);
157 input_bytes_written =
158 ::write(_pty_primary_fd, eoln, eoln_length * sizeof(char));
159
160 EXPECT_NE(-1, input_bytes_written) << strerror(errno);
161 EXPECT_EQ(eoln_length * sizeof(char), size_t(input_bytes_written));
162 return eoln_length * sizeof(char) == size_t(input_bytes_written);
163 }
164
165 bool EditlineAdapter::SendLines(const std::vector<std::string> &lines) {
166 for (auto &line : lines) {
167 #if EDITLINE_TEST_DUMP_OUTPUT
168 printf("<stdin> sending line \"%s\"\n", line.c_str());
169 #endif
170 if (!SendLine(line))
171 return false;
172 }
173 return true;
174 }
175
176 // We ignore the timeout for now.
177 bool EditlineAdapter::GetLine(std::string &line, bool &interrupted,
178 size_t /* timeout_millis */) {
179 // Ensure we're valid before proceeding.
180 if (!IsValid())
181 return false;
182
183 _editline_sp->GetLine(line, interrupted);
184 return true;
185 }
186
187 bool EditlineAdapter::GetLines(lldb_private::StringList &lines,
188 bool &interrupted, size_t /* timeout_millis */) {
189 // Ensure we're valid before proceeding.
190 if (!IsValid())
191 return false;
192
193 _editline_sp->GetLines(1, lines, interrupted);
194 return true;
195 }
196
197 bool EditlineAdapter::IsInputComplete(lldb_private::Editline *editline,
198 lldb_private::StringList &lines) {
199 // We'll call ourselves complete if we've received a balanced set of braces.
200 int start_block_count = 0;
201 int brace_balance = 0;
202
203 for (const std::string &line : lines) {
204 for (auto ch : line) {
205 if (ch == '{') {
206 ++start_block_count;
207 ++brace_balance;
208 } else if (ch == '}')
209 --brace_balance;
210 }
211 }
212
213 return (start_block_count > 0) && (brace_balance == 0);
214 }
215
216 void EditlineAdapter::ConsumeAllOutput() {
217 FilePointer output_file(fdopen(_pty_primary_fd, "r"));
218
219 int ch;
220 while ((ch = fgetc(output_file)) != EOF) {
221 #if EDITLINE_TEST_DUMP_OUTPUT
222 char display_str[] = {0, 0, 0};
223 switch (ch) {
224 case '\t':
225 display_str[0] = '\\';
226 display_str[1] = 't';
227 break;
228 case '\n':
229 display_str[0] = '\\';
230 display_str[1] = 'n';
231 break;
232 case '\r':
233 display_str[0] = '\\';
234 display_str[1] = 'r';
235 break;
236 default:
237 display_str[0] = ch;
238 break;
239 }
240 printf("<stdout> 0x%02x (%03d) (%s)\n", ch, ch, display_str);
241 // putc(ch, stdout);
242 #endif
243 }
244 }
245
246 class EditlineTestFixture : public ::testing::Test {
247 SubsystemRAII<FileSystem> subsystems;
248 EditlineAdapter _el_adapter;
249 std::shared_ptr<std::thread> _sp_output_thread;
250
251 public:
252 static void SetUpTestCase() {
253 // We need a TERM set properly for editline to work as expected.
254 setenv("TERM", "vt100", 1);
255 }
256
257 void SetUp() override {
258 // Validate the editline adapter.
259 EXPECT_TRUE(_el_adapter.IsValid());
260 if (!_el_adapter.IsValid())
261 return;
262
263 // Dump output.
264 _sp_output_thread =
265 std::make_shared<std::thread>([&] { _el_adapter.ConsumeAllOutput(); });
266 }
267
268 void TearDown() override {
269 _el_adapter.CloseInput();
270 if (_sp_output_thread)
271 _sp_output_thread->join();
272 }
273
274 EditlineAdapter &GetEditlineAdapter() { return _el_adapter; }
275 };
276
277 TEST_F(EditlineTestFixture, EditlineReceivesSingleLineText) {
278 // Send it some text via our virtual keyboard.
279 const std::string input_text("Hello, world");
280 EXPECT_TRUE(GetEditlineAdapter().SendLine(input_text));
281
282 // Verify editline sees what we put in.
283 std::string el_reported_line;
284 bool input_interrupted = false;
285 const bool received_line = GetEditlineAdapter().GetLine(
286 el_reported_line, input_interrupted, TIMEOUT_MILLIS);
287
288 EXPECT_TRUE(received_line);
289 EXPECT_FALSE(input_interrupted);
290 EXPECT_EQ(input_text, el_reported_line);
291 }
292
293 TEST_F(EditlineTestFixture, EditlineReceivesMultiLineText) {
294 // Send it some text via our virtual keyboard.
295 std::vector<std::string> input_lines;
296 input_lines.push_back("int foo()");
297 input_lines.push_back("{");
298 input_lines.push_back("printf(\"Hello, world\");");
299 input_lines.push_back("}");
300 input_lines.push_back("");
301
302 EXPECT_TRUE(GetEditlineAdapter().SendLines(input_lines));
303
304 // Verify editline sees what we put in.
305 lldb_private::StringList el_reported_lines;
306 bool input_interrupted = false;
307
308 EXPECT_TRUE(GetEditlineAdapter().GetLines(el_reported_lines,
309 input_interrupted, TIMEOUT_MILLIS));
310 EXPECT_FALSE(input_interrupted);
311
312 // Without any auto indentation support, our output should directly match our
313 // input.
314 std::vector<std::string> reported_lines;
315 for (const std::string &line : el_reported_lines)
316 reported_lines.push_back(line);
317
318 EXPECT_THAT(reported_lines, testing::ContainerEq(input_lines));
319 }
320
321 #endif