gdb/testsuite/gdb.base/commands.exp

   1 #   Copyright 1988, 1990, 1991, 1992, 1994, 1995, 1997, 1998, 1999, 2000,
   2 #   2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   3 #   Free Software Foundation, Inc.
   4
   5 # This program is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 3 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 if $tracelevel then {
  19     strace $tracelevel
  20 }
  21
  22 #
  23 # test special commands (if, while, etc)
  24 #
  25
  26 if { [prepare_for_testing commands.exp commands run.c {debug additional_flags=-DFAKEARGV}] } {
  27     return -1
  28 }
  29
  30 proc gdbvar_simple_if_test {} {
  31     global gdb_prompt
  32
  33     gdb_test_no_output "set \$foo = 0" "set foo in gdbvar_simple_if_test"
  34     # All this test should do is print 0xdeadbeef once.
  35     gdb_test "if \$foo == 1\np/x 0xfeedface\nelse\np/x 0xdeadbeef\nend" \
  36             "\\\$\[0-9\]* = 0xdeadbeef" "gdbvar_simple_if_test #1"
  37     # All this test should do is print 0xfeedface once.
  38     gdb_test "if \$foo == 0\np/x 0xfeedface\nelse\np/x 0xdeadbeef\nend" \
  39             "\\\$\[0-9\]* = 0xfeedface" "gdbvar_simple_if_test #2"
  40 }
  41
  42 proc gdbvar_simple_while_test {} {
  43     global gdb_prompt
  44
  45     gdb_test_no_output "set \$foo = 5" "set foo in gdbvar_simple_while_test"
  46     # This test should print 0xfeedface five times.
  47     gdb_test "while \$foo > 0\np/x 0xfeedface\nset \$foo -= 1\nend" \
  48             "\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface" \
  49             "gdbvar_simple_while_test #1"
  50 }
  51
  52 proc gdbvar_complex_if_while_test {} {
  53     global gdb_prompt
  54
  55     gdb_test_no_output "set \$foo = 4" \
  56         "set foo in gdbvar complex_if_while_test"
  57     # This test should alternate between 0xdeadbeef and 0xfeedface two times.
  58     gdb_test "while \$foo > 0\nset \$foo -= 1\nif \(\$foo % 2\) == 1\np/x 0xdeadbeef\nelse\np/x 0xfeedface\nend\nend" \
  59             "\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface" \
  60             "gdbvar_complex_if_while_test #1"
  61 }
  62
  63 proc progvar_simple_if_test {} {
  64     global gdb_prompt
  65
  66     if [target_info exists noargs] {
  67         verbose "Skipping progvar_simple_if_test because of noargs."
  68         return
  69     }
  70
  71     if { ![runto factorial] } then { gdb_suppress_tests; }
  72     # Don't depend upon argument passing, since most simulators don't
  73     # currently support it.  Bash value variable to be what we want.
  74     gdb_test "p value=5" ".*" "set value to 5 in progvar_simple_if_test #1"
  75     # All this test should do is print 0xdeadbeef once.
  76     gdb_test "if value == 1\np/x 0xfeedface\nelse\np/x 0xdeadbeef\nend" \
  77             "\\\$\[0-9\]* = 0xdeadbeef" \
  78             "progvar_simple_if_test #1"
  79     # All this test should do is print 0xfeedface once.
  80     gdb_test "if value == 5\np/x 0xfeedface\nelse\np/x 0xdeadbeef\nend" \
  81             "\\\$\[0-9\]* = 0xfeedface" \
  82             "progvar_simple_if_test #2"
  83     gdb_stop_suppressing_tests;
  84 }
  85
  86 proc progvar_simple_while_test {} {
  87     global gdb_prompt
  88
  89     if [target_info exists noargs] {
  90         verbose "Skipping progvar_simple_while_test because of noargs."
  91         return
  92     }
  93
  94     gdb_test_no_output "set args 5" "set args in progvar_simple_while_test"
  95     if { ![runto factorial] } then { gdb_suppress_tests }
  96     # Don't depend upon argument passing, since most simulators don't
  97     # currently support it.  Bash value variable to be what we want.
  98     gdb_test "p value=5" ".*" "set value to 5 in progvar_simple_if_test #2"
  99     # This test should print 0xfeedface five times.
 100     gdb_test "while value > 0\np/x 0xfeedface\nset value -= 1\nend" \
 101             "\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface" \
 102             "progvar_simple_while_test #1"
 103     gdb_stop_suppressing_tests;
 104 }
 105
 106 proc progvar_complex_if_while_test {} {
 107     global gdb_prompt
 108
 109     if [target_info exists noargs] {
 110         verbose "Skipping progvar_simple_if_while_test because of noargs."
 111         return
 112     }
 113
 114     gdb_test_no_output "set args 4" \
 115         "set args in progvar_complex_if_while_test"
 116     if { ![runto factorial] } then { gdb_suppress_tests }
 117     # Don't depend upon argument passing, since most simulators don't
 118     # currently support it.  Bash value variable to be what we want.
 119     gdb_test "p value=4" ".*" "set value to 4 in progvar_simple_if_test"
 120     # This test should alternate between 0xdeadbeef and 0xfeedface two times.
 121     gdb_test "while value > 0\nset value -= 1\nif \(value % 2\) == 1\np/x 0xdeadbeef\nelse\np/x 0xfeedface\nend\nend" \
 122             "\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface" \
 123             "progvar_complex_if_while_test #1"
 124     gdb_stop_suppressing_tests;
 125 }
 126
 127 proc if_while_breakpoint_command_test {} {
 128     if [target_info exists noargs] {
 129         verbose "Skipping if_while_breakpoint_command_test because of noargs."
 130         return
 131     }
 132
 133     gdb_test_no_output "set args 5" \
 134         "set args in if_while_breakpoint_command_test"
 135     if { ![runto factorial] } then { gdb_suppress_tests }
 136     # Don't depend upon argument passing, since most simulators don't
 137     # currently support it.  Bash value variable to be what we want.
 138     gdb_test "p value=5" ".*" "set value to 5 in progvar_simple_if_test"
 139     delete_breakpoints
 140     gdb_test "break factorial" "Breakpoint.*at.*" "break factorial #1"
 141
 142     gdb_test_multiple "commands" \
 143         "commands in if_while_breakpoint_command_test" {
 144             -re "End with" {
 145                 pass "commands in if_while_breakpoint_command_test"
 146             }
 147         }
 148
 149     # This test should alternate between 0xdeadbeef and 0xfeedface two times.
 150     gdb_test "while value > 0\nset value -= 1\nif \(value % 2\) == 1\np/x 0xdeadbeef\nelse\np/x 0xfeedface\nend\nend\nend" \
 151             "" \
 152             "commands part 2 in if_while_breakpoint_command_test"
 153     gdb_test "continue" \
 154             "\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface" \
 155             "if_while_breakpoint_command_test #1"
 156    gdb_test "info break" \
 157            "while.*set.*if.*p/x.*else.*p/x.*end.*" \
 158            "info break in if_while_breakpoint_command_test"
 159     gdb_stop_suppressing_tests;
 160 }
 161
 162 # Test that we can run the inferior from breakpoint commands.
 163 #
 164 # The expected behavior is that all commands after the first "step"
 165 # shall be ignored.  See the gdb manual, "Break Commands",
 166 # subsection "Breakpoint command lists".
 167
 168 proc infrun_breakpoint_command_test {} {
 169     if [target_info exists noargs] {
 170         verbose "Skipping infrun_breakpoint_command_test because of noargs."
 171         return
 172     }
 173
 174     gdb_test_no_output "set args 6" \
 175         "set args in infrun_breakpoint_command_test"
 176     if { ![runto factorial] } then { gdb_suppress_tests }
 177     # Don't depend upon argument passing, since most simulators don't
 178     # currently support it.  Bash value variable to be what we want.
 179     gdb_test "p value=6" ".*" "set value to 6 in progvar_simple_if_test #1"
 180     delete_breakpoints
 181     gdb_test "break factorial if value == 5" "Breakpoint.*at.*"
 182
 183 # infrun_breakpoint_command_test - This test was broken into two parts
 184 # to get around a synchronization problem in expect.
 185 # part1: issue the gdb command "commands"
 186 # part2: send the list of commands
 187     gdb_test_multiple "commands" \
 188         "commands in infrun_breakpoint_command_test #1" {
 189             -re "End with" {
 190                 pass "commands in infrun_breakpoint_command_test #1"
 191             }
 192         }
 193     gdb_test "step\nstep\nstep\nstep\nend" "" \
 194         "commands in infrun_breakpoint_command_test #2"
 195
 196     gdb_test "continue" \
 197         "Continuing.*.*.*Breakpoint \[0-9\]*, factorial \\(value=5\\).*at.*\[0-9\]*\[      \]*if \\(value > 1\\) \{.*\[0-9\]*\[      \]*value \\*= factorial \\(value - 1\\);.*" \
 198         "continue in infrun_breakpoint_command_test"
 199
 200     gdb_stop_suppressing_tests;
 201 }
 202
 203 proc breakpoint_command_test {} {
 204     if [target_info exists noargs] {
 205         verbose "Skipping breakpoint_command_test because of noargs."
 206         return
 207     }
 208
 209     gdb_test_no_output "set args 6" "set args in breakpoint_command_test"
 210     if { ![runto factorial] } then { gdb_suppress_tests; }
 211     # Don't depend upon argument passing, since most simulators don't
 212     # currently support it.  Bash value variable to be what we want.
 213     gdb_test "p value=6" ".*" "set value to 6 in progvar_simple_if_test #2"
 214     delete_breakpoints
 215     gdb_test "break factorial" "Breakpoint.*at.*" "break factorial #2"
 216     gdb_test "commands\nprintf \"Now the value is %d\\n\", value\nend" \
 217         "End with.*" "commands in breakpoint_command_test"
 218     gdb_test "continue" \
 219             "Breakpoint \[0-9\]*, factorial.*Now the value is 5" \
 220         "continue in breakpoint_command_test"
 221     gdb_test "print value" " = 5" "print value in breakpoint_command_test"
 222     gdb_stop_suppressing_tests;
 223 }
 224
 225 # Test a simple user defined command (with arguments)
 226 proc user_defined_command_test {} {
 227     global gdb_prompt
 228
 229     gdb_test_no_output "set \$foo = 4" \
 230         "set foo in user_defined_command_test"
 231
 232     gdb_test_multiple "define mycommand" \
 233         "define mycommand in user_defined_command_test" {
 234             -re "End with"  {
 235                 pass "define mycommand in user_defined_command_test"
 236             }
 237         }
 238
 239     # This test should alternate between 0xdeadbeef and 0xfeedface two times.
 240     gdb_test "while \$arg0 > 0\nset \$arg0 -= 1\nif \(\$arg0 % 2\) == 1\np/x 0xdeadbeef\nelse\np/x 0xfeedface\nend\nend\nend" \
 241             "" \
 242             "enter commands in user_defined_command_test"
 243
 244     gdb_test "mycommand \$foo" \
 245             "\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface" \
 246             "execute user defined command in user_defined_command_test"
 247    gdb_test "show user mycommand" \
 248         "  while \\\$arg0.*set.*    if \\\(\\\$arg0.*p/x.*    else\[^\n\].*p/x.*    end\[^\n\].*  end\[^\n\].*" \
 249            "display user command in user_defined_command_test"
 250 }
 251
 252 proc watchpoint_command_test {} {
 253     global noargs
 254     global gdb_prompt
 255
 256     if [target_info exists noargs] {
 257         verbose "Skipping watchpoint_command_test because of noargs."
 258         return
 259     }
 260
 261     # Disable hardware watchpoints if necessary.
 262     if [target_info exists gdb,no_hardware_watchpoints] {
 263         gdb_test_no_output "set can-use-hw-watchpoints 0" ""
 264     }
 265
 266     gdb_test_no_output "set args 6" "set args in watchpoint_command_test"
 267     if { ![runto factorial] } then { return }
 268     delete_breakpoints
 269
 270     # Verify that we can create a watchpoint, and give it a commands
 271     # list that continues the inferior.  We set the watchpoint on a
 272     # local variable, too, so that it self-deletes when the watched
 273     # data goes out of scope.
 274     #
 275     # What should happen is: Each time the watchpoint triggers, it
 276     # continues the inferior.  Eventually, the watchpoint will self-
 277     # delete, when the watched variable is out of scope.  But by that
 278     # time, the inferior should have exited.  GDB shouldn't crash or
 279     # anything untoward as a result of this.
 280     #
 281     set wp_id -1
 282
 283     gdb_test_multiple "watch local_var" "watch local_var" {
 284         -re "\[Ww\]atchpoint (\[0-9\]*): local_var.*$gdb_prompt $" {
 285             set wp_id $expect_out(1,string)
 286             pass "watch local_var"
 287         }
 288     }
 289
 290     if {$wp_id == -1} {return}
 291
 292     gdb_test_multiple "commands $wp_id" "begin commands on watch" {
 293         -re "Type commands for breakpoint.*, one per line.*>$" {
 294             pass "begin commands on watch"
 295         }
 296     }
 297     # See the 'No symbol "value...' fail below.  This command will
 298     # fail if it's executed in the wrong frame.  If adjusting the
 299     # test, make sure this property holds.
 300     gdb_test_multiple "print value" "add print command to watch" {
 301         -re ">$" {
 302             pass "add print command to watch"
 303         }
 304     }
 305     gdb_test_multiple "continue" "add continue command to watch" {
 306         -re ">$" {
 307             pass "add continue command to watch"
 308         }
 309     }
 310     gdb_test "end" \
 311         "" \
 312         "end commands on watch"
 313
 314     set test "continue with watch"
 315     gdb_test_multiple "continue" "$test" {
 316         -re "No symbol \"value\" in current context.\r\n$gdb_prompt $" {
 317             # Happens if GDB actually runs the watchpoints commands,
 318             # even though the watchpoint was deleted for not being in
 319             # scope.
 320             fail $test
 321         }
 322         -re "Continuing.*\[Ww\]atchpoint $wp_id deleted because the program has left the block in.*which its expression is valid.*run.c:(53|77).*$gdb_prompt $" {
 323             pass $test
 324         }
 325    }
 326 }
 327
 328 proc test_command_prompt_position {} {
 329     global gdb_prompt
 330
 331     if [target_info exists noargs] {
 332         verbose "Skipping test_command_prompt_position because of noargs."
 333         return
 334     }
 335
 336     if { ![runto factorial] } then { gdb_suppress_tests; }
 337     # Don't depend upon argument passing, since most simulators don't
 338     # currently support it.  Bash value variable to be what we want.
 339     delete_breakpoints
 340     gdb_test "break factorial" "Breakpoint.*at.*" "break factorial #3"
 341     gdb_test "p value=5" ".*" "set value to 5 in test_command_prompt_position"
 342     # All this test should do is print 0xdeadbeef once.
 343     gdb_test "if value == 1\np/x 0xfeedface\nelse\np/x 0xdeadbeef\nend" \
 344             "\\\$\[0-9\]* = 0xdeadbeef" \
 345             "if test in test_command_prompt_position"
 346
 347     # Now let's test for the correct position of the '>' in gdb's
 348     # prompt for commands.  It should be at the beginning of the line,
 349     # and not after one space.
 350
 351     send_gdb "commands\n"
 352     gdb_expect {
 353         -re "Type commands.*End with.*\[\r\n\]>$" {
 354             send_gdb "printf \"Now the value is %d\\n\", value\n"
 355             gdb_expect {
 356                 -re "^printf.*value\r\n>$" {
 357                     send_gdb "end\n"
 358                     gdb_expect {
 359                         -re "^end\r\n$gdb_prompt $" {
 360                             pass "> OK in test_command_prompt_position"
 361                         }
 362                         -re ".*$gdb_prompt $" {
 363                             fail "some other message in test_command_prompt_position"
 364                         }
 365                         timeout  {
 366                             fail "(timeout) 1 in test_command_prompt_position"
 367                         }
 368                     }
 369                 }
 370                 -re "^ >$" { fail "> not OK in test_command_prompt_position" }
 371                 -re ".*$gdb_prompt $"   {
 372                     fail "wrong message in test_command_prompt_position"
 373                 }
 374                 timeout    {
 375                     fail "(timeout) 2 in test_command_prompt_position "
 376                 }
 377             }
 378         }
 379         -re "Type commands.*End with.*\[\r\n\] >$" {
 380             fail "prompt not OK in test_command_prompt_position"
 381         }
 382         -re ".*$gdb_prompt $" {
 383             fail "commands in test_command_prompt_position"
 384         }
 385         timeout { fail "(timeout) 3 commands in test_command_prompt_position" }
 386     }
 387
 388     gdb_stop_suppressing_tests;
 389 }
 390
 391
 392
 393 proc deprecated_command_test {} {
 394     gdb_test "maintenance deprecate blah" "Can't find command.*" \
 395           "tried to deprecate non-existing command"
 396
 397     gdb_test_no_output "maintenance deprecate p \"new_p\"" "maintenance deprecate p \"new_p\" /1/"
 398     gdb_test "p 5" \
 399             "Warning: 'p', an alias for the command 'print' is deprecated.*Use 'new_p'.*" \
 400             "p deprecated warning, with replacement"
 401     gdb_test "p 5" ".\[0-9\]* = 5.*" "Deprecated warning goes away /1/"
 402
 403     gdb_test_no_output "maintenance deprecate p \"new_p\"" "maintenance deprecate p \"new_p\" /2/"
 404     gdb_test_no_output "maintenance deprecate print \"new_print\""
 405     gdb_test "p 5" \
 406             "Warning: command 'print' \\(p\\) is deprecated.*Use 'new_print'.*" \
 407             "both alias and command are deprecated"
 408     gdb_test "p 5" ".\[0-9\]* = 5.*" "Deprecated warning goes away /2/"
 409
 410     gdb_test_no_output "maintenance deprecate set remote memory-read-packet-size \"srm\" " \
 411             "deprecate long command /1/"
 412     gdb_test "set remote memory-read-packet-size" \
 413             "Warning: command 'set remote memory-read-packet-size' is deprecated.*Use 'srm'.*" \
 414             "long command deprecated /1/"
 415
 416     gdb_test_no_output "maintenance deprecate set remote memory-read-packet-size" \
 417             "deprecate long command /2/"
 418     gdb_test "set remote memory-read-packet-size" \
 419             "Warning: command 'set remote memory-read-packet-size' is deprecated.*No alternative known.*" \
 420             "long command deprecated with no alternative /2/"
 421
 422     gdb_test "maintenance deprecate" \
 423             "\"maintenance deprecate\".*" \
 424             "deprecate with no arguments"
 425 }
 426
 427 proc bp_deleted_in_command_test {} {
 428     global gdb_prompt
 429
 430     if [target_info exists noargs] {
 431         verbose "Skipping bp_deleted_in_command_test because of noargs."
 432         return
 433     }
 434
 435     gdb_test_no_output "set args 1" \
 436         "set args in bp_deleted_in_command_test"
 437     delete_breakpoints
 438
 439     # Create a breakpoint, and associate a command-list to it, with
 440     # one command that deletes this breakpoint.
 441     gdb_test "break factorial" \
 442              "Breakpoint \[0-9\]+ at .*: file .*run.c, line \[0-9\]+\." \
 443              "breakpoint in bp_deleted_in_command_test"
 444
 445     gdb_test_multiple "commands" "begin commands in bp_deleted_in_command_test" {
 446       -re "Type commands for breakpoint.*>$" {
 447           pass "begin commands in bp_deleted_in_command_test"
 448       }
 449     }
 450     gdb_test_multiple "silent" "add silent command" {
 451         -re ">$" {
 452             pass "add silent command"
 453         }
 454     }
 455     gdb_test_multiple "clear factorial" "add clear command" {
 456         -re ">$" {
 457             pass "add clear command"
 458         }
 459     }
 460     gdb_test_multiple "printf \"factorial command-list executed\\n\"" \
 461         "add printf command" {
 462         -re ">$" {
 463             pass "add printf command"
 464         }
 465     }
 466     gdb_test_multiple "cont" "add cont command" {
 467         -re ">$" {
 468             pass "add cont command"
 469         }
 470     }
 471     gdb_test "end" \
 472         "" \
 473         "end commands"
 474
 475     gdb_run_cmd
 476     gdb_expect {
 477         -re ".*factorial command-list executed.*$gdb_prompt $" {
 478             pass "run factorial until breakpoint"
 479         }
 480         -re ".*$gdb_prompt $" {
 481             fail "run factorial until breakpoint"
 482         }
 483         default { fail "(timeout) run factorial until breakpoint" }
 484         timeout { fail "(timeout) run factorial until breakpoint" }
 485     }
 486 }
 487
 488 proc temporary_breakpoint_commands {} {
 489     global gdb_prompt
 490
 491     if [target_info exists noargs] {
 492         verbose "Skipping temporary_breakpoint_commands because of noargs."
 493         return
 494     }
 495
 496     gdb_test_no_output "set args 1" \
 497         "set args in temporary_breakpoint_commands"
 498     delete_breakpoints
 499
 500     # Create a temporary breakpoint, and associate a commands list to it.
 501     # This test will verify that this commands list is executed when the
 502     # breakpoint is hit.
 503     gdb_test "tbreak factorial" \
 504             "Temporary breakpoint \[0-9\]+ at .*: file .*run.c, line \[0-9\]+\." \
 505             "breakpoint in temporary_breakpoint_commands"
 506
 507     gdb_test_multiple "commands" \
 508         "begin commands in bp_deleted_in_command_test" {
 509             -re "Type commands for breakpoint.*>$" {
 510                 pass "begin commands in bp_deleted_in_command_test"
 511             }
 512         }
 513     gdb_test_multiple "silent" "add silent tbreak command" {
 514         -re ">$" {
 515             pass "add silent tbreak command"
 516         }
 517     }
 518     gdb_test_multiple "printf \"factorial tbreak commands executed\\n\"" \
 519         "add printf tbreak command" {
 520             -re ">$" {
 521                 pass "add printf tbreak command"
 522             }
 523         }
 524     gdb_test_multiple "cont" "add cont tbreak command" {
 525         -re ">$" {
 526             pass "add cont tbreak command"
 527         }
 528     }
 529     gdb_test "end" \
 530         "" \
 531         "end tbreak commands"
 532
 533     gdb_run_cmd
 534     gdb_expect {
 535         -re ".*factorial tbreak commands executed.*$gdb_prompt $" {
 536             pass "run factorial until temporary breakpoint"
 537         }
 538         timeout { fail "(timeout) run factorial until temporary breakpoint" }
 539     }
 540 }
 541
 542 # Test that GDB can handle $arg0 outside of user functions without
 543 # crashing.
 544 proc stray_arg0_test { } {
 545     gdb_test "print \$arg0" \
 546         "\\\$\[0-9\]* = void" \
 547         "stray_arg0_test #1"
 548
 549     gdb_test "if 1 == 1\nprint \$arg0\nend" \
 550         "\\\$\[0-9\]* = void" \
 551         "stray_arg0_test #2"
 552
 553     gdb_test "print \$arg0 = 1" \
 554         "\\\$\[0-9\]* = 1" \
 555         "stray_arg0_test #3"
 556
 557     gdb_test "print \$arg0" \
 558         "\\\$\[0-9\]* = 1" \
 559         "stray_arg0_test #4"
 560 }
 561
 562 # Test that GDB is able to source a file with an indented comment.
 563 proc source_file_with_indented_comment {} {
 564     set fd [open "file1" w]
 565     puts $fd \
 566 {define my_fun
 567     #indented comment
 568 end
 569 echo Done!\n}
 570     close $fd
 571
 572     gdb_test "source file1" "Done!" "source file with indented comment"
 573 }
 574
 575 # Test that GDB can handle arguments when sourcing files recursively.
 576 # If the arguments are overwritten with ####### then the test has failed.
 577 proc recursive_source_test {} {
 578     set fd [open "file1" w]
 579     puts $fd \
 580 {source file2
 581 abcdef qwerty}
 582     close $fd
 583
 584     set fd [open "file2" w]
 585     puts $fd \
 586 {define abcdef
 587   echo 1: <<<$arg0>>>\n
 588   source file3
 589   echo 2: <<<$arg0>>>\n
 590 end}
 591     close $fd
 592
 593     set fd [open "file3" w]
 594     puts $fd \
 595 "echo in file3\\n
 596 #################################################################"
 597     close $fd
 598
 599     gdb_test "source file1" \
 600         "1: <<<qwerty>>>\[\r\n]+in file3\[\r\n]+2: <<<qwerty>>>" \
 601         "recursive source test"
 602
 603     file delete file1
 604     file delete file2
 605     file delete file3
 606 }
 607
 608 proc gdb_test_no_prompt { command result msg } {
 609     global gdb_prompt
 610
 611     set msg "$command - $msg"
 612     set result "^[string_to_regexp $command]\r\n$result$"
 613     gdb_test_multiple $command $msg {
 614         -re "$result" {
 615             pass $msg
 616             return 1
 617         }
 618         -re "\r\n *>$" {
 619             fail $msg
 620             return 0
 621         }
 622     }
 623     return 0
 624 }
 625
 626 proc if_commands_test {} {
 627     global gdb_prompt
 628
 629     gdb_test_no_output "set \$tem = 1" "set \$tem in if_commands_test"
 630
 631     set test "if_commands_test 1"
 632     gdb_test_no_prompt "if \$tem == 2" { >} $test
 633     gdb_test_no_prompt "break main" { >} $test
 634     gdb_test_no_prompt "else" { >} $test
 635     gdb_test_no_prompt "break factorial" { >} $test
 636     gdb_test_no_prompt "commands" {  >} $test
 637     gdb_test_no_prompt "silent" {  >} $test
 638     gdb_test_no_prompt "set \$tem = 3" {  >} $test
 639     gdb_test_no_prompt "continue" {  >} $test
 640     gdb_test_multiple "end" "first end - $test" {
 641         -re " >\$" {
 642             pass "first end - $test"
 643         }
 644         -re "\r\n>\$" {
 645             fail "first end - $test"
 646         }
 647     }
 648     gdb_test_multiple "end" "second end - $test" {
 649         -re "Breakpoint \[0-9\]+ at .*: file .*run.c, line \[0-9\]+\.\r\n$gdb_prompt $" {
 650             pass "second end - $test"
 651         }
 652         -re "Undefined command: \"silent\".*$gdb_prompt $" {
 653             fail "second end - $test"
 654         }
 655     }
 656
 657     set test "if_commands_test 2"
 658     gdb_test_no_prompt "if \$tem == 1" { >} $test
 659     gdb_test_no_prompt "break main" { >} $test
 660     gdb_test_no_prompt "else" { >} $test
 661     gdb_test_no_prompt "break factorial" { >} $test
 662     gdb_test_no_prompt "commands" {  >} $test
 663     gdb_test_no_prompt "silent" {  >} $test
 664     gdb_test_no_prompt "set \$tem = 3" {  >} $test
 665     gdb_test_no_prompt "continue" {  >} $test
 666     gdb_test_multiple "end" "first end - $test" {
 667         -re " >\$" {
 668             pass "first end - $test"
 669         }
 670         -re "\r\n>\$" {
 671             fail "first end - $test"
 672         }
 673     }
 674     gdb_test_multiple "end" "second end - $test" {
 675         -re "Breakpoint \[0-9\]+ at .*: file .*run.c, line \[0-9\]+\.\r\n$gdb_prompt $" {
 676             pass "second end - $test"
 677         }
 678     }
 679 }
 680
 681 # Verify an error during "commands" commands execution will prevent any other
 682 # "commands" from other breakpoints at the same location to be executed.
 683
 684 proc error_clears_commands_left {} {
 685     set test "hook-stop 1"
 686     gdb_test_multiple {define hook-stop} $test {
 687         -re "End with a line saying just \"end\"\\.\r\n>$" {
 688             pass $test
 689         }
 690     }
 691     set test "hook-stop 1a"
 692     gdb_test_multiple {echo hook-stop1\n} $test {
 693         -re "\r\n>$" {
 694             pass $test
 695         }
 696     }
 697     gdb_test_no_output "end" "hook-stop 1b"
 698
 699     delete_breakpoints
 700     gdb_breakpoint "main"
 701
 702     set test "main commands 1"
 703     gdb_test_multiple {commands $bpnum} $test {
 704         -re "End with a line saying just \"end\"\\.\r\n>$" {
 705             pass $test
 706         }
 707     }
 708     set test "main commands 1a"
 709     gdb_test_multiple {echo cmd1\n} $test {
 710         -re "\r\n>$" {
 711             pass $test
 712         }
 713     }
 714     set test "main commands 1b"
 715     gdb_test_multiple {errorcommandxy\n} $test {
 716         -re "\r\n>$" {
 717             pass $test
 718         }
 719     }
 720     gdb_test_no_output "end" "main commands 1c"
 721
 722     gdb_breakpoint "main"
 723     set test "main commands 2"
 724     gdb_test_multiple {commands $bpnum} $test {
 725         -re "End with a line saying just \"end\"\\.\r\n>$" {
 726             pass $test
 727         }
 728     }
 729     set test "main commands 2a"
 730     gdb_test_multiple {echo cmd2\n} $test {
 731         -re "\r\n>$" {
 732             pass $test
 733         }
 734     }
 735     set test "main commands 2b"
 736     gdb_test_multiple {errorcommandyz\n} $test {
 737         -re "\r\n>$" {
 738             pass $test
 739         }
 740     }
 741     gdb_test_no_output "end" "main commands 2c"
 742
 743     gdb_run_cmd
 744     gdb_test "" "hook-stop1\r\n.*\r\ncmd1\r\nUndefined command: \"errorcommandxy\"\\.  Try \"help\"\\." "cmd1 error"
 745
 746     gdb_test {echo idle\n} "\r\nidle" "no cmd2"
 747 }
 748
 749 proc redefine_hook_test {} {
 750     global gdb_prompt
 751
 752     gdb_test "define one\nend" \
 753       "" \
 754       "define one"
 755
 756     gdb_test "define hook-one\necho hibob\\n\nend" \
 757       "" \
 758       "define hook-one"
 759
 760     gdb_test_multiple "define one" "redefine one" {
 761         -re "Redefine command .one.. .y or n. $" {
 762             send_gdb "y\n"
 763             exp_continue
 764         }
 765
 766         -re "End with"  {
 767             pass "define one in redefine_hook_test"
 768         }
 769         default {
 770             fail "(timeout or eof) define one in redefine_hook_test"
 771         }
 772     }
 773
 774     gdb_test "end" \
 775             "" \
 776             "enter commands for one redefinition in redefine_hook_test"
 777
 778     gdb_test "one" \
 779             "hibob" \
 780             "execute one command in redefine_hook_test"
 781 }
 782
 783 proc redefine_backtrace_test {} {
 784     global gdb_prompt
 785
 786     gdb_test_multiple "define backtrace" "define backtrace" {
 787         -re "Really redefine built-in command \"backtrace\"\\? \\(y or n\\) $"  {
 788             pass "define backtrace"
 789         }
 790     }
 791
 792     gdb_test_multiple "y" "expect response to define backtrace" {
 793         -re "End with a line saying just \"end\"\\.\r\n>$"  {
 794             pass "expect response to define backtrace"
 795         }
 796     }
 797
 798     gdb_test "echo hibob\\n\nend" \
 799             "" \
 800             "enter commands in redefine_backtrace_test"
 801
 802     gdb_test "backtrace" \
 803             "hibob" \
 804             "execute backtrace command in redefine_backtrace_test"
 805     gdb_test "bt" \
 806             "hibob" \
 807             "execute bt command in redefine_backtrace_test"
 808 }
 809
 810 gdbvar_simple_if_test
 811 gdbvar_simple_while_test
 812 gdbvar_complex_if_while_test
 813 progvar_simple_if_test
 814 progvar_simple_while_test
 815 progvar_complex_if_while_test
 816 if_while_breakpoint_command_test
 817 infrun_breakpoint_command_test
 818 breakpoint_command_test
 819 user_defined_command_test
 820 watchpoint_command_test
 821 test_command_prompt_position
 822 deprecated_command_test
 823 bp_deleted_in_command_test
 824 temporary_breakpoint_commands
 825 stray_arg0_test
 826 source_file_with_indented_comment
 827 recursive_source_test
 828 if_commands_test
 829 error_clears_commands_left
 830 redefine_hook_test
 831 # This one should come last, as it redefines "backtrace".
 832 redefine_backtrace_test