gdb/testsuite/gdb.base/completion.exp

   1 # Copyright 1998, 1999, 2002, 2003, 2004, 2007, 2008, 2009, 2010, 2011
   2 # Free Software Foundation, Inc.
   3
   4 # This program is free software; you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation; either version 3 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 # This file was written by Elena Zannoni (ezannoni@cygnus.com)
  18
  19 # This file is part of the gdb testsuite.
  20
  21 #
  22 # tests for command completion
  23 #
  24 # Here are some useful test cases for completion.
  25 # They should be tested with both M-? and TAB.
  26 #
  27 #   "show output-" "radix"
  28 #   "show output" "-radix"
  29 #   "p" ambiguous (commands starting with p--path, print, printf, etc.)
  30 #   "p "  ambiguous (all symbols)
  31 #   "info t foo" no completions
  32 #   "info t " no completions
  33 #   "info t" ambiguous ("info target", "info terminal", etc.)
  34 #   "info ajksdlfk" no completions
  35 #   "info ajksdlfk " no completions
  36 #   "info" " "
  37 #   "info " ambiguous (all info commands)
  38 #   "p \"break1" unambiguous (completes to filename "break1.c")
  39 #   "p \"break1." unambiguous (should complete to "break1.c" but does not,
  40 #       due to readline limitations)
  41 #   "p 'arg" ambiguous (all symbols starting with arg)
  42 #   "p b-arg" ambiguous (all symbols starting with arg)
  43 #   "p b-" ambiguous (all symbols)
  44 #   "file Make" "file" (word break hard to screw up here)
  45 #   "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
  46 #
  47
  48
  49 if $tracelevel then {
  50         strace $tracelevel
  51         }
  52
  53
  54 global usestubs
  55
  56 #
  57 # test running programs
  58 #
  59
  60 set testfile "break"
  61 set srcfile ${testfile}.c
  62 set srcfile1 ${testfile}1.c
  63 set binfile ${objdir}/${subdir}/${testfile}
  64
  65 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}0.o" object {debug nowarnings}] != "" } {
  66      untested completion.exp
  67      return -1
  68 }
  69
  70 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile1}" "${binfile}1.o" object {debug nowarnings}] != "" } {
  71      untested completion.exp
  72      return -1
  73 }
  74
  75 if  { [gdb_compile "${binfile}0.o ${binfile}1.o" "${binfile}" executable {debug nowarnings}] != "" } {
  76      untested completion.exp
  77      return -1
  78 }
  79
  80 if [get_compiler_info ${binfile}] {
  81     return -1;
  82 }
  83
  84 gdb_exit
  85
  86 gdb_start
  87 gdb_reinitialize_dir $srcdir/$subdir
  88 gdb_load ${binfile}
  89
  90 if ![runto_main] then {
  91         perror "tests suppressed"
  92 }
  93
  94 set oldtimeout1 $timeout
  95 set timeout 30
  96
  97
  98 send_gdb "hfgfh\t"
  99 sleep 1
 100 gdb_expect  {
 101         -re "^hfgfh\\\x07$"\
 102             { send_gdb "\n"
 103               gdb_expect {
 104                       -re "Undefined command: \"hfgfh\"\\.  Try \"help\"\\..*$gdb_prompt $"\
 105                                         { pass "complete 'hfgfh'"}
 106                       -re ".*$gdb_prompt $" { fail "complete 'hfgfh'"}
 107                       timeout           {fail "(timeout) complete 'hfgfh'"}
 108                      }
 109             }
 110         -re ".*$gdb_prompt $"       { fail "complete 'hfgfh'" }
 111         timeout         { fail "(timeout) complete 'hfgfh'" }
 112         }
 113
 114 #exp_internal 0
 115
 116 send_gdb "show output\t"
 117 sleep 1
 118 gdb_expect  {
 119         -re "^show output-radix $"\
 120             { send_gdb "\n"
 121               gdb_expect {
 122                       -re "Default output radix for printing of values is 10\\..*$gdb_prompt $"\
 123                                         { pass "complete 'show output'"}
 124                       -re ".*$gdb_prompt $" { fail "complete 'show output'"}
 125                       timeout           {fail "(timeout) complete 'show output'"}
 126                      }
 127             }
 128         -re "^show output$"\
 129             { send_gdb "\n"
 130                gdb_expect {
 131                       -re "Default output radix for printing of values is 10\\..*$gdb_prompt $"\
 132                                         { fail "complete 'show output'"}
 133                       -re ".*$gdb_prompt $" { fail "complete 'show output'"}
 134                       timeout           { fail "(timeout) complete 'show output'"}
 135                      }
 136
 137              }
 138
 139         -re ".*$gdb_prompt $"       { fail "complete 'show output'" }
 140         timeout         { fail "(timeout) complete 'show output'" }
 141         }
 142
 143
 144 send_gdb "show output-\t"
 145 sleep 1
 146 gdb_expect  {
 147         -re "^show output-radix $"\
 148             { send_gdb "\n"
 149               gdb_expect {
 150                       -re "Default output radix for printing of values is 10\\..*$gdb_prompt $"\
 151                                         { pass "complete 'show output-'"}
 152                       -re ".*$gdb_prompt $" { fail "complete 'show output-'"}
 153                       timeout           {fail "(timeout) complete 'show output-'"}
 154                      }
 155             }
 156         -re "^show output-$"\
 157             { send_gdb "\n"
 158                gdb_expect {
 159                       -re "Default output radix for printing of values is 10\\..*$gdb_prompt $"\
 160                                         { fail "complete 'show output-'"}
 161                       -re ".*$gdb_prompt $" { fail "complete 'show output-'"}
 162                       timeout           { fail "(timeout) complete 'show output-'"}
 163                      }
 164
 165              }
 166
 167         -re ".*$gdb_prompt $"       { fail "complete 'show output-'" }
 168         timeout         { fail "(timeout) complete 'show output-'" }
 169         }
 170
 171 send_gdb "p\t"
 172 sleep 1
 173 gdb_expect  {
 174         -re "^p\\\x07$"\
 175             { send_gdb "\n"
 176               sleep 1
 177               gdb_expect {
 178                       -re "The history is empty\\..*$gdb_prompt $"\
 179                                         { pass "complete 'p'"}
 180                       -re ".*$gdb_prompt $" { fail "complete 'p'"}
 181                       timeout           {fail "(timeout) complete 'p' 2"}
 182                      }
 183             }
 184         -re ".*$gdb_prompt $"       { fail "complete 'p'" }
 185         timeout         { fail "(timeout) complete 'p' 1" }
 186         }
 187
 188 send_gdb "p \t"
 189 sleep 3
 190 gdb_expect  {
 191         -re "^p \\\x07$"\
 192             { send_gdb "\n"
 193               sleep 1
 194               gdb_expect {
 195                       -re "The history is empty\\..*$gdb_prompt $"\
 196                                         { pass "complete 'p '"}
 197                       -re ".*$gdb_prompt $" { fail "complete 'p '"}
 198                       timeout           {fail "(timeout) complete 'p ' 1"}
 199                      }
 200             }
 201         -re ".*$gdb_prompt $"       { fail "complete 'p '" }
 202         timeout         { fail "(timeout) complete 'p ' 2" }
 203         }
 204
 205
 206 send_gdb "info t foo\t"
 207 sleep 1
 208 gdb_expect  {
 209         -re "^info t foo\\\x07$"\
 210             { send_gdb "\n"
 211               gdb_expect {
 212                       -re "Ambiguous info command \"t foo\": target, tasks, terminal, threads, tp, tracepoints, tvariables, types\\..*$gdb_prompt $"\
 213                                         { pass "complete 'info t foo'"}
 214                       -re ".*$gdb_prompt $" { fail "complete 'info t foo'"}
 215                       timeout           {fail "(timeout) complete 'info t foo'"}
 216                      }
 217             }
 218         -re ".*$gdb_prompt $"       { fail "complete 'info t foo'" }
 219         timeout         { fail "(timeout) complete 'info t foo'" }
 220         }
 221
 222 send_gdb "info t\t"
 223 sleep 1
 224 gdb_expect  {
 225         -re "^info t\\\x07$"\
 226             { send_gdb "\n"
 227               gdb_expect {
 228                       -re "Ambiguous info command \"t\": target, tasks, terminal, threads, tp, tracepoints, tvariables, types\\..
 229 *$gdb_prompt $"\
 230                                         { pass "complete 'info t'"}
 231                       -re ".*$gdb_prompt $" { fail "complete 'info t'"}
 232                       timeout           {fail "(timeout) complete 'info t'"}
 233                      }
 234             }
 235         -re ".*$gdb_prompt $"       { fail "complete 'info t'" }
 236         timeout         { fail "(timeout) complete 'info t'" }
 237         }
 238
 239
 240 send_gdb "info t \t"
 241 sleep 1
 242 gdb_expect  {
 243         -re "^info t \\\x07$"\
 244             { send_gdb "\n"
 245               gdb_expect {
 246                       -re "Ambiguous info command \"t \": target, tasks, terminal, threads, tp, tracepoints, tvariables, types\\..
 247 *$gdb_prompt $"\
 248                                         { pass "complete 'info t '"}
 249                       -re ".*$gdb_prompt $" { fail "complete 'info t '"}
 250                       timeout           {fail "(timeout) complete 'info t '"}
 251                      }
 252             }
 253         -re ".*$gdb_prompt $"       { fail "complete 'info t '" }
 254         timeout         { fail "(timeout) complete 'info t '" }
 255         }
 256
 257
 258 send_gdb "info asdfgh\t"
 259 sleep 1
 260 gdb_expect  {
 261         -re "^info asdfgh\\\x07$"\
 262             { send_gdb "\n"
 263               gdb_expect {
 264                       -re "Undefined info command: \"asdfgh\".  Try \"help info\"\\..
 265 *$gdb_prompt $"\
 266                                         { pass "complete 'info asdfgh'"}
 267                       -re ".*$gdb_prompt $" { fail "complete 'info asdfgh'"}
 268                       timeout           {fail "(timeout) complete 'info asdfgh'"}
 269                      }
 270             }
 271         -re ".*$gdb_prompt $"       { fail "complete 'info asdfgh'" }
 272         timeout         { fail "(timeout) complete 'info asdfgh'" }
 273         }
 274
 275
 276 send_gdb "info asdfgh \t"
 277 sleep 1
 278 gdb_expect  {
 279         -re "^info asdfgh \\\x07$"\
 280             { send_gdb "\n"
 281               gdb_expect {
 282                       -re "Undefined info command: \"asdfgh \".  Try \"help info\"\\..
 283 *$gdb_prompt $"\
 284                                         { pass "complete 'info asdfgh '"}
 285                       -re ".*$gdb_prompt $" { fail "complete 'info asdfgh '"}
 286                       timeout           {fail "(timeout) complete 'info asdfgh '"}
 287                      }
 288             }
 289         -re ".*$gdb_prompt $"       { fail "complete 'info asdfgh '" }
 290         timeout         { fail "(timeout) complete 'info asdfgh '" }
 291         }
 292
 293 send_gdb "info\t"
 294 sleep 1
 295 gdb_expect  {
 296         -re "^info $"\
 297             { send_gdb "\n"
 298               gdb_expect {
 299                       -re "\"info\" must be followed by the name of an info command\\.\r\nList of info subcommands.*$gdb_prompt $"\
 300                                         { pass "complete 'info'"}
 301                       -re ".*$gdb_prompt $" { fail "complete 'info'"}
 302                       timeout           {fail "(timeout) complete 'info'"}
 303                      }
 304             }
 305         -re ".*$gdb_prompt $"       { fail "complete 'info'" }
 306         timeout         { fail "(timeout) complete 'info'" }
 307         }
 308
 309 send_gdb "info \t"
 310 sleep 1
 311 gdb_expect  {
 312         -re "^info \\\x07$"\
 313             { send_gdb "\n"
 314               gdb_expect {
 315                       -re "\"info\" must be followed by the name of an info command\\.\r\nList of info subcommands:\r\n\r\n.*$gdb_prompt $"\
 316                                         { pass "complete 'info '"}
 317                       -re ".*$gdb_prompt $" { fail "complete 'info '"}
 318                       timeout           {fail "(timeout) complete 'info '"}
 319                      }
 320             }
 321         -re ".*$gdb_prompt $"       { fail "complete 'info '" }
 322         timeout         { fail "(timeout) complete 'info '" }
 323         }
 324
 325
 326 send_gdb "info \t"
 327 sleep 1
 328 gdb_expect  {
 329         -re "^info \\\x07$"\
 330             { send_gdb "\t"
 331               gdb_expect {
 332                       -re "address.*types.*$gdb_prompt info $"\
 333                           { send_gdb "\n"
 334                             gdb_expect {
 335                                      -re "\"info\".*unambiguous\\..*$gdb_prompt $"\
 336                                         { pass "complete (2) 'info '"}
 337                                      -re ".*$gdb_prompt $" { fail "complete (2) 'info '"}
 338                                      timeout           {fail "(timeout) complete (2) 'info '"}
 339                                     }
 340                            }
 341                       -re ".*$gdb_prompt $" { fail "complete (2) 'info '"}
 342                       timeout           {fail "(timeout) complete (2) 'info '"}
 343                      }
 344             }
 345         -re ".*$gdb_prompt $"       { fail "complete (2) 'info '" }
 346         timeout         { fail "(timeout) complete (2) 'info '" }
 347         }
 348
 349
 350 send_gdb "help info wat\t"
 351 gdb_expect  {
 352         -re "^help info watchpoints $"\
 353             { send_gdb "\n"
 354               gdb_expect {
 355                       -re "Status of watchpoints, .*\r\n.*$gdb_prompt $"\
 356                           { pass "complete help info wat" }
 357                       -re ".*$gdb_prompt $" { fail "complete help info wat"}
 358                       timeout   {fail "(timeout) complete help info wat"}
 359                      }
 360             }
 361         -re "^help info wat\\\x07$" { fail "complete (2) help info wat" }
 362         -re ".*$gdb_prompt $" { fail "complete (3) help info wat" }
 363         timeout         { fail "(timeout) complete (3) help info wat" }
 364         }
 365
 366
 367 send_gdb "p \"break1\t"
 368 sleep 1
 369 gdb_expect  {
 370         -re "^p \"break1\\\x07$"\
 371             { send_gdb "\n"
 372               gdb_expect {
 373                       -re ".*$gdb_prompt $" { fail "complete 'p \"break1'"}
 374                       timeout           {fail "(timeout) complete 'p \"break1'"}
 375                      }
 376             }
 377         -re "^p \"break1\\.c\"$"\
 378             {   send_gdb "\n"
 379                 gdb_expect {
 380                     -re ".*$gdb_prompt $" { pass "complete 'p \"break1'"}
 381                     timeout           {fail "(timeout) complete 'p \"break1'"}
 382                 }
 383             }
 384         -re "^p \"break1.*$"
 385             {   send_gdb "\n"
 386                 gdb_expect {
 387                     -re ".*$gdb_prompt $" { fail "complete 'p \"break1'"}
 388                     timeout           {fail "(timeout) complete 'p \"break1'"}
 389                 }
 390             }
 391         -re ".*$gdb_prompt $"       { fail "complete 'p \"break1'" }
 392         timeout         { fail "(timeout) complete 'p \"break1'" }
 393         }
 394
 395 setup_xfail "*-*-*"
 396 send_gdb "p \"break1.\t"
 397 sleep 1
 398 gdb_expect  {
 399         -re "^p \"break1\\.\\\x07$"\
 400             { send_gdb "\n"
 401               gdb_expect {
 402                       -re ".*$gdb_prompt $" { fail "complete 'p \"break1.'"}
 403                       timeout           {fail "(timeout) complete 'p \"break1.'"}
 404                      }
 405             }
 406         -re "^p \"break1\\.c\"$"\
 407             {   send_gdb "\n"
 408                 gdb_expect {
 409                     -re ".*$gdb_prompt $" { pass "complete 'p \"break1.'"}
 410                     timeout           {fail "(timeout) complete 'p \"break1.'"}
 411                 }
 412             }
 413         -re "^p \"break1\\..*$"
 414             {   send_gdb "\n"
 415                 gdb_expect {
 416                     -re ".*$gdb_prompt $" { fail "complete 'p \"break1.'"}
 417                     timeout           {fail "(timeout) complete 'p \"break1.'"}
 418                 }
 419             }
 420         -re ".*$gdb_prompt $"       { fail "complete 'p \"break1.'" }
 421         timeout         { fail "(timeout) complete 'p \"break1.'" }
 422         }
 423
 424 send_gdb "p 'arg\t"
 425 sleep 1
 426 gdb_expect  {
 427         -re "^p 'arg\\\x07$"\
 428             { send_gdb "\n"
 429               gdb_expect {
 430                       -re "(Invalid character constant\\.|Unmatched single quote\\.).*$gdb_prompt $"\
 431                                         { pass "complete 'p \'arg'"}
 432                       -re ".*$gdb_prompt $" { fail "complete 'p \'arg'"}
 433                       timeout           {fail "(timeout) complete 'p \'arg'"}
 434                      }
 435             }
 436         -re ".*$gdb_prompt $"       { fail "complete 'p \'arg'" }
 437         timeout         { fail "(timeout) complete 'p \'arg'" }
 438         }
 439
 440 send_gdb "p 'arg\t"
 441 sleep 1
 442 gdb_expect {
 443     -re "^p 'arg\\\x07$" {
 444         send_gdb "\t"
 445         gdb_expect {
 446             -re ".*argv.*$gdb_prompt p 'arg$" {
 447                 send_gdb "\n"
 448                 gdb_expect {
 449                     -re "(Invalid character constant\\.|Unmatched single quote\\.).*$gdb_prompt $" {
 450                         pass "complete (2) 'p \'arg'"
 451                     }
 452                     -re ".*$gdb_prompt $" { fail "complete (2) 'p \'arg'" }
 453                     timeout { fail "(timeout) complete (2) 'p \'arg'" }
 454                 }
 455             }
 456             -re "(There are $decimal possibilities\\.  Do you really\r\nwish to see them all.|Display all $decimal possibilities.) \\(y or n\\)$" {
 457                 send_gdb "n"
 458                 gdb_expect {
 459                     -re "\\(gdb\\) p 'arg$" {
 460                         send_gdb "\n"
 461                         gdb_expect {
 462                             -re "(Invalid character constant\\.|Unmatched single quote\\.).*$gdb_prompt $" {
 463                                 pass "complete (2) 'p \'arg'"
 464                             }
 465                             -re ".*$gdb_prompt $" {
 466                                 fail "complete (2) 'p \'arg'"
 467                             }
 468                             timeout { fail "(timeout) complete (2) 'p \'arg'" }
 469                         }
 470                     }
 471                     -re ".*$gdb_prompt $" { fail "complete (2) 'p \'arg'" }
 472                     timeout { fail "(timeout) complete (2) 'p \'arg'" }
 473                 }
 474             }
 475             -re ".*$gdb_prompt $" { fail "complete (2) 'p \'arg'" }
 476             timeout { fail "(timeout) complete (2) 'p \'arg'" }
 477         }
 478     }
 479     -re ".*$gdb_prompt $" { fail "complete (2) 'p \'arg'" }
 480     timeout { fail "(timeout) complete (2) 'p \'arg'" }
 481 }
 482
 483
 484 # These tests used to try completing the shorter "p b-a".
 485 # Unfortunately, on some systems, there are .o files in system
 486 # libraries which declare static variables named `b'.  Of course,
 487 # those variables aren't really in scope, as far as the compiler is
 488 # concerned.  But GDB deliberately tries to be more liberal: if you
 489 # enter an identifier that doesn't have any binding in scope, GDB will
 490 # search all the program's compilation units for a static variable of
 491 # the given name.
 492 #
 493 # This behavior can help avoid a lot of pedantry, so it's usually a
 494 # good thing.  But in this test case, it causes GDB to print the value
 495 # of some random variable, instead of giving us the "No symbol..."
 496 # error we were expecting.
 497 #
 498 # For example, on S/390 linux, the file s_atan.c in libm.a declares a
 499 # `b', which is a structure containing an int and a float, so GDB says
 500 # ``Argument to arithmetic operation not a number or boolean'' instead
 501 # of ``No symbol ...''.
 502 #
 503 # So, I'm hoping that there is no system with a static library variable named
 504 # `no_var_by_this_name'.
 505 send_gdb "p no_var_named_this-arg\t"
 506 sleep 1
 507 gdb_expect {
 508     -re "^p no_var_named_this-arg\\\x07$" {
 509         send_gdb "\n"
 510         gdb_expect {
 511             -re "No symbol \"no_var_named_this\" in current context\\..*$gdb_prompt $" {
 512                 pass "complete 'p no_var_named_this-arg'"
 513             }
 514             -re ".*$gdb_prompt $" {
 515                 fail "complete 'p no_var_named_this-arg'"
 516             }
 517             timeout {
 518                 fail "(timeout) complete 'p no_var_named_this-arg'"
 519             }
 520         }
 521     }
 522     -re ".*$gdb_prompt $" {
 523         fail "complete 'p no_var_named_this-arg'"
 524     }
 525     timeout {
 526         fail "(timeout) complete 'p no_var_named_this-arg'"
 527     }
 528 }
 529
 530 send_gdb "p no_var_named_this-arg\t"
 531 sleep 1
 532 gdb_expect {
 533     -re "^p no_var_named_this-arg\\\x07$" {
 534         send_gdb "\t"
 535         gdb_expect {
 536             -re ".*argv.*$gdb_prompt p no_var_named_this-arg$" {
 537                 send_gdb "\n"
 538                 gdb_expect {
 539                     -re "No symbol \"no_var_named_this\" in current context\\..*$gdb_prompt $" {
 540                         pass "complete (2) 'p no_var_named_this-arg'"
 541                     }
 542                     -re ".*$gdb_prompt $" {
 543                         fail "complete (2) 'p no_var_named_this-arg'"
 544                     }
 545                     timeout {
 546                         fail "(timeout) complete (2) 'p no_var_named_this-arg'"
 547                     }
 548                 }
 549             }
 550             -re "(There are $decimal possibilities\\.  Do you really\r\nwish to see them all.|Display all $decimal possibilities.) \\(y or n\\)$" {
 551                 send_gdb "n"
 552                 gdb_expect {
 553                     -re "\\(gdb\\) p no_var_named_this-arg$" {
 554                         send_gdb "\n"
 555                         gdb_expect {
 556                             -re "No symbol \"no_var_named_this\" in current context\\..*$gdb_prompt $" {
 557                                 pass "complete (2) 'p no_var_named_this-arg'"
 558                             }
 559                             -re ".*$gdb_prompt $" {
 560                                 fail "complete (2) 'p no_var_named_this-arg'"
 561                             }
 562                             timeout {
 563                                 fail "(timeout) complete (2) 'p no_var_named_this-arg'"
 564                             }
 565                         }
 566                     }
 567                     -re ".*$gdb_prompt $" {
 568                         fail "complete (2) 'p no_var_named_this-arg'"
 569                     }
 570                     timeout {
 571                         fail "(timeout) complete (2) 'p no_var_named_this-arg'"
 572                     }
 573                 }
 574             }
 575             -re ".*$gdb_prompt $" {
 576                 fail "complete (2) 'p no_var_named_this-arg'"
 577             }
 578             timeout { fail "(timeout) complete (2) 'p no_var_named_this-arg'" }
 579         }
 580     }
 581     -re ".*$gdb_prompt $" { fail "complete (2) 'p no_var_named_this-arg'" }
 582     timeout { fail "(timeout) complete (2) 'p no_var_named_this-arg'" }
 583 }
 584
 585 send_gdb "p no_var_named_this-\t"
 586 sleep 1
 587 gdb_expect  {
 588     -re "^p no_var_named_this-\\\x07$" {
 589         send_gdb "\t"
 590         gdb_expect {
 591             -re "(There are $decimal possibilities\\.  Do you really\r\nwish to see them all.|Display all $decimal possibilities.) \\(y or n\\)$" {
 592                 send_gdb "n"
 593                 gdb_expect {
 594                     -re "\\(gdb\\) p no_var_named_this-$" {
 595                         send_gdb "\n"
 596                         gdb_expect {
 597                             -re "No symbol \"no_var_named_this\" in current context\\..*$gdb_prompt $" {
 598                                 pass "complete (2) 'p no_var_named_this-'"
 599                             }
 600                             -re ".*$gdb_prompt $" {
 601                                 fail "complete (2) 'p no_var_named_this-'"
 602                             }
 603                             timeout {
 604                                 fail "(timeout) complete (2) 'p no_var_named_this-'"
 605                             }
 606                         }
 607                     }
 608                     -re ".*$gdb_prompt $" {
 609                         fail "complete (2) 'p no_var_named_this-'"
 610                     }
 611                     timeout {
 612                         fail "(timeout) complete (2) 'p no_var_named_this-'"
 613                     }
 614                 }
 615             }
 616             -re ".*argv.*$gdb_prompt p no_var_named_this-$" {
 617                 send_gdb "\n"
 618                 gdb_expect {
 619                     -re "No symbol \"no_var_named_this\" in current context\\..*$gdb_prompt $" {
 620                         pass "complete (2) 'p no_var_named_this-'"
 621                     }
 622                     -re ".*$gdb_prompt $" {
 623                         fail "complete (2) 'p no_var_named_this-'"
 624                     }
 625                     timeout {
 626                         fail "(timeout) complete (2) 'p no_var_named_this-'"
 627                     }
 628                 }
 629             }
 630             -re ".*$gdb_prompt $" {
 631                 fail "complete (2) 'p no_var_named_this-'"
 632             }
 633             timeout { fail "(timeout) complete (2) 'p no_var_named_this-'" }
 634         }
 635     }
 636     -re ".*$gdb_prompt $" { fail "complete (2) 'p no_var_named_this-'" }
 637     timeout { fail "(timeout) complete (2) 'p no_var_named_this-'" }
 638 }
 639
 640 send_gdb "p values\[0\].a\t"
 641 sleep 3
 642 gdb_expect  {
 643         -re "^p values.0..a_field $"\
 644             { send_gdb "\n"
 645               sleep 1
 646               gdb_expect {
 647                       -re "^.* = 0.*$gdb_prompt $"\
 648                                         { pass "complete 'p values\[0\].a'"}
 649                       -re ".*$gdb_prompt $" { fail "complete 'p values\[0\].a'"}
 650                       timeout           {fail "(timeout) complete 'p values\[0\].a'"}
 651                      }
 652             }
 653         -re ".*$gdb_prompt $"       { fail "complete 'p values\[0\].a'" }
 654         timeout         { fail "(timeout) complete 'p values\[0\].a' 2" }
 655         }
 656
 657 send_gdb "p values\[0\] . a\t"
 658 gdb_expect  {
 659         -re "^p values.0. . a_field $"\
 660             { send_gdb "\n"
 661               gdb_expect {
 662                       -re "^.* = 0.*$gdb_prompt $"\
 663                                         { pass "complete 'p values\[0\] . a'"}
 664                       -re ".*$gdb_prompt $" { fail "complete 'p values\[0\] . a'"}
 665                       timeout           {fail "(timeout) complete 'p values\[0\] . a'"}
 666                      }
 667             }
 668         -re ".*$gdb_prompt $"       { fail "complete 'p values\[0\] . a'" }
 669         timeout         { fail "(timeout) complete 'p values\[0\] . a' 2" }
 670         }
 671
 672 send_gdb "p &values\[0\] -> a\t"
 673 gdb_expect  {
 674         -re "^p &values.0. -> a_field $"\
 675             { send_gdb "\n"
 676               gdb_expect {
 677                       -re "^.* = .*0x\[0-9a-fA-F\]*.*$gdb_prompt $"\
 678                                         { pass "complete 'p &values\[0\] -> a'"}
 679                       -re ".*$gdb_prompt $" { fail "complete 'p &values\[0\] -> a'"}
 680                       timeout           {fail "(timeout) complete 'p &values\[0\] -> a'"}
 681                      }
 682             }
 683         -re ".*$gdb_prompt $"       { fail "complete 'p &values\[0\] -> a'" }
 684         timeout         { fail "(timeout) complete 'p &values\[0\] -> a' 2" }
 685         }
 686
 687 gdb_test "complete p &values\[0\]->z" \
 688     "p &values.0.->z_field" \
 689     "copmletion of field in anonymous union"
 690
 691 # The following tests used to simply try to complete `${objdir}/file',
 692 # and so on.  The problem is that ${objdir} can be very long; the
 693 # completed filename may be more than eighty characters wide.  When
 694 # this happens, readline tries to manage things, producing output that
 695 # may make sense on the screen, but is rather hard for our script to
 696 # recognize.
 697 #
 698 # In the case that motivated this change, the (gdb) prompt occupied
 699 # the leftmost six columns, and `${objdir}/' was seventy-four
 700 # characters long --- eighty in all.  After printing the slash,
 701 # readline emitted a space, a carriage return, and then `Makefile'
 702 # (the tab character being received as input after `Make'.
 703 #
 704 # Basically, you have to let readline do whatever it's going to do to
 705 # make the screen look right.  If it happens to use a different
 706 # strategy on Tuesdays to get the cursor in the right place, that's
 707 # not something the testsuite should care about.
 708 #
 709 # So, we avoid long lines.  We `cd' to ${objdir} first, and then do
 710 # the completion relative to the current directory.
 711
 712 # ${srcdir} may be a relative path.  We want to make sure we end up
 713 # in the right directory - so make sure we know where it is.
 714 set mydir [pwd]
 715 cd ${srcdir}
 716 set fullsrcdir [pwd]
 717 cd ${mydir}
 718
 719 # If the directory name contains a '+' we must escape it, adding a backslash.
 720 # If not, the test below will fail because it will interpret the '+' as a
 721 # regexp operator. We use string_to_regexp for this purpose.
 722
 723 gdb_test "cd ${fullsrcdir}" \
 724          "Working directory [string_to_regexp ${fullsrcdir}].*" \
 725          "cd to \${srcdir}"
 726
 727
 728 # GDB used to fail adding / on directories, on the first try only.
 729 set uniquedir ../testsuite/gdb.base/comp-dir
 730 set escapeduniquedir [string_to_regexp ${uniquedir}]
 731 set uniquesu subdi
 732 set uniquesub ${uniquesu}r
 733 set escapeuniquesub [string_to_regexp ${uniquesub}]
 734 send_gdb "dir ${uniquedir}\t"
 735 gdb_expect {
 736         -re "${escapeduniquedir}/" {
 737             pass "directory completion"
 738             send_gdb "${uniquesu}\t"
 739         }
 740         -re "${escapeduniquedir} $" {
 741             fail "directory completion (old gdb bug)"
 742             send_gdb "\b/${uniquesu}\t"
 743         }
 744         default {
 745             fail "directory completion (timeout)"
 746             send_gdb "\ndir ${uniquedir}/${uniquesu}\t"
 747         }
 748 }
 749
 750 gdb_expect {
 751         -re "${escapeuniquesub}/$" {
 752             pass "directory completion 2"
 753         }
 754         timeout {
 755             fail "directory completion 2"
 756         }
 757 }
 758
 759 # Empty COMMAND sends no newline while " " sends the newline we need.
 760 gdb_test " " "Source directories searched: .*" "Glob remaining of directory test"
 761
 762
 763 send_gdb "complete file ./gdb.base/compl\n"
 764 sleep 1
 765 gdb_expect  {
 766     -re "file ./gdb.base/completion\\.exp.*$gdb_prompt $"
 767         { pass "complete-command 'file ./gdb.base/compl'"}
 768     -re ".*$gdb_prompt $"       { fail "complete-command 'file ./gdb.base/compl'" }
 769     timeout         { fail "(timeout) complete-command 'file ./gdb.base/compl'" }
 770 }
 771
 772 send_gdb "file ./gdb.base/complet\t"
 773 sleep 1
 774 gdb_expect  {
 775         -re "^file ./gdb.base/completion\\.exp $"\
 776             { send_gdb "\n"
 777               # Ignore the exact error message.
 778               gdb_test_multiple "" "complete 'file ./gdb.base/complet'" {
 779                   -re "\r\nA program is being debugged already\\.\[\r\n\]+Are you sure you want to change the file\\? \\(y or n\\) $" {
 780                       send_gdb "n\n"
 781                       exp_continue
 782                   }
 783                   -re ".*$gdb_prompt $" { pass "complete 'file ./gdb.base/complet'" }
 784               }
 785             }
 786         -re ".*$gdb_prompt $"       { fail "complete 'file ./gdb.base/complet'" }
 787         timeout         { fail "(timeout) complete 'file ./gdb.base/complet'" }
 788         }
 789
 790 send_gdb "info func marke\t"
 791 sleep 1
 792 gdb_expect  {
 793         -re "^info func marke.*r$"\
 794             {
 795               send_gdb "\t\t"
 796               sleep 3
 797               gdb_expect {
 798                       -re "marker1.*$gdb_prompt info func marker$"\
 799                       { send_gdb "\n"
 800                         gdb_expect {
 801                                 -re "All functions matching regular expression \"marker\":.*File.*break1.c:\r\nint marker1\\((void|)\\);\r\nint marker2\\(int\\).*marker3\\(char.*char.*\\).*marker4\\(long( int)?\\);.*$gdb_prompt $"\
 802                                                   { pass "complete 'info func marke'"}
 803                                 -re ".*$gdb_prompt $" { fail "complete 'info func marke'"}
 804                                 timeout           {fail "(timeout) complete 'info func marke'"}
 805                                }
 806                       }
 807                       -re ".*$gdb_prompt $" { fail "complete 'info func marke'"}
 808                       timeout           {fail "(timeout) complete 'info func marke'"}
 809                      }
 810             }
 811         -re ".*$gdb_prompt $"       { fail "complete 'info func marke'" }
 812         timeout         { fail "(timeout) complete 'info func marke'" }
 813         }
 814
 815
 816 send_gdb "set follow-fork-mode \t\t"
 817 sleep 1
 818 gdb_expect  {
 819         -re "child.*parent.*$gdb_prompt set follow-fork-mode $"\
 820             { send_gdb "\n"
 821               gdb_expect {
 822                       -re "Requires an argument.*child.*parent.*$gdb_prompt $"\
 823                                         { pass "complete 'set follow-fork-mode'"}
 824                       -re "Ambiguous item \"\"\\..*$gdb_prompt $"\
 825                                         { pass "complete 'set follow-fork-mode'"}
 826                       -re ".*$gdb_prompt $" { fail "complete 'set follow-fork-mode'"}
 827                       timeout           {fail "(timeout) complete 'set follow-fork-mode'"}
 828                      }
 829             }
 830         -re ".*$gdb_prompt $"       { fail "complete 'set follow-fork-mode'" }
 831         timeout         { fail "(timeout) complete 'set follow-fork-mode'" }
 832         }
 833
 834 gdb_test_no_output "complete print values\[0\].x." \
 835     "field completion with invalid field"
 836
 837 # If there is a non-deprecated completion, it should be returned.
 838 gdb_test "complete sav" "save" "test non-deprecated completion"
 839 # If there is only a deprecated completion, then it should be returned.
 840 gdb_test "complete save-t" "save-tracepoints" "test deprecated completion"
 841
 842
 843 # Restore globals modified in this test...
 844 set timeout $oldtimeout1
 845
 846 return 0