1# Copyright 2017-2020 Free Software Foundation, Inc. 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 18load_lib completion-support.exp 19 20standard_testfile cpls.cc cpls2.cc cpls-hyphen.cc 21 22if {[prepare_for_testing "failed to prepare" $testfile \ 23 [list $srcfile $srcfile2 $srcfile3] {debug}]} { 24 return -1 25} 26 27# Tests below are about tab-completion, which doesn't work if readline 28# library isn't used. Check it first. 29 30if { ![readline_is_used] } { 31 untested "no tab completion support without readline" 32 return -1 33} 34 35# Disable the completion limit for the whole testcase. 36gdb_test_no_output "set max-completions unlimited" 37 38# Start of tests. 39 40# Test completion of all parameter prefixes, crossing "(" and ")", 41# with and without whitespace. 42 43proc_with_prefix all-param-prefixes {} { 44 45 # Test both linespecs and explicit locations. 46 foreach cmd_prefix {"b" "b -function"} { 47 set line "$cmd_prefix param_prefixes_test_long(long)" 48 set start [index_after "test_long" $line] 49 test_complete_prefix_range $line $start 50 51 # Same, but with extra spaces. Note that the original spaces in 52 # the input line are preserved after completion. 53 test_gdb_complete_unique \ 54 "$cmd_prefix param_prefixes_test_long(long " \ 55 "$cmd_prefix param_prefixes_test_long(long )" 56 test_gdb_complete_unique \ 57 "$cmd_prefix param_prefixes_test_long( long " \ 58 "$cmd_prefix param_prefixes_test_long( long )" 59 test_gdb_complete_unique \ 60 "$cmd_prefix param_prefixes_test_long ( long " \ 61 "$cmd_prefix param_prefixes_test_long ( long )" 62 63 # Complete all parameter prefixes between "(i" and "(int*, int&)". 64 # Note that this exercises completing when the point is at the 65 # space in "param_prefixes_test_intp_intr(int*, ". 66 set line "$cmd_prefix param_prefixes_test_intp_intr(int*, int&)" 67 set start [index_after "intp_intr" $line] 68 test_complete_prefix_range $line $start 69 70 # Similar, but with extra spaces. 71 test_gdb_complete_unique \ 72 "$cmd_prefix param_prefixes_test_intp_intr ( int* " \ 73 "$cmd_prefix param_prefixes_test_intp_intr ( int* , int&)" 74 75 test_gdb_complete_unique \ 76 "$cmd_prefix param_prefixes_test_intp_intr ( int *" \ 77 "$cmd_prefix param_prefixes_test_intp_intr ( int *, int&)" 78 79 test_gdb_complete_unique \ 80 "$cmd_prefix param_prefixes_test_intp_intr ( int *, int " \ 81 "$cmd_prefix param_prefixes_test_intp_intr ( int *, int &)" 82 83 test_gdb_complete_unique \ 84 "$cmd_prefix param_prefixes_test_intp_intr ( int *, int & " \ 85 "$cmd_prefix param_prefixes_test_intp_intr ( int *, int & )" 86 } 87} 88 89# Test completion of an overloaded function. 90 91proc_with_prefix overload {} { 92 set completion_list { 93 "overload_ambiguous_test(int, int)" 94 "overload_ambiguous_test(int, long)" 95 "overload_ambiguous_test(long)" 96 } 97 98 foreach cmd_prefix {"b" "b -function"} { 99 test_gdb_complete_multiple \ 100 "$cmd_prefix " "overload_ambiguous_" "test(" \ 101 $completion_list 102 check_bp_locations_match_list \ 103 "$cmd_prefix overload_ambiguous_test" \ 104 $completion_list 105 106 # Test disambiguating by typing enough to pick the "int" as 107 # first parameter type. This then tests handling ambiguity in 108 # the second parameter, which checks that tab completion when 109 # the point is at the whitespace behaves naturally, by showing 110 # the remaining matching overloads to the user. 111 test_gdb_complete_multiple \ 112 "$cmd_prefix " "overload_ambiguous_test(i" "nt, " { 113 "overload_ambiguous_test(int, int)" 114 "overload_ambiguous_test(int, long)" 115 } 116 117 # Add a few more characters to make the completion 118 # unambiguous. 119 test_gdb_complete_unique \ 120 "$cmd_prefix overload_ambiguous_test(int, i" \ 121 "$cmd_prefix overload_ambiguous_test(int, int)" 122 check_bp_locations_match_list \ 123 "$cmd_prefix overload_ambiguous_test(int, int)" { 124 "overload_ambiguous_test(int, int)" 125 } 126 } 127} 128 129# Test completion of a function that is defined in different scopes 130# with different parameters. 131 132proc_with_prefix overload-2 {} { 133 with_test_prefix "all" { 134 set completion_list { 135 "(anonymous namespace)::overload2_function(overload2_arg3)" 136 "(anonymous namespace)::struct_overload2_test::overload2_function(overload2_arg4)" 137 "ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)" 138 "ns_overload2_test::(anonymous namespace)::ns_overload2_test::struct_overload2_test::overload2_function(overload2_arga)" 139 "ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)" 140 "ns_overload2_test::(anonymous namespace)::struct_overload2_test::overload2_function(overload2_arg8)" 141 "ns_overload2_test::overload2_function(overload2_arg5)" 142 "ns_overload2_test::struct_overload2_test::overload2_function(overload2_arg6)" 143 "overload2_function(overload2_arg1)" 144 "struct_overload2_test::overload2_function(overload2_arg2)" 145 } 146 foreach cmd_prefix {"b" "b -function"} { 147 test_gdb_complete_multiple \ 148 "$cmd_prefix " "overload2_func" "tion(overload2_arg" $completion_list 149 check_bp_locations_match_list \ 150 "$cmd_prefix overload2_function" $completion_list 151 } 152 } 153 154 # Same, but restrict to functions/methods in some scope. 155 with_test_prefix "restrict scope" { 156 set completion_list { 157 "ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)" 158 "ns_overload2_test::overload2_function(overload2_arg5)" 159 } 160 foreach cmd_prefix {"b" "b -function"} { 161 test_gdb_complete_multiple \ 162 "$cmd_prefix " "ns_overload2_test::overload2_func" "tion(overload2_arg" $completion_list 163 check_bp_locations_match_list \ 164 "$cmd_prefix ns_overload2_test::overload2_function" $completion_list 165 } 166 } 167 168 # Restrict to anonymous namespace scopes. 169 with_test_prefix "restrict scope 2" { 170 set completion_list { 171 "(anonymous namespace)::overload2_function(overload2_arg3)" 172 "ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)" 173 } 174 foreach cmd_prefix {"b" "b -function"} { 175 test_gdb_complete_multiple \ 176 "$cmd_prefix " "(anonymous namespace)::overload2_func" "tion(overload2_arg" $completion_list 177 check_bp_locations_match_list \ 178 "$cmd_prefix (anonymous namespace)::overload2_function" $completion_list 179 } 180 } 181 182 # Add enough scopes, and we get a unique completion. 183 with_test_prefix "unique completion" { 184 foreach cmd_prefix {"b" "b -function"} { 185 test_gdb_complete_unique \ 186 "$cmd_prefix ns_overload2_test::(anonymous namespace)::overload2_func" \ 187 "$cmd_prefix ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)" 188 check_setting_bp_fails "$cmd_prefix ns_overload2_test::(anonymous namespace)::overload2_func" 189 check_bp_locations_match_list \ 190 "$cmd_prefix ns_overload2_test::(anonymous namespace)::overload2_function" \ 191 {"ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)"} 192 } 193 } 194} 195 196# Test linespecs / locations using fully-qualified names. 197 198proc_with_prefix fqn {} { 199 200 # "-qualified" works with both explicit locations and linespecs. 201 # Also test that combining a source file with a function name 202 # still results in a full match, with both linespecs and explicit 203 # locations. 204 foreach cmd_prefix { 205 "b -qualified " 206 "b -qualified -function " 207 "b -qualified cpls.cc:" 208 "b -qualified -source cpls.cc -function " 209 "b -source cpls.cc -qualified -function " 210 } { 211 test_gdb_complete_unique \ 212 "${cmd_prefix}overload2_func" \ 213 "${cmd_prefix}overload2_function(overload2_arg1)" 214 215 # Drill down until we find a unique completion. 216 test_gdb_complete_multiple "${cmd_prefix}" "ns_overload2_test::" "" { 217 "ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)" 218 "ns_overload2_test::(anonymous namespace)::ns_overload2_test::struct_overload2_test::overload2_function(overload2_arga)" 219 "ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)" 220 "ns_overload2_test::(anonymous namespace)::struct_overload2_test::overload2_function(overload2_arg8)" 221 "ns_overload2_test::overload2_function(overload2_arg5)" 222 "ns_overload2_test::struct_overload2_test::overload2_function(overload2_arg6)" 223 } 224 225 test_gdb_complete_multiple "${cmd_prefix}" "ns_overload2_test::(anonymous namespace)::" "" { 226 "ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)" 227 "ns_overload2_test::(anonymous namespace)::ns_overload2_test::struct_overload2_test::overload2_function(overload2_arga)" 228 "ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)" 229 "ns_overload2_test::(anonymous namespace)::struct_overload2_test::overload2_function(overload2_arg8)" 230 } 231 232 test_gdb_complete_multiple "${cmd_prefix}" "ns_overload2_test::(anonymous namespace)::ns_overload2_test::" "" { 233 "ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)" 234 "ns_overload2_test::(anonymous namespace)::ns_overload2_test::struct_overload2_test::overload2_function(overload2_arga)" 235 } 236 237 test_gdb_complete_unique \ 238 "${cmd_prefix}ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_func" \ 239 "${cmd_prefix}ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)" 240 241 } 242} 243 244# Check that a fully-qualified lookup name doesn't match symbols in 245# nested scopes. 246 247proc_with_prefix fqn-2 {} { 248 set linespec "struct_overload2_test::overload2_function(overload2_arg6)" 249 set cmd_prefix "b -qualified" 250 check_setting_bp_fails "$cmd_prefix $linespec" 251 test_gdb_complete_none "$cmd_prefix $linespec" 252 253 # Check that using the same name, but not fully-qualifying it, 254 # would find something, just to make sure the test above is 255 # testing what we intend to test. 256 set cmd_prefix "b -function" 257 test_gdb_complete_unique "$cmd_prefix $linespec" "$cmd_prefix $linespec" 258 check_bp_locations_match_list \ 259 "$cmd_prefix $linespec" \ 260 {"ns_overload2_test::struct_overload2_test::overload2_function(overload2_arg6)"} 261} 262 263# Test completion of functions in different scopes that have the same 264# name and parameters. Restricting the scopes should find fewer and 265# fewer matches. 266 267proc_with_prefix overload-3 {} { 268 with_test_prefix "all overloads" { 269 set completion_list { 270 "(anonymous namespace)::overload3_function(int)" 271 "(anonymous namespace)::overload3_function(long)" 272 "(anonymous namespace)::struct_overload3_test::overload3_function(int)" 273 "(anonymous namespace)::struct_overload3_test::overload3_function(long)" 274 "ns_overload3_test::(anonymous namespace)::ns_overload3_test::overload3_function(int)" 275 "ns_overload3_test::(anonymous namespace)::ns_overload3_test::overload3_function(long)" 276 "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(int)" 277 "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(long)" 278 "ns_overload3_test::(anonymous namespace)::overload3_function(int)" 279 "ns_overload3_test::(anonymous namespace)::overload3_function(long)" 280 "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(int)" 281 "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(long)" 282 "ns_overload3_test::overload3_function(int)" 283 "ns_overload3_test::overload3_function(long)" 284 "ns_overload3_test::struct_overload3_test::overload3_function(int)" 285 "ns_overload3_test::struct_overload3_test::overload3_function(long)" 286 "overload3_function(int)" 287 "overload3_function(long)" 288 "struct_overload3_test::overload3_function(int)" 289 "struct_overload3_test::overload3_function(long)" 290 } 291 foreach cmd_prefix {"b" "b -function"} { 292 test_gdb_complete_multiple "$cmd_prefix " "overload3_func" "tion(" $completion_list 293 check_bp_locations_match_list "$cmd_prefix overload3_function" $completion_list 294 } 295 } 296 297 with_test_prefix "restrict overload" { 298 foreach cmd_prefix {"b" "b -function"} { 299 test_gdb_complete_unique \ 300 "$cmd_prefix overload3_function(int)" \ 301 "$cmd_prefix overload3_function(int)" 302 check_bp_locations_match_list "$cmd_prefix overload3_function(int)" { 303 "(anonymous namespace)::overload3_function(int)" 304 "(anonymous namespace)::struct_overload3_test::overload3_function(int)" 305 "ns_overload3_test::(anonymous namespace)::ns_overload3_test::overload3_function(int)" 306 "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(int)" 307 "ns_overload3_test::(anonymous namespace)::overload3_function(int)" 308 "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(int)" 309 "ns_overload3_test::overload3_function(int)" 310 "ns_overload3_test::struct_overload3_test::overload3_function(int)" 311 "overload3_function(int)" 312 "struct_overload3_test::overload3_function(int)" 313 } 314 } 315 } 316 317 with_test_prefix "restrict scope" { 318 set completion_list { 319 "(anonymous namespace)::struct_overload3_test::overload3_function(int)" 320 "(anonymous namespace)::struct_overload3_test::overload3_function(long)" 321 "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(int)" 322 "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(long)" 323 "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(int)" 324 "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(long)" 325 "ns_overload3_test::struct_overload3_test::overload3_function(int)" 326 "ns_overload3_test::struct_overload3_test::overload3_function(long)" 327 "struct_overload3_test::overload3_function(int)" 328 "struct_overload3_test::overload3_function(long)" 329 } 330 foreach cmd_prefix {"b" "b -function"} { 331 test_gdb_complete_multiple \ 332 "$cmd_prefix " "struct_overload3_test::overload3_func" "tion(" \ 333 $completion_list 334 check_bp_locations_match_list \ 335 "$cmd_prefix struct_overload3_test::overload3_function" \ 336 $completion_list 337 } 338 } 339} 340 341# Test completing an overloaded template method. 342 343proc_with_prefix template-overload {} { 344 set completion_list { 345 "template_struct<int>::template_overload_fn(int)" 346 "template_struct<long>::template_overload_fn(long)" 347 } 348 foreach cmd_prefix {"b" "b -function"} { 349 test_gdb_complete_multiple "$cmd_prefix " "template_overload_fn" "(" $completion_list 350 check_bp_locations_match_list "$cmd_prefix template_overload_fn" $completion_list 351 check_bp_locations_match_list \ 352 "$cmd_prefix template_struct<int>::template_overload_fn" \ 353 "template_struct<int>::template_overload_fn(int)" 354 } 355} 356 357# Test completing template methods with non-void return type. 358 359proc_with_prefix template-ret-type {} { 360 set method_name "template2_fn<int, int>" 361 set param_list "(template2_ret_type<int>, int, int)" 362 set struct_type "template2_struct<template2_ret_type<int> >" 363 set ret_type "template2_ret_type<int>" 364 365 # Templates are listed both with and without return type, making 366 # "template2_<tab>" ambiguous. 367 foreach cmd_prefix {"b" "b -function"} { 368 set completion_list \ 369 [list \ 370 "${ret_type} ${struct_type}::${method_name}${param_list}" \ 371 "${struct_type}::${method_name}${param_list}"] 372 test_gdb_complete_multiple "$cmd_prefix " "template2_" "" $completion_list 373 374 # Add one character more after "2_", and the linespec becomes 375 # unambiguous. Test completing the whole prefix range after that, 376 # thus testing completing either with or without return type. 377 foreach {s t} [list \ 378 "template2_r" \ 379 "${ret_type} ${struct_type}::${method_name}${param_list}" \ 380 "template2_s" \ 381 "${struct_type}::${method_name}${param_list}"] { 382 set linespec $t 383 set complete_line "$cmd_prefix $linespec" 384 set start [index_after $s $complete_line] 385 test_complete_prefix_range $complete_line $start 386 } 387 388 # Setting a breakpoint without the template params doesn't work. 389 check_setting_bp_fails "$cmd_prefix template2_fn" 390 # However, setting a breakpoint with template params and without 391 # the method params does work, just like with non-template 392 # functions. It also works with or without return type. 393 foreach linespec [list \ 394 "${method_name}" \ 395 "${method_name}${param_list}" \ 396 "${struct_type}::${method_name}" \ 397 "${struct_type}::${method_name}${param_list}" \ 398 "${ret_type} ${struct_type}::${method_name}" \ 399 "${ret_type} ${struct_type}::${method_name}${param_list}"] { 400 check_bp_locations_match_list \ 401 "$cmd_prefix $linespec" \ 402 [list "${struct_type}::${method_name}${param_list}"] 403 } 404 } 405} 406 407# Test completion of a const-overloaded funtion (const-overload). 408# Note that "const" appears after the function/method parameters. 409 410proc_with_prefix const-overload {} { 411 set completion_list { 412 "struct_with_const_overload::const_overload_fn()" 413 "struct_with_const_overload::const_overload_fn() const" 414 } 415 foreach cmd_prefix {"b" "b -function"} { 416 test_gdb_complete_multiple \ 417 "$cmd_prefix " "const_overload_fn" "()" \ 418 $completion_list 419 test_gdb_complete_multiple \ 420 "$cmd_prefix " "const_overload_fn ( " ")" \ 421 $completion_list 422 test_gdb_complete_multiple \ 423 "$cmd_prefix " "const_overload_fn()" "" \ 424 $completion_list 425 426 check_bp_locations_match_list \ 427 "$cmd_prefix const_overload_fn" \ 428 {"struct_with_const_overload::const_overload_fn()" 429 "struct_with_const_overload::const_overload_fn() const"} 430 431 check_setting_bp_fails "$cmd_prefix const_overload_fn(" 432 check_bp_locations_match_list \ 433 "$cmd_prefix const_overload_fn()" \ 434 {"struct_with_const_overload::const_overload_fn()"} 435 check_bp_locations_match_list \ 436 "$cmd_prefix const_overload_fn() const" \ 437 {"struct_with_const_overload::const_overload_fn() const"} 438 } 439} 440 441# Same but quote-enclose the function name. This makes the overload 442# no longer be ambiguous. 443 444proc_with_prefix const-overload-quoted {} { 445 foreach cmd_prefix {"b" "b -function"} { 446 set linespec "'const_overload_fn()'" 447 test_gdb_complete_unique "$cmd_prefix $linespec" "$cmd_prefix $linespec" 448 check_bp_locations_match_list \ 449 "$cmd_prefix $linespec" { 450 "struct_with_const_overload::const_overload_fn()" 451 } 452 453 set linespec "'const_overload_fn() const'" 454 test_gdb_complete_unique "$cmd_prefix $linespec" "$cmd_prefix $linespec" 455 check_bp_locations_match_list \ 456 "$cmd_prefix $linespec" { 457 "struct_with_const_overload::const_overload_fn() const" 458 } 459 } 460} 461 462# Test that when the function is unambiguous, linespec completion 463# appends the end quote char automatically, both ' and ". 464 465proc_with_prefix append-end-quote-char-when-unambiguous {} { 466 foreach cmd_prefix {"b" "b -function"} { 467 foreach qc $completion::all_quotes_list { 468 set linespec "${qc}not_overloaded_fn()${qc}" 469 foreach cmd [list "$cmd_prefix ${qc}not_overloaded_fn()" \ 470 "$cmd_prefix ${qc}not_overloaded_fn" \ 471 "$cmd_prefix ${qc}not_overloaded_"] { 472 test_gdb_complete_unique $cmd "$cmd_prefix $linespec" 473 } 474 check_bp_locations_match_list \ 475 "$cmd_prefix $linespec" {"not_overloaded_fn()"} 476 } 477 } 478} 479 480# Test completing symbols of source files. 481 482proc_with_prefix in-source-file-unconstrained {} { 483 # First test that unconstrained matching picks up functions from 484 # multiple files. 485 test_gdb_complete_multiple "b " "file_constrained_test" "_cpls" { 486 "file_constrained_test_cpls2_function(int)" 487 "file_constrained_test_cpls_function(int)" 488 } 489 check_setting_bp_fails "b file_constrained_test_cpls" 490} 491 492# Test an unambiguous completion that would be ambiguous if it weren't 493# for the source file component, due to 494# "file_constrained_test_cpls_function" in cpls.cc. Test with 495# different components quoted, and with whitespace before the function 496# name. 497 498proc_with_prefix in-source-file-unambiguous {} { 499 foreach sqc $completion::maybe_quoted_list { 500 foreach fqc $completion::maybe_quoted_list { 501 # Linespec. 502 foreach sep {":" ": "} { 503 set linespec \ 504 "${sqc}cpls2.cc${sqc}${sep}${fqc}file_constrained_test_cpls2_function(int)${fqc}" 505 set complete_line "b $linespec" 506 set start [index_after "constrained_test" $complete_line] 507 set input_line [string range $complete_line 0 $start] 508 test_gdb_complete_unique $input_line ${complete_line} 509 check_bp_locations_match_list "b $linespec" { 510 "file_constrained_test_cpls2_function(int)" 511 } 512 } 513 514 # Explicit location. 515 set source_opt "-source ${sqc}cpls2.cc${sqc}" 516 set function_opt "-function ${fqc}file_constrained_test_cpls2_function(int)${fqc}" 517 set complete_line "b $source_opt $function_opt" 518 set start [index_after "cpls2_functio" $complete_line] 519 set input_line [string range $complete_line 0 $start] 520 test_gdb_complete_unique $input_line ${complete_line} 521 check_bp_locations_match_list "$complete_line" { 522 "file_constrained_test_cpls2_function(int)" 523 } 524 } 525 } 526} 527 528# Test an ambiguous completion constrained by a source file. Test 529# with different components quoted, and with whitespace before the 530# function name. 531 532proc_with_prefix in-source-file-ambiguous {} { 533 foreach sqc $completion::maybe_quoted_list { 534 foreach fqc $completion::maybe_quoted_list { 535 # Linespec. 536 foreach sep {":" ": "} { 537 set cmd_prefix "b ${sqc}cpls2.cc${sqc}${sep}" 538 test_gdb_complete_multiple "${cmd_prefix}" ${fqc} "" { 539 "another_file_constrained_test_cpls2_function(int)" 540 "file_constrained_test_cpls2_function(int)" 541 } ${fqc} ${fqc} 542 } 543 544 # Explicit location. 545 test_gdb_complete_multiple \ 546 "b -source ${sqc}cpls2.cc${sqc} -function " ${fqc} "" { 547 "another_file_constrained_test_cpls2_function(int)" 548 "file_constrained_test_cpls2_function(int)" 549 } ${fqc} ${fqc} 550 } 551 } 552} 553 554# Check that completing a file name in a linespec auto-appends a colon 555# instead of a whitespace character. 556 557proc_with_prefix source-complete-appends-colon {} { 558 # Test with quotes to make sure the end quote char is put at the 559 # right place. 560 foreach qc $completion::maybe_quoted_list { 561 test_gdb_complete_unique \ 562 "b ${qc}cpls2." \ 563 "b ${qc}cpls2.cc${qc}" ":" 564 test_gdb_complete_unique \ 565 "b ${qc}cpls2.c" \ 566 "b ${qc}cpls2.cc${qc}" ":" 567 test_gdb_complete_unique \ 568 "b ${qc}cpls2.cc" \ 569 "b ${qc}cpls2.cc${qc}" ":" 570 571 # Same, but with a filename with an hyphen (which is normally 572 # a language word break char). 573 test_gdb_complete_unique \ 574 "b ${qc}cpls-" \ 575 "b ${qc}cpls-hyphen.cc${qc}" ":" 576 test_gdb_complete_unique \ 577 "b ${qc}cpls-hyphen" \ 578 "b ${qc}cpls-hyphen.cc${qc}" ":" 579 } 580 581 # Test the same, but with the name of a nonexisting file. 582 583 # Cursor at the end of the string. 584 test_gdb_complete_none "b nonexistingfilename.cc" 585 # Cursor past the end of the string. 586 test_gdb_complete_multiple "b nonexistingfilename.cc " "" "" \ 587 $completion::keyword_list 588 foreach qc $completion::all_quotes_list { 589 # Unterminated quote. 590 test_gdb_complete_none "b ${qc}nonexistingfilename.cc" 591 test_gdb_complete_none "b ${qc}nonexistingfilename.cc " 592 # Terminated quote, cursor at the quote. 593 test_gdb_complete_unique \ 594 "b ${qc}nonexistingfilename.cc${qc}" \ 595 "b ${qc}nonexistingfilename.cc${qc}" 596 # Terminated quote, cursor past the quote. 597 test_gdb_complete_multiple \ 598 "b ${qc}nonexistingfilename.cc${qc} " "" "" \ 599 $completion::keyword_list 600 } 601} 602 603#################################################################### 604 605# Test that a colon at the end of the linespec is understood as an 606# incomplete scope operator (incomplete-scope-colon), instead of a 607# source/function separator. 608 609proc_with_prefix incomplete-scope-colon {} { 610 611 # Helper for the loop below to simplify it. Tests completion of 612 # the range defined by the RANGE_SS found in the constructed line. 613 # 614 # E.g., with: 615 # 616 # source="source.cc" 617 # fqc="'" 618 # prototype="ns::function()" 619 # range_ss="s::f" 620 # 621 # we'd try completing with the cursor set in each of the 622 # underlined range's positions of: 623 # 624 # b source.cc:'ns::function()'" 625 # ^^^^ 626 # 627 # Also test that setting a breakpoint at the constructed line 628 # finds the same breakpoint location as completion does. 629 # 630 proc incomplete_scope_colon_helper {prototype range_ss {skip_check_bp 0}} { 631 foreach source {"" "cpls.cc"} { 632 # Test with and without source quoting. 633 foreach sqc $completion::maybe_quoted_list { 634 if {$source == "" && $sqc != ""} { 635 # Invalid combination. 636 continue 637 } 638 639 # Test with and without function quoting. 640 foreach fqc $completion::maybe_quoted_list { 641 if {$source == ""} { 642 set linespec_source "" 643 set explicit_source "" 644 } else { 645 set linespec_source "${sqc}${source}${sqc}:" 646 set explicit_source "-source ${sqc}${source}${sqc}" 647 } 648 649 # Even though this use case is trickier with 650 # linespecs due to the ":" as separator, test both 651 # linespecs and explicit locations for 652 # completeness. 653 foreach location [list \ 654 "${linespec_source}${fqc}$prototype${fqc}" \ 655 "${explicit_source} -function ${fqc}$prototype${fqc}"] { 656 set complete_line "b $location" 657 set start [string first $range_ss $complete_line] 658 set end [expr ($start + [string length $range_ss])] 659 test_complete_prefix_range $complete_line $start $end 660 if {!$skip_check_bp} { 661 check_bp_locations_match_list "b $location" [list "$prototype"] 662 } 663 } 664 } 665 } 666 } 667 } 668 669 incomplete_scope_colon_helper \ 670 "struct_incomplete_scope_colon_test::incomplete_scope_colon_test()" \ 671 "t::i" 672 673 incomplete_scope_colon_helper \ 674 "ns_incomplete_scope_colon_test::incomplete_scope_colon_test()" \ 675 "t::i" 676 677 # Test completing around both "::"s. 678 foreach range_ss {"t::s" "t::i"} skip_check_bp {0 1} { 679 incomplete_scope_colon_helper \ 680 "ns2_incomplete_scope_colon_test::struct_in_ns2_incomplete_scope_colon_test::incomplete_scope_colon_test()" \ 681 $range_ss $skip_check_bp 682 } 683} 684 685# Test completing functions/methods in anonymous namespaces. 686 687proc_with_prefix anon-ns {} { 688 foreach cmd_prefix {"b" "b -function"} { 689 foreach qc $completion::maybe_quoted_list { 690 test_gdb_complete_unique \ 691 "$cmd_prefix ${qc}anon_ns_function" \ 692 "$cmd_prefix ${qc}anon_ns_function()${qc}" 693 check_bp_locations_match_list "$cmd_prefix ${qc}anon_ns_function()${qc}" { 694 "(anonymous namespace)::anon_ns_function()" 695 "(anonymous namespace)::anon_ns_struct::anon_ns_function()" 696 "the_anon_ns_wrapper_ns::(anonymous namespace)::anon_ns_function()" 697 "the_anon_ns_wrapper_ns::(anonymous namespace)::anon_ns_struct::anon_ns_function()" 698 } 699 } 700 701 # A "(" finds all anonymous namespace functions/methods in all 702 # scopes. 703 test_gdb_complete_multiple "$cmd_prefix " "(" "anonymous namespace)::" { 704 "(anonymous namespace)::anon_ns_function()" 705 "(anonymous namespace)::anon_ns_struct::anon_ns_function()" 706 "(anonymous namespace)::overload2_function(overload2_arg3)" 707 "(anonymous namespace)::overload3_function(int)" 708 "(anonymous namespace)::overload3_function(long)" 709 "(anonymous namespace)::struct_overload2_test::overload2_function(overload2_arg4)" 710 "(anonymous namespace)::struct_overload3_test::overload3_function(int)" 711 "(anonymous namespace)::struct_overload3_test::overload3_function(long)" 712 "ns_overload2_test::(anonymous namespace)::ns_overload2_test::overload2_function(overload2_arg9)" 713 "ns_overload2_test::(anonymous namespace)::ns_overload2_test::struct_overload2_test::overload2_function(overload2_arga)" 714 "ns_overload2_test::(anonymous namespace)::overload2_function(overload2_arg7)" 715 "ns_overload2_test::(anonymous namespace)::struct_overload2_test::overload2_function(overload2_arg8)" 716 "ns_overload3_test::(anonymous namespace)::ns_overload3_test::overload3_function(int)" 717 "ns_overload3_test::(anonymous namespace)::ns_overload3_test::overload3_function(long)" 718 "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(int)" 719 "ns_overload3_test::(anonymous namespace)::ns_overload3_test::struct_overload3_test::overload3_function(long)" 720 "ns_overload3_test::(anonymous namespace)::overload3_function(int)" 721 "ns_overload3_test::(anonymous namespace)::overload3_function(long)" 722 "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(int)" 723 "ns_overload3_test::(anonymous namespace)::struct_overload3_test::overload3_function(long)" 724 "the_anon_ns_wrapper_ns::(anonymous namespace)::anon_ns_function()" 725 "the_anon_ns_wrapper_ns::(anonymous namespace)::anon_ns_struct::anon_ns_function()" 726 } 727 728 set function "the_anon_ns_wrapper_ns::(anonymous namespace)::anon_ns_function()" 729 test_gdb_complete_unique "$cmd_prefix $function" "$cmd_prefix $function" 730 check_bp_locations_match_list "$cmd_prefix $function" [list $function] 731 732 # Test completing after the "(anonymous namespace)" part. 733 test_gdb_complete_unique \ 734 "$cmd_prefix the_anon_ns_wrapper_ns::(anonymous namespace)::anon_ns_fu" \ 735 "$cmd_prefix $function" 736 737 # Test whitespace in the "(anonymous namespace)" component. 738 739 test_gdb_complete_unique \ 740 "$cmd_prefix the_anon_ns_wrapper_ns::( anonymous namespace )::anon_ns_fu" \ 741 "$cmd_prefix the_anon_ns_wrapper_ns::( anonymous namespace )::anon_ns_function()" 742 check_setting_bp_fails \ 743 "$cmd_prefix the_anon_ns_wrapper_ns::( anonymous namespace )::anon_ns_fu" 744 745 set function_ws \ 746 "the_anon_ns_wrapper_ns::( anonymous namespace )::anon_ns_function ( )" 747 test_gdb_complete_unique "$cmd_prefix $function_ws" "$cmd_prefix $function_ws" 748 check_bp_locations_match_list "$cmd_prefix $function_ws" [list $function] 749 } 750} 751 752# Basic test for completing "operator<". More extensive C++ operator 753# tests in cpls-op.exp. 754 755proc_with_prefix operator< {} { 756 # Complete all prefixes between "oper" and the whole prototype. 757 set function "operator<(foo_enum, foo_enum)" 758 foreach cmd_prefix {"b" "b -function"} { 759 set line "$cmd_prefix $function" 760 set start [index_after "oper" $line] 761 test_complete_prefix_range $line $start 762 } 763 764 # There's a label in the function; try completing it. (Exhaustive 765 # label completion tests further below.) 766 foreach location [list \ 767 "$function:label1" \ 768 "-function $function -label label1"] { 769 770 set cmd "b $location" 771 set input_line [string range $cmd 0 [expr [string length $cmd] - 3]] 772 773 test_gdb_complete_unique $input_line $cmd 774 test_gdb_complete_unique $cmd $cmd 775 check_bp_locations_match_list $cmd [list "$location"] 776 } 777} 778 779# Test completion of scopes with an ambiguous prefix. 780 781proc_with_prefix ambiguous-prefix {} { 782 foreach cmd_prefix {"b" "b -function"} { 783 test_gdb_complete_multiple "$cmd_prefix " "ambiguous_pre" "fix_" { 784 "ambiguous_prefix_global_func()" 785 "the_ambiguous_prefix_ns::ambiguous_prefix_ns_func()" 786 "the_ambiguous_prefix_struct::ambiguous_prefix_method()" 787 } 788 check_setting_bp_fails "$cmd_prefix ambiguous_prefix_" 789 } 790} 791 792# Test completion of function labels. 793 794proc_with_prefix function-labels {} { 795 # Test with and without a source file component. 796 foreach_location_functions \ 797 { "" "cpls.cc" } \ 798 { "function_with_labels(int)" } \ 799 { 800 # Linespec version. Test various spacing around the label 801 # colon separator. 802 foreach label_sep {":" " :" ": " " : "} { 803 set linespec "${location}${label_sep}" 804 test_gdb_complete_multiple "b $linespec" "l" "abel" { 805 "label1" 806 "label2" 807 } 808 check_setting_bp_fails "b ${linespec}label" 809 810 set tsep [string trim ${source_sep}] 811 check_bp_locations_match_list \ 812 "b ${linespec}label1" [list "${source}${tsep}${function}:label1"] 813 check_bp_locations_match_list \ 814 "b ${linespec}label2" [list "${source}${tsep}${function}:label2"] 815 } 816 } \ 817 { 818 # Explicit locations version. 819 append location " -label" 820 test_gdb_complete_multiple "b $location " "l" "abel" { 821 "label1" 822 "label2" 823 } 824 check_setting_bp_fails "b $location label" 825 826 if {$source != ""} { 827 set bp_loc_src "-source ${source} " 828 } else { 829 set bp_loc_src "" 830 } 831 check_bp_locations_match_list \ 832 "b ${location} label1" [list "${bp_loc_src}-function $function -label label1"] 833 check_bp_locations_match_list \ 834 "b ${location} label2" [list "${bp_loc_src}-function $function -label label2"] 835 } 836} 837 838# Test that completion after a function name offers keyword 839# (if/task/thread) matches in linespec mode, and also the explicit 840# location options in explicit locations mode. 841 842proc_with_prefix keywords-after-function {} { 843 set explicit_list \ 844 [concat $completion::explicit_opts_list $completion::keyword_list] 845 846 # Test without a source file, with a known source file, and with 847 # and unknown source file. 848 # Test a known and an unknown function. 849 foreach_location_functions \ 850 { "" "cpls.cc" "unknown_file.cc" } \ 851 { "function_with_labels(int)" "unknown_function(int)" } \ 852 { 853 # Linespec version. 854 test_gdb_complete_multiple "b ${location} " "" "" \ 855 $completion::keyword_list 856 } \ 857 { 858 # Explicit locations version. 859 test_gdb_complete_multiple "b ${location} " "" "" \ 860 $explicit_list 861 } 862} 863 864# Same, but after a label. 865 866proc_with_prefix keywords-after-label {} { 867 set explicit_list \ 868 [concat $completion::explicit_opts_list $completion::keyword_list] 869 870 foreach_location_labels \ 871 { "" "cpls.cc" } \ 872 { "function_with_labels(int)" "unknown_function(int)" } \ 873 { "label1" "non_existing_label" } \ 874 { 875 # Linespec version. 876 test_gdb_complete_multiple "b ${location} " "" "" \ 877 $completion::keyword_list 878 } \ 879 { 880 # Explicit locations version. 881 test_gdb_complete_multiple "b ${location} " "" "" \ 882 $explicit_list 883 } 884} 885 886# Similar, but after an unknown file, and in linespec mode only. 887 888proc_with_prefix keywords-after-unknown-file {} { 889 # Test with and without quoting. 890 foreach qc $completion::maybe_quoted_list { 891 set line "b ${qc}unknown_file.cc${qc}: " 892 test_gdb_complete_multiple $line "" "" $completion::keyword_list 893 } 894} 895 896# Test that linespec / function completion does not match data 897# symbols, only functions/methods. 898 899proc_with_prefix no-data-symbols {} { 900 foreach cmd_prefix {"b" "b -function"} { 901 test_gdb_complete_unique "$cmd_prefix code_" "$cmd_prefix code_function()" 902 } 903} 904 905 906# After "if", we expect an expression, which has a different completer 907# that matches data symbols as well. Check that that works. 908 909proc_with_prefix if-expression {} { 910 foreach cmd_prefix {"b" "b -function"} { 911 test_gdb_complete_multiple "$cmd_prefix function() if " "code_" "" { 912 "code_data" 913 "code_function()" 914 } 915 916 test_gdb_complete_unique \ 917 "$cmd_prefix function() if code_data + another_da" \ 918 "$cmd_prefix function() if code_data + another_data" 919 920 test_gdb_complete_unique \ 921 "$cmd_prefix non_existing_function() if code_data + another_da" \ 922 "$cmd_prefix non_existing_function() if code_data + another_data" 923 924 # FIXME: For now, thread and task also use the expression 925 # completer. 926 test_gdb_complete_unique \ 927 "$cmd_prefix function() thread code_data + another_da" \ 928 "$cmd_prefix function() thread code_data + another_data" 929 test_gdb_complete_unique \ 930 "$cmd_prefix function() task code_data + another_da" \ 931 "$cmd_prefix function() task code_data + another_data" 932 } 933} 934 935# The testcase driver. Calls all test procedures. 936 937proc test_driver {} { 938 all-param-prefixes 939 overload 940 overload-2 941 fqn 942 fqn-2 943 overload-3 944 template-overload 945 template-ret-type 946 const-overload 947 const-overload-quoted 948 append-end-quote-char-when-unambiguous 949 in-source-file-unconstrained 950 in-source-file-unambiguous 951 in-source-file-ambiguous 952 source-complete-appends-colon 953 incomplete-scope-colon 954 anon-ns 955 operator< 956 ambiguous-prefix 957 function-labels 958 keywords-after-function 959 keywords-after-label 960 keywords-after-unknown-file 961 no-data-symbols 962 if-expression 963} 964 965test_driver 966