gdb/testsuite/gdb.base/commands.exp

   1 #   Copyright 1988-2016 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 #
  17 # test special commands (if, while, etc)
  18 #
  19
  20 standard_testfile
  21
  22 if { [prepare_for_testing commands.exp commands run.c {debug additional_flags=-DFAKEARGV}] } {
  23     return -1
  24 }
  25
  26 # Run to FUNCTION.  If that fails, issue a FAIL and make the caller
  27 # return.
  28
  29 proc runto_or_return {function} {
  30     if { ![runto factorial] } {
  31         fail "cannot run to $function"
  32         return -code return
  33     }
  34 }
  35
  36 proc_with_prefix gdbvar_simple_if_test {} {
  37     global gdb_prompt
  38     global valnum_re
  39
  40     gdb_test_no_output "set \$foo = 0" "set foo"
  41     # All this test should do is print 0xdeadbeef once.
  42     gdb_test \
  43         [multi_line_input \
  44              {if $foo == 1} \
  45              {  p/x 0xfeedface} \
  46              {else} \
  47              {  p/x 0xdeadbeef} \
  48              {end}] \
  49         "$valnum_re = 0xdeadbeef" \
  50         "#1"
  51
  52     # All this test should do is print 0xfeedface once.
  53     gdb_test \
  54         [multi_line_input \
  55              {if $foo == 0} \
  56              {  p/x 0xfeedface} \
  57              {else} \
  58              {  p/x 0xdeadbeef} \
  59              {end}] \
  60         "$valnum_re = 0xfeedface" \
  61         "#2"
  62 }
  63
  64 proc_with_prefix gdbvar_simple_while_test {} {
  65     global gdb_prompt
  66     global valnum_re
  67
  68     gdb_test_no_output "set \$foo = 5" "set foo"
  69     # This test should print 0xfeedface five times.
  70     gdb_test \
  71         [multi_line_input \
  72              {while $foo > 0} \
  73              {  p/x 0xfeedface} \
  74              {  set $foo -= 1} \
  75              {end}] \
  76         [multi_line \
  77              "$valnum_re = 0xfeedface" \
  78              "$valnum_re = 0xfeedface" \
  79              "$valnum_re = 0xfeedface" \
  80              "$valnum_re = 0xfeedface" \
  81              "$valnum_re = 0xfeedface"] \
  82         "#1"
  83 }
  84
  85 proc_with_prefix gdbvar_complex_if_while_test {} {
  86     global gdb_prompt
  87     global valnum_re
  88
  89     gdb_test_no_output "set \$foo = 4" "set foo"
  90     # This test should alternate between 0xdeadbeef and 0xfeedface two times.
  91     gdb_test \
  92         [multi_line_input \
  93              {while $foo > 0} \
  94              {  set $foo -= 1} \
  95              {  if ($foo % 2) == 1} \
  96              {    p/x 0xdeadbeef} \
  97              {  else} \
  98              {    p/x 0xfeedface} \
  99              {  end} \
 100              {end}] \
 101         [multi_line \
 102              "$valnum_re = 0xdeadbeef" \
 103              "$valnum_re = 0xfeedface" \
 104              "$valnum_re = 0xdeadbeef" \
 105              "$valnum_re = 0xfeedface"] \
 106         "#1"
 107 }
 108
 109 proc_with_prefix progvar_simple_if_test {} {
 110     global gdb_prompt
 111     global valnum_re
 112
 113     runto_or_return factorial
 114
 115     # Don't depend upon argument passing, since most simulators don't
 116     # currently support it.  Bash value variable to be what we want.
 117     gdb_test "p value=5" " = 5" "set value to 5"
 118     # All this test should do is print 0xdeadbeef once.
 119     gdb_test \
 120         [multi_line_input \
 121              {if value == 1} \
 122              {  p/x 0xfeedface} \
 123              {else} \
 124              {  p/x 0xdeadbeef} \
 125              {end}] \
 126         "$valnum_re = 0xdeadbeef" \
 127         "#1"
 128
 129     # All this test should do is print 0xfeedface once.
 130     gdb_test \
 131         [multi_line_input \
 132              {if value == 5} \
 133              {  p/x 0xfeedface} \
 134              {else} \
 135              {  p/x 0xdeadbeef} \
 136              {end}] \
 137         "$valnum_re = 0xfeedface" \
 138         "#2"
 139 }
 140
 141 proc_with_prefix progvar_simple_while_test {} {
 142     global gdb_prompt
 143     global valnum_re
 144
 145     runto_or_return factorial
 146
 147     # Don't depend upon argument passing, since most simulators don't
 148     # currently support it.  Bash value variable to be what we want.
 149     gdb_test "p value=5" " = 5" "set value to 5"
 150     # This test should print 0xfeedface five times.
 151     gdb_test \
 152         [multi_line_input \
 153              {while value > 0} \
 154              {  p/x 0xfeedface} \
 155              {  set value -= 1} \
 156              {end}] \
 157         [multi_line \
 158              "$valnum_re = 0xfeedface" \
 159              "$valnum_re = 0xfeedface" \
 160              "$valnum_re = 0xfeedface" \
 161              "$valnum_re = 0xfeedface" \
 162              "$valnum_re = 0xfeedface"] \
 163         "#1"
 164 }
 165
 166 proc_with_prefix progvar_complex_if_while_test {} {
 167     global gdb_prompt
 168     global valnum_re
 169
 170     runto_or_return factorial
 171
 172     # Don't depend upon argument passing, since most simulators don't
 173     # currently support it.  Bash value variable to be what we want.
 174     gdb_test "p value=4" " = 4" "set value to 4"
 175     # This test should alternate between 0xdeadbeef and 0xfeedface two
 176     # times.
 177     gdb_test \
 178         [multi_line_input \
 179              {while value > 0} \
 180              {  set value -= 1} \
 181              {  if (value % 2) == 1} \
 182              {    p/x 0xdeadbeef} \
 183              {  else} \
 184              {    p/x 0xfeedface} \
 185              {  end} \
 186              {end}] \
 187         [multi_line \
 188              "$valnum_re = 0xdeadbeef" \
 189              "$valnum_re = 0xfeedface" \
 190              "$valnum_re = 0xdeadbeef" \
 191              "$valnum_re = 0xfeedface"] \
 192         "#1"
 193 }
 194
 195 proc_with_prefix if_while_breakpoint_command_test {} {
 196     global valnum_re
 197
 198     runto_or_return factorial
 199
 200     # Don't depend upon argument passing, since most simulators don't
 201     # currently support it.  Bash value variable to be what we want.
 202     gdb_test "p value=5" " = 5" "set value to 5"
 203     delete_breakpoints
 204     gdb_test "break factorial" "Breakpoint.*at.*" "break factorial"
 205
 206     gdb_test_multiple "commands" "commands" {
 207         -re "End with" {
 208             pass "commands"
 209         }
 210     }
 211
 212     # This test should alternate between 0xdeadbeef and 0xfeedface two times.
 213     gdb_test \
 214         [multi_line_input \
 215              {while value > 0} \
 216              {  set value -= 1} \
 217              {  if (value % 2) == 1} \
 218              {    p/x 0xdeadbeef} \
 219              {  else} \
 220              {    p/x 0xfeedface} \
 221              {  end} \
 222              {end} \
 223              {end}] \
 224         "" \
 225         "commands part 2"
 226     gdb_test \
 227         "continue" \
 228         [multi_line \
 229              "$valnum_re = 0xdeadbeef" \
 230              "$valnum_re = 0xfeedface" \
 231              "$valnum_re = 0xdeadbeef" \
 232              "$valnum_re = 0xfeedface"] \
 233         "#1"
 234     gdb_test "info break" "while.*set.*if.*p/x.*else.*p/x.*end.*"
 235 }
 236
 237 # Test that we can run the inferior from breakpoint commands.
 238 #
 239 # The expected behavior is that all commands after the first "step"
 240 # shall be ignored.  See the gdb manual, "Break Commands",
 241 # subsection "Breakpoint command lists".
 242
 243 proc_with_prefix infrun_breakpoint_command_test {} {
 244     runto_or_return factorial
 245
 246     # Don't depend upon argument passing, since most simulators don't
 247     # currently support it.  Bash value variable to be what we want.
 248     gdb_test "p value=6" " = 6" "set value to 6"
 249     delete_breakpoints
 250     gdb_test "break factorial if value == 5" "Breakpoint.*at.*"
 251
 252 # infrun_breakpoint_command_test - This test was broken into two parts
 253 # to get around a synchronization problem in expect.
 254 # part1: issue the gdb command "commands"
 255 # part2: send the list of commands
 256
 257     set test "commands #1"
 258     gdb_test_multiple "commands" $test {
 259         -re "End with" {
 260             pass $test
 261         }
 262     }
 263     gdb_test "step\nstep\nstep\nstep\nend" "" \
 264         "commands #2"
 265
 266     gdb_test "continue" \
 267         "Continuing.*.*.*Breakpoint \[0-9\]*, factorial \\(value=5\\).*at.*\[0-9\]*\[      \]*if \\(value > 1\\) \{.*\[0-9\]*\[      \]*value \\*= factorial \\(value - 1\\);.*"
 268 }
 269
 270 proc_with_prefix breakpoint_command_test {} {
 271     runto_or_return factorial
 272
 273     # Don't depend upon argument passing, since most simulators don't
 274     # currently support it.  Bash value variable to be what we want.
 275     gdb_test "p value=6" " = 6" "set value to 6"
 276     delete_breakpoints
 277     gdb_test "break factorial" "Breakpoint.*at.*"
 278     gdb_test \
 279         [multi_line_input \
 280              {commands} \
 281              {  printf "Now the value is %d\n", value} \
 282              {end}] \
 283         "End with.*" \
 284         "commands"
 285     gdb_test "continue" \
 286             "Breakpoint \[0-9\]*, factorial.*Now the value is 5"
 287     gdb_test "print value" " = 5"
 288 }
 289
 290 # Test a simple user defined command (with arguments)
 291 proc_with_prefix user_defined_command_test {} {
 292     global gdb_prompt
 293     global valnum_re
 294
 295     gdb_test_no_output "set \$foo = 4" "set foo"
 296
 297     gdb_test_multiple "define mycommand" "define mycommand" {
 298         -re "End with"  {
 299             pass "define mycommand"
 300         }
 301     }
 302
 303     # This test should alternate between 0xdeadbeef and 0xfeedface two times.
 304     gdb_test \
 305         [multi_line_input \
 306              {while $arg0 > 0} \
 307              {  set $arg0 -= 1} \
 308              {  if ($arg0 % 2) == 1} \
 309              {    p/x 0xdeadbeef} \
 310              {  else} \
 311              {    p/x 0xfeedface} \
 312              {  end} \
 313              {end} \
 314              {end}] \
 315         "" \
 316         "enter commands"
 317
 318     global decimal
 319     set valnum_re "\\\$$decimal"
 320
 321     gdb_test \
 322         {mycommand $foo} \
 323         [multi_line \
 324              "$valnum_re = 0xdeadbeef" \
 325              "$valnum_re = 0xfeedface" \
 326              "$valnum_re = 0xdeadbeef" \
 327              "$valnum_re = 0xfeedface"] \
 328         "execute user-defined command"
 329    gdb_test "show user mycommand" \
 330         "  while \\\$arg0.*set.*    if \\\(\\\$arg0.*p/x.*    else\[^\n\].*p/x.*    end\[^\n\].*  end\[^\n\].*" \
 331            "display user command"
 332
 333     # Create and test a user-defined command with an empty body.
 334     gdb_test_multiple "define myemptycommand" "define myemptycommand" {
 335         -re "End with"  {
 336             pass "define myemptycommand"
 337         }
 338     }
 339     gdb_test "end" \
 340         "" \
 341         "end definition of user-defined command with empty body"
 342
 343     gdb_test_no_output "myemptycommand" \
 344         "execute user-defined empty command"
 345
 346     gdb_test "show user" \
 347         "User command \"myemptycommand.*" \
 348         "display empty command in command list"
 349
 350     gdb_test "show user myemptycommand" \
 351         "User command \"myemptycommand.*" \
 352         "display user-defined empty command"
 353 }
 354
 355 # Test that "eval" in a user-defined command expands $argc/$argN.
 356
 357 proc_with_prefix user_defined_command_args_eval {} {
 358     global gdb_prompt
 359
 360     gdb_test_multiple "define command_args_eval" \
 361         "define command_args_eval" {
 362             -re "End with"  {
 363                 pass "define"
 364             }
 365         }
 366
 367     # Make a command that constructs references to $argc and $argN via
 368     # eval.
 369     gdb_test \
 370         [multi_line \
 371              {eval "printf \"argc = %%d,\", $arg%c", 'c'} \
 372              {set $i = 0} \
 373              {while $i < $argc} \
 374              {  eval "printf \" %%d\", $arg%d", $i} \
 375              {  set $i = $i + 1} \
 376              {end} \
 377              {printf "\n"} \
 378              {end}] \
 379         "" \
 380         "enter commands"
 381
 382     gdb_test "command_args_eval 1 2 3" "argc = 3, 1 2 3" "execute command"
 383 }
 384
 385 # Test that the $argc/$argN variables are pushed on/popped from the
 386 # args stack correctly when a user-defined command calls another
 387 # user-defined command (or in this case, recurses).
 388
 389 proc_with_prefix user_defined_command_args_stack_test {} {
 390     global gdb_prompt
 391
 392     gdb_test_multiple "define args_stack_command" \
 393         "define args_stack_command" {
 394             -re "End with"  {
 395                 pass "define"
 396             }
 397         }
 398
 399     # Make a command that refers to $argc/$argN before and after
 400     # recursing.  Also, vary the number of arguments passed to each
 401     # recursion point.
 402     gdb_test \
 403         [multi_line \
 404              {printf "before, argc = %d,", $argc} \
 405              {set $i = 0} \
 406              {while $i < $argc} \
 407              {  eval "printf \" %%d\", $arg%d", $i} \
 408              {  set $i = $i + 1} \
 409              {end} \
 410              {printf "\n"} \
 411              {} \
 412              {} \
 413              {if $argc == 3} \
 414              {  args_stack_command 21 22} \
 415              {end} \
 416              {if $argc == 2} \
 417              {  args_stack_command 11} \
 418              {end} \
 419              {} \
 420              {} \
 421              {printf "after, argc = %d,", $argc} \
 422              {set $i = 0} \
 423              {while $i < $argc} \
 424              {  eval "printf \" %%d\", $arg%d", $i} \
 425              {  set $i = $i + 1} \
 426              {end} \
 427              {printf "\n"} \
 428              {end}] \
 429         "" \
 430         "enter commands"
 431
 432     set expected \
 433         [multi_line \
 434              "before, argc = 3, 31 32 33" \
 435              "before, argc = 2, 21 22" \
 436              "before, argc = 1, 11" \
 437              "after, argc = 1, 11" \
 438              "after, argc = 2, 21 22" \
 439              "after, argc = 3, 31 32 33"]
 440     gdb_test "args_stack_command 31 32 33" $expected "execute command"
 441 }
 442
 443 proc_with_prefix watchpoint_command_test {} {
 444     global gdb_prompt
 445
 446     # Disable hardware watchpoints if necessary.
 447     if [target_info exists gdb,no_hardware_watchpoints] {
 448         gdb_test_no_output "set can-use-hw-watchpoints 0" ""
 449     }
 450
 451     runto_or_return factorial
 452
 453     delete_breakpoints
 454
 455     # Verify that we can create a watchpoint, and give it a commands
 456     # list that continues the inferior.  We set the watchpoint on a
 457     # local variable, too, so that it self-deletes when the watched
 458     # data goes out of scope.
 459     #
 460     # What should happen is: Each time the watchpoint triggers, it
 461     # continues the inferior.  Eventually, the watchpoint will self-
 462     # delete, when the watched variable is out of scope.  But by that
 463     # time, the inferior should have exited.  GDB shouldn't crash or
 464     # anything untoward as a result of this.
 465     #
 466     set wp_id -1
 467
 468     gdb_test_multiple "watch local_var" "watch local_var" {
 469         -re "\[Ww\]atchpoint (\[0-9\]*): local_var.*$gdb_prompt $" {
 470             set wp_id $expect_out(1,string)
 471             pass "watch local_var"
 472         }
 473     }
 474
 475     if {$wp_id == -1} {return}
 476
 477     gdb_test_multiple "commands $wp_id" "begin commands on watch" {
 478         -re "Type commands for breakpoint.*, one per line.*>$" {
 479             pass "begin commands on watch"
 480         }
 481     }
 482     # See the 'No symbol "value...' fail below.  This command will
 483     # fail if it's executed in the wrong frame.  If adjusting the
 484     # test, make sure this property holds.
 485     gdb_test_multiple "print value" "add print command to watch" {
 486         -re ">$" {
 487             pass "add print command to watch"
 488         }
 489     }
 490     gdb_test_multiple "continue" "add continue command to watch" {
 491         -re ">$" {
 492             pass "add continue command to watch"
 493         }
 494     }
 495     gdb_test "end" \
 496         "" \
 497         "end commands on watch"
 498
 499     set test "continue with watch"
 500     set lno_1 [gdb_get_line_number "commands.exp: hw local_var out of scope" "run.c"]
 501     set lno_2 [gdb_get_line_number "commands.exp: local_var out of scope"    "run.c"]
 502     gdb_test_multiple "continue" "$test" {
 503         -re "No symbol \"value\" in current context.\r\n$gdb_prompt $" {
 504             # Happens if GDB actually runs the watchpoints commands,
 505             # even though the watchpoint was deleted for not being in
 506             # scope.
 507             fail $test
 508         }
 509         -re "Continuing.*\[Ww\]atchpoint $wp_id deleted because the program has left the block in.*which its expression is valid.*run.c:($lno_1|$lno_2).*$gdb_prompt $" {
 510             pass $test
 511         }
 512    }
 513 }
 514
 515 proc_with_prefix test_command_prompt_position {} {
 516     global gdb_prompt
 517     global valnum_re
 518
 519     runto_or_return factorial
 520
 521     # Don't depend upon argument passing, since most simulators don't
 522     # currently support it.  Bash value variable to be what we want.
 523     delete_breakpoints
 524     gdb_test "break factorial" "Breakpoint.*at.*"
 525     gdb_test "p value=5" ".*" "set value to 5"
 526     # All this test should do is print 0xdeadbeef once.
 527     gdb_test \
 528         [multi_line_input \
 529              {if value == 1} \
 530              {  p/x 0xfeedface} \
 531              {else} \
 532              {  p/x 0xdeadbeef} \
 533              {end}] \
 534         "$valnum_re = 0xdeadbeef" \
 535         "if test"
 536
 537     # Now let's test for the correct position of the '>' in gdb's
 538     # prompt for commands.  It should be at the beginning of the line,
 539     # and not after one space.
 540
 541     set test "> OK"
 542     gdb_test_multiple "commands" $test {
 543         -re "Type commands.*End with.*\[\r\n\]>$" {
 544             gdb_test_multiple "printf \"Now the value is %d\\n\", value" $test {
 545                 -re "^printf.*value\r\n>$" {
 546                     gdb_test_multiple "end" $test {
 547                         -re "^end\r\n$gdb_prompt $" {
 548                             pass $test
 549                         }
 550                     }
 551                 }
 552             }
 553         }
 554     }
 555 }
 556
 557
 558
 559 proc_with_prefix deprecated_command_test {} {
 560     gdb_test "maintenance deprecate blah" "Can't find command.*" \
 561           "tried to deprecate non-existing command"
 562
 563     gdb_test_no_output "maintenance deprecate p \"new_p\"" "maintenance deprecate p \"new_p\" /1/"
 564     gdb_test "p 5" \
 565             "Warning: 'p', an alias for the command 'print' is deprecated.*Use 'new_p'.*" \
 566             "p deprecated warning, with replacement"
 567     gdb_test "p 5" ".\[0-9\]* = 5.*" "deprecated warning goes away /1/"
 568
 569     gdb_test_no_output "maintenance deprecate p \"new_p\"" "maintenance deprecate p \"new_p\" /2/"
 570     gdb_test_no_output "maintenance deprecate print \"new_print\""
 571     gdb_test "p 5" \
 572             "Warning: command 'print' \\(p\\) is deprecated.*Use 'new_print'.*" \
 573             "both alias and command are deprecated"
 574     gdb_test "p 5" ".\[0-9\]* = 5.*" "deprecated warning goes away /2/"
 575
 576     gdb_test_no_output "maintenance deprecate set remote memory-read-packet-size \"srm\" " \
 577             "deprecate long command /1/"
 578     gdb_test "set remote memory-read-packet-size" \
 579             "Warning: command 'set remote memory-read-packet-size' is deprecated.*Use 'srm'.*" \
 580             "long command deprecated /1/"
 581
 582     gdb_test_no_output "maintenance deprecate set remote memory-read-packet-size" \
 583             "deprecate long command /2/"
 584     gdb_test "set remote memory-read-packet-size" \
 585             "Warning: command 'set remote memory-read-packet-size' is deprecated.*No alternative known.*" \
 586             "long command deprecated with no alternative /2/"
 587
 588     gdb_test "maintenance deprecate" \
 589             "\"maintenance deprecate\".*" \
 590             "deprecate with no arguments"
 591 }
 592
 593 proc_with_prefix bp_deleted_in_command_test {} {
 594     global gdb_prompt
 595
 596     delete_breakpoints
 597
 598     # Create a breakpoint, and associate a command-list to it, with
 599     # one command that deletes this breakpoint.
 600     gdb_test "break factorial" \
 601              "Breakpoint \[0-9\]+ at .*: file .*run.c, line \[0-9\]+\."
 602
 603     gdb_test_multiple "commands" "begin commands" {
 604       -re "Type commands for breakpoint.*>$" {
 605           pass "begin commands"
 606       }
 607     }
 608     gdb_test_multiple "silent" "add silent command" {
 609         -re ">$" {
 610             pass "add silent command"
 611         }
 612     }
 613     gdb_test_multiple "clear factorial" "add clear command" {
 614         -re ">$" {
 615             pass "add clear command"
 616         }
 617     }
 618     gdb_test_multiple "printf \"factorial command-list executed\\n\"" \
 619         "add printf command" {
 620         -re ">$" {
 621             pass "add printf command"
 622         }
 623     }
 624     gdb_test_multiple "cont" "add cont command" {
 625         -re ">$" {
 626             pass "add cont command"
 627         }
 628     }
 629     gdb_test "end" \
 630         "" \
 631         "end commands"
 632
 633     gdb_run_cmd
 634     gdb_test "" "factorial command-list executed.*" "run factorial until breakpoint"
 635 }
 636
 637 proc_with_prefix temporary_breakpoint_commands {} {
 638     global gdb_prompt
 639
 640     delete_breakpoints
 641
 642     # Create a temporary breakpoint, and associate a commands list to it.
 643     # This test will verify that this commands list is executed when the
 644     # breakpoint is hit.
 645     gdb_test "tbreak factorial" \
 646             "Temporary breakpoint \[0-9\]+ at .*: file .*run.c, line \[0-9\]+\." \
 647             "breakpoint"
 648
 649     gdb_test_multiple "commands" \
 650         "begin commands in bp_deleted_in_command_test" {
 651             -re "Type commands for breakpoint.*>$" {
 652                 pass "begin commands"
 653             }
 654         }
 655     gdb_test_multiple "silent" "add silent tbreak command" {
 656         -re ">$" {
 657             pass "add silent tbreak command"
 658         }
 659     }
 660     gdb_test_multiple "printf \"factorial tbreak commands executed\\n\"" \
 661         "add printf tbreak command" {
 662             -re ">$" {
 663                 pass "add printf tbreak command"
 664             }
 665         }
 666     gdb_test_multiple "cont" "add cont tbreak command" {
 667         -re ">$" {
 668             pass "add cont tbreak command"
 669         }
 670     }
 671     gdb_test "end" \
 672         "" \
 673         "end tbreak commands"
 674
 675     gdb_run_cmd
 676     gdb_test "" "factorial tbreak commands executed.*" \
 677         "run factorial until temporary breakpoint"
 678 }
 679
 680 # Test that GDB can handle $arg0 outside of user functions without
 681 # crashing.
 682 proc_with_prefix stray_arg0_test { } {
 683     global valnum_re
 684
 685     gdb_test "print \$arg0" \
 686         "$valnum_re = void" \
 687         "#1"
 688
 689     gdb_test "if 1 == 1\nprint \$arg0\nend" \
 690         "$valnum_re = void" \
 691         "#2"
 692
 693     gdb_test "print \$arg0 = 1" \
 694         "$valnum_re = 1" \
 695         "#3"
 696
 697     gdb_test "print \$arg0" \
 698         "$valnum_re = 1" \
 699         "#4"
 700 }
 701
 702 # Test that GDB is able to source a file with an indented comment.
 703 proc_with_prefix source_file_with_indented_comment {} {
 704     set file1 [standard_output_file file1]
 705
 706     set fd [open "$file1" w]
 707     puts $fd \
 708 {define my_fun
 709     #indented comment
 710 end
 711 echo Done!\n}
 712     close $fd
 713
 714     gdb_test "source $file1" "Done!" "source file"
 715 }
 716
 717 # Test that GDB can handle arguments when sourcing files recursively.
 718 # If the arguments are overwritten with ####### then the test has failed.
 719 proc_with_prefix recursive_source_test {} {
 720     set file1 [standard_output_file file1]
 721     set file2 [standard_output_file file2]
 722     set file3 [standard_output_file file3]
 723
 724     set fd [open "$file1" w]
 725     puts $fd \
 726 "source $file2
 727 abcdef qwerty"
 728     close $fd
 729
 730     set fd [open "$file2" w]
 731     puts $fd \
 732 "define abcdef
 733   echo 1: <<<\$arg0>>>\\n
 734   source $file3
 735   echo 2: <<<\$arg0>>>\\n
 736 end"
 737     close $fd
 738
 739     set fd [open "$file3" w]
 740     puts $fd \
 741 "echo in file3\\n
 742 #################################################################"
 743     close $fd
 744
 745     gdb_test "source $file1" \
 746         "1: <<<qwerty>>>\[\r\n]+in file3\[\r\n]+2: <<<qwerty>>>" \
 747         "source file"
 748
 749     file delete $file1
 750     file delete $file2
 751     file delete $file3
 752 }
 753
 754 proc gdb_test_no_prompt { command result msg } {
 755     global gdb_prompt
 756
 757     set msg "$command - $msg"
 758     set result "^[string_to_regexp $command]\r\n$result$"
 759     gdb_test_multiple $command $msg {
 760         -re "$result" {
 761             pass $msg
 762             return 1
 763         }
 764         -re "\r\n *>$" {
 765             fail $msg
 766             return 0
 767         }
 768     }
 769     return 0
 770 }
 771
 772 proc_with_prefix if_commands_test {} {
 773     global gdb_prompt
 774
 775     gdb_test_no_output "set \$tem = 1" "set \$tem"
 776
 777     set test "if_commands_test 1"
 778     gdb_test_no_prompt "if \$tem == 2" { >} $test
 779     gdb_test_no_prompt "break main" { >} $test
 780     gdb_test_no_prompt "else" { >} $test
 781     gdb_test_no_prompt "break factorial" { >} $test
 782     gdb_test_no_prompt "commands" {  >} $test
 783     gdb_test_no_prompt "silent" {  >} $test
 784     gdb_test_no_prompt "set \$tem = 3" {  >} $test
 785     gdb_test_no_prompt "continue" {  >} $test
 786     gdb_test_multiple "end" "first end - $test" {
 787         -re " >\$" {
 788             pass "first end - $test"
 789         }
 790         -re "\r\n>\$" {
 791             fail "first end - $test"
 792         }
 793     }
 794     gdb_test_multiple "end" "second end - $test" {
 795         -re "Breakpoint \[0-9\]+ at .*: file .*run.c, line \[0-9\]+\.\r\n$gdb_prompt $" {
 796             pass "second end - $test"
 797         }
 798         -re "Undefined command: \"silent\".*$gdb_prompt $" {
 799             fail "second end - $test"
 800         }
 801     }
 802
 803     set test "if_commands_test 2"
 804     gdb_test_no_prompt "if \$tem == 1" { >} $test
 805     gdb_test_no_prompt "break main" { >} $test
 806     gdb_test_no_prompt "else" { >} $test
 807     gdb_test_no_prompt "break factorial" { >} $test
 808     gdb_test_no_prompt "commands" {  >} $test
 809     gdb_test_no_prompt "silent" {  >} $test
 810     gdb_test_no_prompt "set \$tem = 3" {  >} $test
 811     gdb_test_no_prompt "continue" {  >} $test
 812     gdb_test_multiple "end" "first end - $test" {
 813         -re " >\$" {
 814             pass "first end - $test"
 815         }
 816         -re "\r\n>\$" {
 817             fail "first end - $test"
 818         }
 819     }
 820     gdb_test_multiple "end" "second end - $test" {
 821         -re "Breakpoint \[0-9\]+ at .*: file .*run.c, line \[0-9\]+\.\r\n$gdb_prompt $" {
 822             pass "second end - $test"
 823         }
 824     }
 825 }
 826
 827 # Verify an error during "commands" commands execution will prevent any other
 828 # "commands" from other breakpoints at the same location to be executed.
 829
 830 proc_with_prefix error_clears_commands_left {} {
 831     set test "hook-stop 1"
 832     gdb_test_multiple {define hook-stop} $test {
 833         -re "End with a line saying just \"end\"\\.\r\n>$" {
 834             pass $test
 835         }
 836     }
 837     set test "hook-stop 1a"
 838     gdb_test_multiple {echo hook-stop1\n} $test {
 839         -re "\r\n>$" {
 840             pass $test
 841         }
 842     }
 843     gdb_test_no_output "end" "hook-stop 1b"
 844
 845     delete_breakpoints
 846     gdb_breakpoint "main"
 847
 848     set test "main commands 1"
 849     gdb_test_multiple {commands $bpnum} $test {
 850         -re "End with a line saying just \"end\"\\.\r\n>$" {
 851             pass $test
 852         }
 853     }
 854     set test "main commands 1a"
 855     gdb_test_multiple {echo cmd1\n} $test {
 856         -re "\r\n>$" {
 857             pass $test
 858         }
 859     }
 860     set test "main commands 1b"
 861     gdb_test_multiple {errorcommandxy\n} $test {
 862         -re "\r\n>$" {
 863             pass $test
 864         }
 865     }
 866     gdb_test_no_output "end" "main commands 1c"
 867
 868     gdb_breakpoint "main"
 869     set test "main commands 2"
 870     gdb_test_multiple {commands $bpnum} $test {
 871         -re "End with a line saying just \"end\"\\.\r\n>$" {
 872             pass $test
 873         }
 874     }
 875     set test "main commands 2a"
 876     gdb_test_multiple {echo cmd2\n} $test {
 877         -re "\r\n>$" {
 878             pass $test
 879         }
 880     }
 881     set test "main commands 2b"
 882     gdb_test_multiple {errorcommandyz\n} $test {
 883         -re "\r\n>$" {
 884             pass $test
 885         }
 886     }
 887     gdb_test_no_output "end" "main commands 2c"
 888
 889     gdb_run_cmd
 890     gdb_test \
 891         "" \
 892         [multi_line \
 893              "hook-stop1" \
 894              ".*" \
 895              "cmd1" \
 896              "Undefined command: \"errorcommandxy\"\\.  Try \"help\"\\."] \
 897         "cmd1 error"
 898
 899     gdb_test {echo idle\n} "\r\nidle" "no cmd2"
 900 }
 901
 902 proc_with_prefix redefine_hook_test {} {
 903     global gdb_prompt
 904
 905     gdb_test \
 906         [multi_line_input \
 907              "define one"\
 908              "end"] \
 909         "" \
 910         "define one"
 911
 912     gdb_test \
 913         [multi_line_input \
 914              "define hook-one" \
 915              "echo hibob\\n" \
 916              "end"] \
 917         "" \
 918         "define hook-one"
 919
 920     set test "redefine one"
 921     gdb_test_multiple "define one" $test {
 922         -re "Redefine command .one.. .y or n. $" {
 923             send_gdb "y\n"
 924             exp_continue
 925         }
 926
 927         -re "End with"  {
 928             pass $test
 929         }
 930     }
 931
 932     gdb_test "end" "" "enter commands for one redefinition"
 933
 934     gdb_test "one" "hibob" "execute one command"
 935 }
 936
 937 proc_with_prefix redefine_backtrace_test {} {
 938     global gdb_prompt
 939
 940     gdb_test_multiple "define backtrace" "define backtrace" {
 941         -re "Really redefine built-in command \"backtrace\"\\? \\(y or n\\) $"  {
 942             pass "define backtrace"
 943         }
 944     }
 945
 946     gdb_test_multiple "y" "expect response to define backtrace" {
 947         -re "End with a line saying just \"end\"\\.\r\n>$"  {
 948             pass "expect response to define backtrace"
 949         }
 950     }
 951
 952     gdb_test \
 953         [multi_line_input \
 954              "echo hibob\\n" \
 955              "end"] \
 956         "" \
 957         "enter commands"
 958
 959     gdb_test "backtrace" "hibob" "execute backtrace command"
 960     gdb_test "bt" "hibob" "execute bt command"
 961 }
 962
 963 gdbvar_simple_if_test
 964 gdbvar_simple_while_test
 965 gdbvar_complex_if_while_test
 966 progvar_simple_if_test
 967 progvar_simple_while_test
 968 progvar_complex_if_while_test
 969 if_while_breakpoint_command_test
 970 infrun_breakpoint_command_test
 971 breakpoint_command_test
 972 user_defined_command_test
 973 user_defined_command_args_eval
 974 user_defined_command_args_stack_test
 975 watchpoint_command_test
 976 test_command_prompt_position
 977 deprecated_command_test
 978 bp_deleted_in_command_test
 979 temporary_breakpoint_commands
 980 stray_arg0_test
 981 source_file_with_indented_comment
 982 recursive_source_test
 983 if_commands_test
 984 error_clears_commands_left
 985 redefine_hook_test
 986 # This one should come last, as it redefines "backtrace".
 987 redefine_backtrace_test