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(stream: _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(p: new FilePointer(fdopen(fd: _pty_secondary_fd, modes: "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>(args&: *_el_secondary_file, |
122 | args: NativeFile::Unowned, args&: output_mutex); |
123 | lldb::LockableStreamFileSP error_stream_sp = |
124 | std::make_shared<LockableStreamFile>(args&: *_el_secondary_file, |
125 | args: NativeFile::Unowned, args&: output_mutex); |
126 | |
127 | // Create an Editline instance. |
128 | _editline_sp.reset(p: 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(p: 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(fd: _pty_primary_fd, buf: line.c_str(), |
153 | n: line.length() * sizeof(std::string::value_type)); |
154 | |
155 | const char *eoln = "\n" ; |
156 | const size_t eoln_length = strlen(s: eoln); |
157 | input_bytes_written = |
158 | ::write(fd: _pty_primary_fd, buf: eoln, n: 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(first_line_number: 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(fd: _pty_primary_fd, modes: "r" )); |
218 | |
219 | int ch; |
220 | while ((ch = fgetc(stream: 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(name: "TERM" , value: "vt100" , replace: 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>(args: [&] { _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 | line&: el_reported_line, interrupted&: 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(x: "int foo()" ); |
297 | input_lines.push_back(x: "{" ); |
298 | input_lines.push_back(x: "printf(\"Hello, world\");" ); |
299 | input_lines.push_back(x: "}" ); |
300 | input_lines.push_back(x: "" ); |
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(x: line); |
317 | |
318 | EXPECT_THAT(reported_lines, testing::ContainerEq(input_lines)); |
319 | } |
320 | |
321 | #endif |
322 | |