]>
Commit | Line | Data |
---|---|---|
3666a048 | 1 | # Copyright 2017-2021 Free Software Foundation, Inc. |
8955eb2d PA |
2 | |
3 | # This program is free software; you can redistribute it and/or modify | |
4 | # it under the terms of the GNU General Public License as published by | |
5 | # the Free Software Foundation; either version 3 of the License, or | |
6 | # (at your option) any later version. | |
7 | # | |
8 | # This program is distributed in the hope that it will be useful, | |
9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | # GNU General Public License for more details. | |
12 | # | |
13 | # You should have received a copy of the GNU General Public License | |
14 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
15 | ||
16 | # This file is part of the gdb testsuite. | |
17 | ||
18 | # Any variable or procedure in the namespace whose name starts with | |
19 | # "_" is private to the module. Do not use these. | |
20 | ||
21 | namespace eval completion { | |
22 | variable bell_re "\\\x07" | |
23 | ||
24 | # List of all quote chars. | |
25 | variable all_quotes_list {"'" "\""} | |
26 | ||
27 | # List of all quote chars, including no-quote at all. | |
28 | variable maybe_quoted_list {"" "'" "\""} | |
29 | ||
733d554a | 30 | variable keyword_list {"-force-condition" "if" "task" "thread"} |
8955eb2d PA |
31 | |
32 | variable explicit_opts_list \ | |
a20714ff | 33 | {"-function" "-label" "-line" "-qualified" "-source"} |
8955eb2d PA |
34 | } |
35 | ||
36 | # Make a regular expression that matches a TAB completion list. | |
37 | ||
38 | proc make_tab_completion_list_re { completion_list } { | |
39 | # readline separates the completion columns that fit on the same | |
40 | # line with whitespace. Since we're testing under "set width | |
41 | # unlimited", all completions will be printed on the same line. | |
42 | # The amount of whitespace depends on the length of the widest | |
43 | # completion. We could compute that here and expect the exact | |
44 | # number of ws characters between each completion match, but to | |
45 | # keep it simple, we accept any number of characters. | |
46 | set ws " +" | |
47 | ||
48 | set completion_list_re "" | |
49 | foreach c $completion_list { | |
50 | append completion_list_re [string_to_regexp $c] | |
51 | append completion_list_re $ws | |
52 | } | |
53 | append completion_list_re $ws | |
54 | ||
55 | return $completion_list_re | |
56 | } | |
57 | ||
58 | # Make a regular expression that matches a "complete" command | |
59 | # completion list. CMD_PREFIX is the command prefix added to each | |
60 | # completion match. | |
61 | ||
62 | proc make_cmd_completion_list_re { cmd_prefix completion_list start_quote_char end_quote_char } { | |
63 | ||
64 | set completion_list_re "" | |
65 | foreach c $completion_list { | |
66 | # The command prefix is included in all completion matches. | |
67 | append completion_list_re [string_to_regexp $cmd_prefix$start_quote_char$c$end_quote_char] | |
68 | append completion_list_re "\r\n" | |
69 | } | |
70 | ||
71 | return $completion_list_re | |
72 | } | |
73 | ||
74 | # Clear the input line. | |
75 | ||
76 | proc clear_input_line { test } { | |
77 | global gdb_prompt | |
78 | ||
79 | send_gdb "\003" | |
80 | gdb_test_multiple "" "$test (clearing input line)" { | |
81 | -re "Quit\r\n$gdb_prompt $" { | |
82 | } | |
83 | } | |
84 | } | |
85 | ||
86 | # Test that completing LINE with TAB completes to nothing. | |
87 | ||
88 | proc test_gdb_complete_tab_none { line } { | |
89 | set line_re [string_to_regexp $line] | |
90 | ||
91 | set test "tab complete \"$line\"" | |
92 | send_gdb "$line\t" | |
93 | gdb_test_multiple "" "$test" { | |
94 | -re "^$line_re$completion::bell_re$" { | |
95 | pass "$test" | |
96 | } | |
97 | } | |
98 | ||
99 | clear_input_line $test | |
100 | } | |
101 | ||
102 | # Test that completing INPUT_LINE with TAB completes to | |
103 | # COMPLETE_LINE_RE. APPEND_CHAR_RE is the character expected to be | |
104 | # appended after EXPECTED_OUTPUT. Normally that's a whitespace, but | |
105 | # in some cases it's some other character, like a colon. | |
106 | ||
107 | proc test_gdb_complete_tab_unique { input_line complete_line_re append_char_re } { | |
108 | ||
109 | set test "tab complete \"$input_line\"" | |
110 | send_gdb "$input_line\t" | |
7325b16b | 111 | set res 1 |
8955eb2d PA |
112 | gdb_test_multiple "" "$test" { |
113 | -re "^$complete_line_re$append_char_re$" { | |
114 | pass "$test" | |
115 | } | |
7325b16b TV |
116 | timeout { |
117 | fail "$test (timeout)" | |
118 | set res -1 | |
119 | } | |
8955eb2d PA |
120 | } |
121 | ||
122 | clear_input_line $test | |
7325b16b | 123 | return $res |
8955eb2d PA |
124 | } |
125 | ||
126 | # Test that completing INPUT_LINE with TAB completes to "INPUT_LINE + | |
127 | # ADD_COMPLETED_LINE" and that it displays the completion matches in | |
e2a689da PA |
128 | # COMPLETION_LIST. If MAX_COMPLETIONS then we expect the completion |
129 | # to hit the max-completions limit. | |
8955eb2d PA |
130 | |
131 | proc test_gdb_complete_tab_multiple { input_line add_completed_line \ | |
e2a689da | 132 | completion_list {max_completions 0}} { |
8955eb2d PA |
133 | global gdb_prompt |
134 | ||
135 | set input_line_re [string_to_regexp $input_line] | |
136 | set add_completed_line_re [string_to_regexp $add_completed_line] | |
137 | ||
138 | set expected_re [make_tab_completion_list_re $completion_list] | |
139 | ||
e2a689da PA |
140 | if {$max_completions} { |
141 | append expected_re "\r\n" | |
142 | append expected_re \ | |
143 | "\\*\\*\\* List may be truncated, max-completions reached\\. \\*\\*\\*" | |
144 | } | |
145 | ||
8955eb2d PA |
146 | set test "tab complete \"$input_line\"" |
147 | send_gdb "$input_line\t" | |
148 | gdb_test_multiple "" "$test (first tab)" { | |
149 | -re "^${input_line_re}${completion::bell_re}$add_completed_line_re$" { | |
150 | send_gdb "\t" | |
151 | # If we auto-completed to an ambiguous prefix, we need an | |
152 | # extra tab to show the matches list. | |
153 | if {$add_completed_line != ""} { | |
154 | send_gdb "\t" | |
6892d2e4 PA |
155 | set maybe_bell ${completion::bell_re} |
156 | } else { | |
157 | set maybe_bell "" | |
8955eb2d PA |
158 | } |
159 | gdb_test_multiple "" "$test (second tab)" { | |
b2b2a215 PA |
160 | -re "^${maybe_bell}\r\n$expected_re\r\n$gdb_prompt " { |
161 | gdb_test_multiple "" "$test (second tab)" { | |
162 | -re "^$input_line_re$add_completed_line_re$" { | |
163 | pass "$test" | |
164 | } | |
165 | } | |
8955eb2d PA |
166 | } |
167 | } | |
168 | } | |
169 | } | |
170 | ||
171 | clear_input_line $test | |
172 | } | |
173 | ||
174 | # Test that completing LINE with the complete command completes to | |
175 | # nothing. | |
176 | ||
177 | proc test_gdb_complete_cmd_none { line } { | |
178 | gdb_test_no_output "complete $line" "cmd complete \"$line\"" | |
179 | } | |
180 | ||
181 | # Test that completing LINE with the complete command completes to | |
182 | # COMPLETE_LINE_RE. | |
183 | ||
184 | proc test_gdb_complete_cmd_unique { input_line complete_line_re } { | |
185 | global gdb_prompt | |
186 | ||
187 | set cmd "complete $input_line" | |
188 | set cmd_re [string_to_regexp $cmd] | |
189 | set test "cmd complete \"$input_line\"" | |
190 | gdb_test_multiple $cmd $test { | |
191 | -re "^$cmd_re\r\n$complete_line_re\r\n$gdb_prompt $" { | |
192 | pass $test | |
193 | } | |
194 | } | |
195 | } | |
196 | ||
197 | # Test that completing "CMD_PREFIX + COMPLETION_WORD" with the | |
198 | # complete command displays the COMPLETION_LIST completion list. Each | |
e2a689da PA |
199 | # entry in the list should be prefixed by CMD_PREFIX. If |
200 | # MAX_COMPLETIONS then we expect the completion to hit the | |
201 | # max-completions limit. | |
8955eb2d | 202 | |
e2a689da | 203 | proc test_gdb_complete_cmd_multiple { cmd_prefix completion_word completion_list {start_quote_char ""} {end_quote_char ""} {max_completions 0}} { |
8955eb2d PA |
204 | global gdb_prompt |
205 | ||
206 | set expected_re [make_cmd_completion_list_re $cmd_prefix $completion_list $start_quote_char $end_quote_char] | |
e2a689da PA |
207 | |
208 | if {$max_completions} { | |
a994424f | 209 | set cmd_prefix_re [string_to_regexp $cmd_prefix] |
e2a689da | 210 | append expected_re \ |
a994424f | 211 | "$cmd_prefix_re \\*\\*\\* List may be truncated, max-completions reached\\. \\*\\*\\*.*\r\n" |
e2a689da PA |
212 | } |
213 | ||
8955eb2d PA |
214 | set cmd_re [string_to_regexp "complete $cmd_prefix$completion_word"] |
215 | set test "cmd complete \"$cmd_prefix$completion_word\"" | |
216 | gdb_test_multiple "complete $cmd_prefix$completion_word" $test { | |
217 | -re "^$cmd_re\r\n$expected_re$gdb_prompt $" { | |
218 | pass $test | |
219 | } | |
220 | } | |
221 | } | |
222 | ||
223 | # Test that completing LINE completes to nothing. | |
224 | ||
225 | proc test_gdb_complete_none { input_line } { | |
26655f53 SL |
226 | if { [readline_is_used] } { |
227 | test_gdb_complete_tab_none $input_line | |
228 | } | |
8955eb2d PA |
229 | test_gdb_complete_cmd_none $input_line |
230 | } | |
231 | ||
232 | # Test that completing INPUT_LINE completes to COMPLETE_LINE_RE. | |
233 | # | |
234 | # APPEND_CHAR is the character expected to be appended after | |
235 | # EXPECTED_OUTPUT when TAB completing. Normally that's a whitespace, | |
236 | # but in some cases it's some other character, like a colon. | |
237 | # | |
238 | # If MAX_COMPLETIONS is true, then we expect the completion to hit the | |
239 | # max-completions limit. Since we're expecting a unique completion | |
240 | # match, this will only be visible in the "complete" command output. | |
241 | # Tab completion will just auto-complete the only match and won't | |
242 | # display a match list. | |
243 | # | |
244 | # Note: usually it's more convenient to pass a literal string instead | |
245 | # of a regular expression (as COMPLETE_LINE_RE). See | |
246 | # test_gdb_complete_unique below. | |
247 | ||
248 | proc test_gdb_complete_unique_re { input_line complete_line_re {append_char " "} {max_completions 0}} { | |
249 | set append_char_re [string_to_regexp $append_char] | |
26655f53 | 250 | if { [readline_is_used] } { |
7325b16b TV |
251 | if { [test_gdb_complete_tab_unique $input_line $complete_line_re \ |
252 | $append_char_re] == -1 } { | |
253 | return -1 | |
254 | } | |
26655f53 | 255 | } |
8955eb2d PA |
256 | |
257 | # Trim INPUT_LINE and COMPLETE LINE, for the case we're completing | |
258 | # a command with leading whitespace. Leading command whitespace | |
259 | # is discarded by GDB. | |
260 | set input_line [string trimleft $input_line] | |
261 | set expected_output_re [string trimleft $complete_line_re] | |
262 | if {$append_char_re != " "} { | |
263 | append expected_output_re $append_char_re | |
264 | } | |
265 | if {$max_completions} { | |
266 | set max_completion_reached_msg \ | |
267 | "*** List may be truncated, max-completions reached. ***" | |
268 | set input_line_re \ | |
269 | [string_to_regexp $input_line] | |
270 | set max_completion_reached_msg_re \ | |
271 | [string_to_regexp $max_completion_reached_msg] | |
272 | ||
273 | append expected_output_re \ | |
274 | "\r\n$input_line_re $max_completion_reached_msg_re" | |
275 | } | |
276 | ||
277 | test_gdb_complete_cmd_unique $input_line $expected_output_re | |
7325b16b | 278 | return 1 |
8955eb2d PA |
279 | } |
280 | ||
281 | # Like TEST_GDB_COMPLETE_UNIQUE_RE, but COMPLETE_LINE is a string, not | |
282 | # a regular expression. | |
283 | ||
284 | proc test_gdb_complete_unique { input_line complete_line {append_char " "} {max_completions 0}} { | |
285 | set complete_line_re [string_to_regexp $complete_line] | |
286 | test_gdb_complete_unique_re $input_line $complete_line_re $append_char $max_completions | |
287 | } | |
288 | ||
289 | # Test that completing "CMD_PREFIX + COMPLETION_WORD" adds | |
290 | # ADD_COMPLETED_LINE to the input line, and that it displays | |
291 | # COMPLETION_LIST as completion match list. COMPLETION_WORD is the | |
e2a689da PA |
292 | # completion word. If MAX_COMPLETIONS then we expect the completion |
293 | # to hit the max-completions limit. | |
294 | ||
295 | proc test_gdb_complete_multiple { | |
296 | cmd_prefix completion_word add_completed_line completion_list | |
297 | {start_quote_char ""} {end_quote_char ""} {max_completions 0} | |
298 | } { | |
26655f53 SL |
299 | if { [readline_is_used] } { |
300 | test_gdb_complete_tab_multiple "$cmd_prefix$completion_word" $add_completed_line $completion_list $max_completions | |
301 | } | |
e2a689da | 302 | test_gdb_complete_cmd_multiple $cmd_prefix $completion_word $completion_list $start_quote_char $end_quote_char $max_completions |
8955eb2d PA |
303 | } |
304 | ||
6a3c6ee4 PA |
305 | # Test that all the substring prefixes of INPUT from [0..START) to |
306 | # [0..END) complete to COMPLETION_RE (a regular expression). If END | |
307 | # is ommitted, default to the length of INPUT. | |
8955eb2d | 308 | |
6a3c6ee4 | 309 | proc test_complete_prefix_range_re {input completion_re start {end -1}} { |
8955eb2d | 310 | if {$end == -1} { |
6a3c6ee4 | 311 | set end [string length $input] |
8955eb2d PA |
312 | } |
313 | ||
7325b16b TV |
314 | set timeouts 0 |
315 | set max_timeouts 3 | |
8955eb2d | 316 | for {set i $start} {$i < $end} {incr i} { |
6a3c6ee4 | 317 | set line [string range $input 0 $i] |
7325b16b TV |
318 | set res [test_gdb_complete_unique_re "$line" $completion_re] |
319 | if { $res == -1 } { | |
320 | incr timeouts | |
321 | } else { | |
322 | if { $timeouts > 0 } { | |
323 | set timeouts 0 | |
324 | } | |
325 | } | |
326 | if { $timeouts == $max_timeouts } { | |
327 | verbose -log "Consecutive timeouts in test_complete_prefix_range_re, giving up" | |
328 | break | |
329 | } | |
8955eb2d PA |
330 | } |
331 | } | |
332 | ||
6a3c6ee4 PA |
333 | # Test that all the substring prefixes of COMPLETION from [0..START) |
334 | # to [0..END) complete to COMPLETION. If END is ommitted, default to | |
335 | # the length of COMPLETION. | |
336 | ||
337 | proc test_complete_prefix_range {completion start {end -1}} { | |
338 | set completion_re [string_to_regexp $completion] | |
339 | test_complete_prefix_range_re $completion $completion_re $start $end | |
340 | } | |
341 | ||
8955eb2d PA |
342 | # Find NEEDLE in HAYSTACK and return the index _after_ NEEDLE. E.g., |
343 | # searching for "(" in "foo(int)" returns 4, which would be useful if | |
344 | # you want to find the "(" to try completing "foo(". | |
345 | ||
346 | proc index_after {needle haystack} { | |
347 | set start [string first $needle $haystack] | |
348 | if {$start == -1} { | |
349 | error "could not find \"$needle\" in \"$haystack\"" | |
350 | } | |
351 | return [expr $start + [string length $needle]] | |
352 | } | |
353 | ||
354 | # Create a breakpoint using BREAK_COMMAND, and return the number | |
355 | # of locations found. | |
356 | ||
357 | proc completion::_create_bp {break_command} { | |
358 | global gdb_prompt | |
359 | global decimal hex | |
360 | ||
361 | set found_locations -1 | |
362 | ||
363 | set test "set breakpoint" | |
364 | gdb_test_multiple "$break_command" $test { | |
365 | -re "\\\(\($decimal\) locations\\\)\r\n$gdb_prompt $" { | |
366 | set found_locations "$expect_out(1,string)" | |
367 | } | |
368 | -re "Breakpoint $decimal at $hex: file .*, line .*$gdb_prompt $" { | |
369 | set found_locations 1 | |
370 | } | |
371 | -re "Make breakpoint pending on future shared library load.*y or .n.. $" { | |
372 | send_gdb "n\n" | |
373 | gdb_test_multiple "" "$test (prompt)" { | |
374 | -re "$gdb_prompt $" { | |
375 | } | |
376 | } | |
377 | set found_locations 0 | |
378 | } | |
379 | -re "invalid explicit location argument, \[^\r\n\]*\r\n$gdb_prompt $" { | |
380 | set found_locations 0 | |
381 | } | |
382 | -re "Function \[^\r\n\]* not defined in \[^\r\n\]*\r\n$gdb_prompt $" { | |
383 | set found_locations 0 | |
384 | } | |
385 | } | |
386 | return $found_locations | |
387 | } | |
388 | ||
389 | # Return true if lists A and B have the same elements. Order of | |
390 | # elements does not matter. | |
391 | ||
392 | proc completion::_leq {a b} { | |
393 | return [expr {[lsort $a] eq [lsort $b]}] | |
394 | } | |
395 | ||
396 | # Check that trying to create a breakpoint using BREAK_COMMAND fails. | |
397 | ||
398 | proc check_setting_bp_fails {break_command} { | |
399 | with_test_prefix "\"$break_command\" creates no bp locations" { | |
400 | set found_locations [completion::_create_bp $break_command] | |
401 | gdb_assert {$found_locations == 0} "matches" | |
402 | if {$found_locations != 0} { | |
403 | delete_breakpoints | |
404 | } | |
405 | } | |
406 | } | |
407 | ||
408 | # Check that creating the breakpoint using BREAK_COMMAND finds the | |
409 | # same breakpoint locations as completing BREAK_COMMAND. | |
410 | # COMPLETION_LIST is the expected completion match list. | |
411 | ||
412 | proc check_bp_locations_match_list {break_command completion_list} { | |
413 | global gdb_prompt | |
414 | global hex | |
415 | ||
416 | with_test_prefix "compare \"$break_command\" completion list with bp location list" { | |
417 | set num_locations [completion::_create_bp $break_command] | |
418 | ||
419 | set found_list "" | |
420 | ||
421 | set any "\[^\r\n\]*" | |
422 | ||
423 | gdb_test_multiple "info breakpoint \$bpnum" "info breakpoint" { | |
424 | -re "in \(\[^\r\n\]*\) at " { | |
425 | # A function location. | |
426 | set found_location "$expect_out(1,string)" | |
427 | lappend found_list $found_location | |
428 | exp_continue | |
429 | } | |
430 | -re "breakpoint${any}keep${any}y${any}$hex\[ \t]*\(${any}\)\r\n" { | |
431 | # A label location. | |
432 | set found_location "$expect_out(1,string)" | |
433 | lappend found_list $found_location | |
434 | exp_continue | |
435 | } | |
436 | -re "$gdb_prompt $" { | |
437 | } | |
438 | } | |
439 | ||
440 | gdb_assert {[completion::_leq $found_list $completion_list]} "matches" | |
441 | ||
442 | delete_breakpoints | |
443 | } | |
444 | } | |
445 | ||
446 | # Build linespec and explicit locations out of all the combinations of | |
447 | # SOURCES, FUNCTIONS and LABELS, with all combinations of possible | |
448 | # quoting and whitespace around separators, and run BODY_LINESPEC and | |
449 | # BODY_EXPLICIT in the context of the caller for each combination. A | |
450 | # variable named "location" is set in the callers context with the | |
451 | # currently iterated location. | |
452 | ||
453 | proc foreach_location_functions { sources functions body_linespec body_explicit } { | |
454 | upvar source source | |
455 | upvar function function | |
456 | upvar source_sep source_sep | |
457 | upvar location location | |
458 | ||
459 | foreach source $sources { | |
460 | # Test with and without source quoting. | |
461 | foreach sqc $completion::maybe_quoted_list { | |
462 | if {$source == "" && $sqc != ""} { | |
463 | # Invalid combination. | |
464 | continue | |
465 | } | |
466 | ||
467 | # Test with and without function quoting. | |
468 | foreach fqc $completion::maybe_quoted_list { | |
469 | # Test known and unknown functions. | |
470 | foreach function $functions { | |
471 | # Linespec version. Test with and without spacing | |
472 | # after the source/colon colon separator. | |
473 | foreach source_sep {"" ":" ": "} { | |
474 | # Skip invalid combinations. | |
475 | if {$source == "" && $source_sep != ""} { | |
476 | continue | |
477 | } | |
478 | if {$source != "" && $source_sep == ""} { | |
479 | continue | |
480 | } | |
481 | ||
482 | set location "${sqc}${source}${sqc}${source_sep}${fqc}$function${fqc}" | |
483 | uplevel 1 $body_linespec | |
484 | } | |
485 | ||
486 | # Explicit locations version. | |
487 | if {$source != ""} { | |
488 | set loc_src "-source ${sqc}${source}${sqc} " | |
489 | } else { | |
490 | set loc_src "" | |
491 | } | |
492 | ||
493 | set location "${loc_src}-function ${fqc}$function${fqc}" | |
494 | uplevel 1 $body_explicit | |
495 | } | |
496 | } | |
497 | } | |
498 | } | |
499 | } | |
500 | ||
501 | # Same as foreach_locations_functions, but also iterate over | |
502 | # combinations of labels. | |
503 | proc foreach_location_labels { sources functions labels body_linespec body_explicit } { | |
504 | upvar source source | |
505 | upvar function function | |
506 | upvar label label | |
507 | upvar source_sep source_sep | |
508 | upvar label_sep label_sep | |
509 | upvar location location | |
510 | ||
511 | # Test both with a known source file and without a source file | |
512 | # component. | |
513 | foreach_location_functions \ | |
514 | $sources \ | |
515 | $functions \ | |
516 | { | |
517 | # Linespec version. Test various spacing around the label | |
518 | # colon separator. | |
519 | set saved_location ${location} | |
520 | foreach label_sep {":" " :" ": " " : "} { | |
521 | # Test both known and unknown label. | |
522 | foreach label $labels { | |
523 | set location "${saved_location}${label_sep}$label" | |
524 | uplevel 1 $body_linespec | |
525 | } | |
526 | } | |
527 | } \ | |
528 | { | |
529 | # Explicit locations version. | |
530 | set saved_location ${location} | |
531 | foreach label $labels { | |
532 | set location "${saved_location} -label $label" | |
533 | uplevel 1 $body_explicit | |
534 | } | |
535 | } | |
536 | } | |
e2a689da PA |
537 | |
538 | # Check that completion of INPUT_LINE results in GDB completing on all | |
539 | # command names. | |
540 | proc test_gdb_completion_offers_commands {input_line} { | |
541 | global gdb_prompt | |
542 | ||
543 | # There are two many commands to usefully check here. So we force | |
544 | # max-completions to 2, and check if those 2 come out. | |
545 | ||
546 | # Save current max-completions. | |
547 | set max_completions 0 | |
548 | set test "show max-completions" | |
549 | gdb_test_multiple $test $test { | |
550 | -re "Maximum number of completion candidates is (.*)\\.\r\n$gdb_prompt $" { | |
551 | set max_completions $expect_out(1,string) | |
552 | } | |
553 | } | |
554 | ||
555 | # Force showing two commands. | |
556 | gdb_test_no_output "set max-completions 2" "" | |
557 | ||
bb8d1260 SL |
558 | # TUI adds additional commands to the possible completions, so we |
559 | # need different patterns depending on whether or not it is enabled. | |
560 | if { [skip_tui_tests] } { | |
561 | test_gdb_complete_multiple $input_line "" "" { | |
562 | "!" | |
563 | "actions" | |
564 | } "" "" 1 | |
565 | } else { | |
566 | test_gdb_complete_multiple $input_line "" "" { | |
567 | "!" | |
568 | "+" | |
569 | } "" "" 1 | |
570 | } | |
e2a689da PA |
571 | |
572 | # Restore. | |
573 | gdb_test_no_output "set max-completions $max_completions" "" | |
574 | } |