1 # Copyright 2017-2020 Free Software Foundation, Inc.
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.
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.
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/>.
16 # This file is part of the gdb testsuite.
18 # Any variable or procedure in the namespace whose name starts with
19 # "_" is private to the module. Do not use these.
21 namespace eval completion {
22 variable bell_re "\\\x07"
24 # List of all quote chars.
25 variable all_quotes_list {"'" "\""}
27 # List of all quote chars, including no-quote at all.
28 variable maybe_quoted_list {"" "'" "\""}
30 variable keyword_list {"if" "task" "thread"}
32 variable explicit_opts_list \
33 {"-function" "-label" "-line" "-qualified" "-source"}
36 # Make a regular expression that matches a TAB completion list.
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.
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
53 append completion_list_re $ws
55 return $completion_list_re
58 # Make a regular expression that matches a "complete" command
59 # completion list. CMD_PREFIX is the command prefix added to each
62 proc make_cmd_completion_list_re { cmd_prefix completion_list start_quote_char end_quote_char } {
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"
71 return $completion_list_re
74 # Clear the input line.
76 proc clear_input_line { test } {
80 gdb_test_multiple "" "$test (clearing input line)" {
81 -re "Quit\r\n$gdb_prompt $" {
86 # Test that completing LINE with TAB completes to nothing.
88 proc test_gdb_complete_tab_none { line } {
89 set line_re [string_to_regexp $line]
91 set test "tab complete \"$line\""
93 gdb_test_multiple "" "$test" {
94 -re "^$line_re$completion::bell_re$" {
99 clear_input_line $test
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.
107 proc test_gdb_complete_tab_unique { input_line complete_line_re append_char_re } {
109 set test "tab complete \"$input_line\""
110 send_gdb "$input_line\t"
112 gdb_test_multiple "" "$test" {
113 -re "^$complete_line_re$append_char_re$" {
117 fail "$test (timeout)"
122 clear_input_line $test
126 # Test that completing INPUT_LINE with TAB completes to "INPUT_LINE +
127 # ADD_COMPLETED_LINE" and that it displays the completion matches in
128 # COMPLETION_LIST. If MAX_COMPLETIONS then we expect the completion
129 # to hit the max-completions limit.
131 proc test_gdb_complete_tab_multiple { input_line add_completed_line \
132 completion_list {max_completions 0}} {
135 set input_line_re [string_to_regexp $input_line]
136 set add_completed_line_re [string_to_regexp $add_completed_line]
138 set expected_re [make_tab_completion_list_re $completion_list]
140 if {$max_completions} {
141 append expected_re "\r\n"
143 "\\*\\*\\* List may be truncated, max-completions reached\\. \\*\\*\\*"
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$" {
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 != ""} {
155 set maybe_bell ${completion::bell_re}
159 gdb_test_multiple "" "$test (second tab)" {
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$" {
171 clear_input_line $test
174 # Test that completing LINE with the complete command completes to
177 proc test_gdb_complete_cmd_none { line } {
178 gdb_test_no_output "complete $line" "cmd complete \"$line\""
181 # Test that completing LINE with the complete command completes to
184 proc test_gdb_complete_cmd_unique { input_line complete_line_re } {
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 $" {
197 # Test that completing "CMD_PREFIX + COMPLETION_WORD" with the
198 # complete command displays the COMPLETION_LIST completion list. Each
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.
203 proc test_gdb_complete_cmd_multiple { cmd_prefix completion_word completion_list {start_quote_char ""} {end_quote_char ""} {max_completions 0}} {
206 set expected_re [make_cmd_completion_list_re $cmd_prefix $completion_list $start_quote_char $end_quote_char]
208 if {$max_completions} {
209 set cmd_prefix_re [string_to_regexp $cmd_prefix]
211 "$cmd_prefix_re \\*\\*\\* List may be truncated, max-completions reached\\. \\*\\*\\*.*\r\n"
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 $" {
223 # Test that completing LINE completes to nothing.
225 proc test_gdb_complete_none { input_line } {
226 if { [readline_is_used] } {
227 test_gdb_complete_tab_none $input_line
229 test_gdb_complete_cmd_none $input_line
232 # Test that completing INPUT_LINE completes to COMPLETE_LINE_RE.
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.
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.
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.
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]
250 if { [readline_is_used] } {
251 if { [test_gdb_complete_tab_unique $input_line $complete_line_re \
252 $append_char_re] == -1 } {
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
265 if {$max_completions} {
266 set max_completion_reached_msg \
267 "*** List may be truncated, max-completions reached. ***"
269 [string_to_regexp $input_line]
270 set max_completion_reached_msg_re \
271 [string_to_regexp $max_completion_reached_msg]
273 append expected_output_re \
274 "\r\n$input_line_re $max_completion_reached_msg_re"
277 test_gdb_complete_cmd_unique $input_line $expected_output_re
281 # Like TEST_GDB_COMPLETE_UNIQUE_RE, but COMPLETE_LINE is a string, not
282 # a regular expression.
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
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
292 # completion word. If MAX_COMPLETIONS then we expect the completion
293 # to hit the max-completions limit.
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}
299 if { [readline_is_used] } {
300 test_gdb_complete_tab_multiple "$cmd_prefix$completion_word" $add_completed_line $completion_list $max_completions
302 test_gdb_complete_cmd_multiple $cmd_prefix $completion_word $completion_list $start_quote_char $end_quote_char $max_completions
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.
309 proc test_complete_prefix_range_re {input completion_re start {end -1}} {
311 set end [string length $input]
316 for {set i $start} {$i < $end} {incr i} {
317 set line [string range $input 0 $i]
318 set res [test_gdb_complete_unique_re "$line" $completion_re]
322 if { $timeouts > 0 } {
326 if { $timeouts == $max_timeouts } {
327 verbose -log "Consecutive timeouts in test_complete_prefix_range_re, giving up"
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.
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
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(".
346 proc index_after {needle haystack} {
347 set start [string first $needle $haystack]
349 error "could not find \"$needle\" in \"$haystack\""
351 return [expr $start + [string length $needle]]
354 # Create a breakpoint using BREAK_COMMAND, and return the number
355 # of locations found.
357 proc completion::_create_bp {break_command} {
361 set found_locations -1
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)"
368 -re "Breakpoint $decimal at $hex: file .*, line .*$gdb_prompt $" {
369 set found_locations 1
371 -re "Make breakpoint pending on future shared library load.*y or .n.. $" {
373 gdb_test_multiple "" "$test (prompt)" {
374 -re "$gdb_prompt $" {
377 set found_locations 0
379 -re "invalid explicit location argument, \[^\r\n\]*\r\n$gdb_prompt $" {
380 set found_locations 0
382 -re "Function \[^\r\n\]* not defined in \[^\r\n\]*\r\n$gdb_prompt $" {
383 set found_locations 0
386 return $found_locations
389 # Return true if lists A and B have the same elements. Order of
390 # elements does not matter.
392 proc completion::_leq {a b} {
393 return [expr {[lsort $a] eq [lsort $b]}]
396 # Check that trying to create a breakpoint using BREAK_COMMAND fails.
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} {
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.
412 proc check_bp_locations_match_list {break_command completion_list} {
416 with_test_prefix "compare \"$break_command\" completion list with bp location list" {
417 set num_locations [completion::_create_bp $break_command]
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
430 -re "breakpoint${any}keep${any}y${any}$hex\[ \t]*\(${any}\)\r\n" {
432 set found_location "$expect_out(1,string)"
433 lappend found_list $found_location
436 -re "$gdb_prompt $" {
440 gdb_assert {[completion::_leq $found_list $completion_list]} "matches"
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.
453 proc foreach_location_functions { sources functions body_linespec body_explicit } {
455 upvar function function
456 upvar source_sep source_sep
457 upvar location location
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.
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 != ""} {
478 if {$source != "" && $source_sep == ""} {
482 set location "${sqc}${source}${sqc}${source_sep}${fqc}$function${fqc}"
483 uplevel 1 $body_linespec
486 # Explicit locations version.
488 set loc_src "-source ${sqc}${source}${sqc} "
493 set location "${loc_src}-function ${fqc}$function${fqc}"
494 uplevel 1 $body_explicit
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 } {
505 upvar function function
507 upvar source_sep source_sep
508 upvar label_sep label_sep
509 upvar location location
511 # Test both with a known source file and without a source file
513 foreach_location_functions \
517 # Linespec version. Test various spacing around the label
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
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
538 # Check that completion of INPUT_LINE results in GDB completing on all
540 proc test_gdb_completion_offers_commands {input_line} {
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.
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)
555 # Force showing two commands.
556 gdb_test_no_output "set max-completions 2" ""
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 "" "" {
566 test_gdb_complete_multiple $input_line "" "" {
573 gdb_test_no_output "set max-completions $max_completions" ""