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 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 # Please email any bugs, comments, and/or additions to this file to:
  18 # bug-gdb@prep.ai.mit.edu
  19
  20 if $tracelevel then {
  21     strace $tracelevel
  22 }
  23
  24 #
  25 # test special commands (if, while, etc)
  26 #
  27 set prms_id 0
  28 set bug_id 0
  29
  30 set testfile "run"
  31 set srcfile ${testfile}.c
  32 set binfile ${objdir}/${subdir}/commands
  33 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-DFAKEARGV}] != "" } {
  34      untested commands.exp
  35      return -1
  36 }
  37
  38 gdb_exit
  39 gdb_start
  40 delete_breakpoints
  41 gdb_reinitialize_dir $srcdir/$subdir
  42 gdb_load ${binfile}
  43
  44 proc gdbvar_simple_if_test {} {
  45     global gdb_prompt
  46
  47     gdb_test "set \$foo = 0" "" "set foo in gdbvar_simple_if_test"
  48     # All this test should do is print 0xdeadbeef once.
  49     gdb_test "if \$foo == 1\np/x 0xfeedface\nelse\np/x 0xdeadbeef\nend" \
  50             "\\\$\[0-9\]* = 0xdeadbeef" "gdbvar_simple_if_test #1"
  51     # All this test should do is print 0xfeedface once.
  52     gdb_test "if \$foo == 0\np/x 0xfeedface\nelse\np/x 0xdeadbeef\nend" \
  53             "\\\$\[0-9\]* = 0xfeedface" "gdbvar_simple_if_test #2"
  54 }
  55
  56 proc gdbvar_simple_while_test {} {
  57     global gdb_prompt
  58
  59     gdb_test "set \$foo = 5" "" "set foo in gdbvar_simple_while_test"
  60     # This test should print 0xfeedface five times.
  61     gdb_test "while \$foo > 0\np/x 0xfeedface\nset \$foo -= 1\nend" \
  62             "\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface" \
  63             "gdbvar_simple_while_test #1"
  64 }
  65
  66 proc gdbvar_complex_if_while_test {} {
  67     global gdb_prompt
  68
  69     gdb_test "set \$foo = 4" "" "set foo in gdbvar complex_if_while_test"
  70     # This test should alternate between 0xdeadbeef and 0xfeedface two times.
  71     gdb_test "while \$foo > 0\nset \$foo -= 1\nif \(\$foo % 2\) == 1\np/x 0xdeadbeef\nelse\np/x 0xfeedface\nend\nend" \
  72             "\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface" \
  73             "gdbvar_complex_if_while_test #1"
  74 }
  75
  76 proc progvar_simple_if_test {} {
  77     global gdb_prompt
  78
  79     if [target_info exists noargs] {
  80         verbose "Skipping progvar_simple_if_test because of noargs."
  81         return
  82     }
  83
  84     if { ![runto factorial] } then { gdb_suppress_tests; }
  85     # Don't depend upon argument passing, since most simulators don't
  86     # currently support it.  Bash value variable to be what we want.
  87     gdb_test "p value=5" "" "set value to 5 in progvar_simple_if_test #1"
  88     # All this test should do is print 0xdeadbeef once.
  89     gdb_test "if value == 1\np/x 0xfeedface\nelse\np/x 0xdeadbeef\nend" \
  90             "\\\$\[0-9\]* = 0xdeadbeef" \
  91             "progvar_simple_if_test #1"
  92     # All this test should do is print 0xfeedface once.
  93     gdb_test "if value == 5\np/x 0xfeedface\nelse\np/x 0xdeadbeef\nend" \
  94             "\\\$\[0-9\]* = 0xfeedface" \
  95             "progvar_simple_if_test #2"
  96     gdb_stop_suppressing_tests;
  97 }
  98
  99 proc progvar_simple_while_test {} {
 100     global gdb_prompt
 101
 102     if [target_info exists noargs] {
 103         verbose "Skipping progvar_simple_while_test because of noargs."
 104         return
 105     }
 106
 107     gdb_test "set args 5" "" "set args in progvar_simple_while_test"
 108     if { ![runto factorial] } then { gdb_suppress_tests }
 109     # Don't depend upon argument passing, since most simulators don't
 110     # currently support it.  Bash value variable to be what we want.
 111     gdb_test "p value=5" "" "set value to 5 in progvar_simple_if_test #2"
 112     # This test should print 0xfeedface five times.
 113     gdb_test "while value > 0\np/x 0xfeedface\nset value -= 1\nend" \
 114             "\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface" \
 115             "progvar_simple_while_test #1"
 116     gdb_stop_suppressing_tests;
 117 }
 118
 119 proc progvar_complex_if_while_test {} {
 120     global gdb_prompt
 121
 122     if [target_info exists noargs] {
 123         verbose "Skipping progvar_simple_if_while_test because of noargs."
 124         return
 125     }
 126
 127     gdb_test "set args 4" "" "set args in progvar_complex_if_while_test"
 128     if { ![runto factorial] } then { gdb_suppress_tests }
 129     # Don't depend upon argument passing, since most simulators don't
 130     # currently support it.  Bash value variable to be what we want.
 131     gdb_test "p value=4" "" "set value to 4 in progvar_simple_if_test"
 132     # This test should alternate between 0xdeadbeef and 0xfeedface two times.
 133     gdb_test "while value > 0\nset value -= 1\nif \(value % 2\) == 1\np/x 0xdeadbeef\nelse\np/x 0xfeedface\nend\nend" \
 134             "\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface" \
 135             "progvar_complex_if_while_test #1"
 136     gdb_stop_suppressing_tests;
 137 }
 138
 139 proc if_while_breakpoint_command_test {} {
 140     if [target_info exists noargs] {
 141         verbose "Skipping if_while_breakpoint_command_test because of noargs."
 142         return
 143     }
 144
 145     gdb_test "set args 5" "" "set args in if_while_breakpoint_command_test"
 146     if { ![runto factorial] } then { gdb_suppress_tests }
 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" "" "set value to 5 in progvar_simple_if_test"
 150     delete_breakpoints
 151     gdb_test "break factorial" "Breakpoint.*at.*" "break factorial #1"
 152
 153     send_gdb "commands\n"
 154     gdb_expect {
 155         -re "End with" {
 156             pass "commands in if_while_breakpoint_command_test"
 157         }
 158         default {
 159             fail "(timeout or eof) commands in if_while_breakpoint_command_test"
 160         }
 161     }
 162     # This test should alternate between 0xdeadbeef and 0xfeedface two times.
 163     gdb_test "while value > 0\nset value -= 1\nif \(value % 2\) == 1\np/x 0xdeadbeef\nelse\np/x 0xfeedface\nend\nend\nend" \
 164             "" \
 165             "commands part 2 in if_while_breakpoint_command_test"
 166     gdb_test "continue" \
 167             "\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface" \
 168             "if_while_breakpoint_command_test #1"
 169    gdb_test "info break" \
 170            "while.*set.*if.*p/x.*else.*p/x.*end.*" \
 171            "info break in if_while_breakpoint_command_test"
 172     gdb_stop_suppressing_tests;
 173 }
 174
 175 # Test that we can run the inferior from breakpoint commands.
 176 #
 177 # The expected behavior is that all commands after the first "step"
 178 # shall be ignored.  See the gdb manual, "Break Commands",
 179 # subsection "Breakpoint command lists".
 180
 181 proc infrun_breakpoint_command_test {} {
 182     if [target_info exists noargs] {
 183         verbose "Skipping infrun_breakpoint_command_test because of noargs."
 184         return
 185     }
 186
 187     gdb_test "set args 6" "" "set args in infrun_breakpoint_command_test"
 188     if { ![runto factorial] } then { gdb_suppress_tests }
 189     # Don't depend upon argument passing, since most simulators don't
 190     # currently support it.  Bash value variable to be what we want.
 191     gdb_test "p value=6" "" "set value to 6 in progvar_simple_if_test #1"
 192     delete_breakpoints
 193     gdb_test "break factorial if value == 5" "Breakpoint.*at.*"
 194
 195 # infrun_breakpoint_command_test - This test was broken into two parts
 196 # to get around a synchronization problem in expect.
 197 # part1: issue the gdb command "commands"
 198 # part2: send the list of commands
 199     send_gdb "commands\n"
 200     gdb_expect {
 201         -re "End with" {
 202             pass "commands in infrun_breakpoint_command_test #1"
 203         }
 204         default {
 205             fail "(timeout or eof) commands in infrun_breakpoint_command_test"
 206         }
 207     }
 208     gdb_test "step\nstep\nstep\nstep\nend" "" \
 209         "commands in infrun_breakpoint_command_test #2"
 210
 211         gdb_test "continue" \
 212                 "Continuing.*.*.*Breakpoint \[0-9\]*, factorial \\(value=5\\).*at.*\[0-9\]*\[      \]*if \\(value > 1\\) \{.*\[0-9\]*\[      \]*value \\*= factorial \\(value - 1\\);.*" \
 213                 "continue in infrun_breakpoint_command_test"
 214
 215     gdb_stop_suppressing_tests;
 216 }
 217
 218 proc breakpoint_command_test {} {
 219     if [target_info exists noargs] {
 220         verbose "Skipping breakpoint_command_test because of noargs."
 221         return
 222     }
 223
 224     gdb_test "set args 6" "" "set args in breakpoint_command_test"
 225     if { ![runto factorial] } then { gdb_suppress_tests; }
 226     # Don't depend upon argument passing, since most simulators don't
 227     # currently support it.  Bash value variable to be what we want.
 228     gdb_test "p value=6" "" "set value to 6 in progvar_simple_if_test #2"
 229     delete_breakpoints
 230     gdb_test "break factorial" "Breakpoint.*at.*" "break factorial #2"
 231     gdb_test "commands\nprintf \"Now the value is %d\\n\", value\nend" \
 232         "End with.*" "commands in breakpoint_command_test"
 233     gdb_test "continue" \
 234             "Breakpoint \[0-9\]*, factorial.*Now the value is 5" \
 235         "continue in breakpoint_command_test"
 236     gdb_test "print value" " = 5" "print value in breakpoint_command_test"
 237     gdb_stop_suppressing_tests;
 238 }
 239
 240 # Test a simple user defined command (with arguments)
 241 proc user_defined_command_test {} {
 242     global gdb_prompt
 243
 244     gdb_test "set \$foo = 4" "" "set foo in user_defined_command_test"
 245
 246     send_gdb "define mycommand\n"
 247     gdb_expect {
 248         -re "End with"  {
 249             pass "define mycommand in user_defined_command_test"
 250         }
 251         default {
 252             fail "(timeout or eof) define mycommand in user_defined_command_test"
 253         }
 254     }
 255     # This test should alternate between 0xdeadbeef and 0xfeedface two times.
 256     gdb_test "while \$arg0 > 0\nset \$arg0 -= 1\nif \(\$arg0 % 2\) == 1\np/x 0xdeadbeef\nelse\np/x 0xfeedface\nend\nend\nend" \
 257             "" \
 258             "enter commands in user_defined_command_test"
 259
 260     gdb_test "mycommand \$foo" \
 261             "\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface\[^\n\]*\n\\\$\[0-9\]* = 0xdeadbeef\[^\n\]*\n\\\$\[0-9\]* = 0xfeedface" \
 262             "execute user defined command in user_defined_command_test"
 263    gdb_test "show user mycommand" \
 264         "  while \\\$arg0.*set.*    if \\\(\\\$arg0.*p/x.*    else\[^\n\].*p/x.*    end\[^\n\].*  end\[^\n\].*" \
 265            "display user command in user_defined_command_test"
 266 }
 267
 268 proc watchpoint_command_test {} {
 269     global noargs
 270     global gdb_prompt
 271
 272     if [target_info exists noargs] {
 273         verbose "Skipping watchpoint_command_test because of noargs."
 274         return
 275     }
 276
 277     gdb_test "set args 6" "" "set args in watchpoint_command_test"
 278     if { ![runto factorial] } then { return }
 279     delete_breakpoints
 280
 281     # Verify that we can create a watchpoint, and give it a commands
 282     # list that continues the inferior.  We set the watchpoint on a
 283     # local variable, too, so that it self-deletes when the watched
 284     # data goes out of scope.
 285     #
 286     # What should happen is: Each time the watchpoint triggers, it
 287     # continues the inferior.  Eventually, the watchpoint will self-
 288     # delete, when the watched variable is out of scope.  But by that
 289     # time, the inferior should have exited.  GDB shouldn't crash or
 290     # anything untoward as a result of this.
 291     #
 292     set wp_id -1
 293
 294     send_gdb "watch local_var\n"
 295     gdb_expect {
 296         -re ".*\[Ww\]atchpoint (\[0-9\]*): local_var.*$gdb_prompt $" {
 297             set wp_id $expect_out(1,string)
 298             pass "watch local_var"
 299         }
 300         -re "$gdb_prompt $"\
 301             {fail "watch local_var"}
 302         timeout {fail "(timeout) watch local_var"}
 303     }
 304
 305     if {$wp_id == -1} {return}
 306
 307     send_gdb "commands $wp_id\n"
 308     gdb_expect {
 309       -re "Type commands for when breakpoint $wp_id is hit, one per line.*>" {
 310           pass "begin commands on watch"
 311       }
 312       -re "$gdb_prompt $" {fail "begin commands on watch"}
 313       timeout             {fail "(timeout) begin commands on watch"}
 314     }
 315     send_gdb "print value\n"
 316     gdb_expect {
 317         -re ">"               {pass "add print command to watch"}
 318         -re "$gdb_prompt $"   {fail "add print command to watch"}
 319         timeout               {fail "(timeout) add print command to watch"}
 320     }
 321     send_gdb "continue\n"
 322     gdb_expect {
 323         -re ">"               {pass "add continue command to watch"}
 324         -re "$gdb_prompt $"   {fail "add continue command to watch"}
 325         timeout               {fail "(timeout) add continue command to watch"}
 326     }
 327     send_gdb "end\n"
 328     gdb_expect {
 329         -re "$gdb_prompt $"   {pass "end commands on watch"}
 330         timeout               {fail "(timeout) end commands on watch"}
 331     }
 332     send_gdb "continue\n"
 333     gdb_expect {
 334         -re "Continuing.*\[Ww\]atchpoint $wp_id deleted because the program has left the block in.*which its expression is valid.*run.c:(57|82).*$gdb_prompt $" {
 335             pass "continue with watch"
 336         }
 337         -re "$gdb_prompt $"   {fail "continue with watch"}
 338         timeout               {fail "(timeout) continue with watch"}
 339     }
 340 }
 341
 342 proc test_command_prompt_position {} {
 343     global gdb_prompt
 344
 345     if [target_info exists noargs] {
 346         verbose "Skipping test_command_prompt_position because of noargs."
 347         return
 348     }
 349
 350     if { ![runto factorial] } then { gdb_suppress_tests; }
 351     # Don't depend upon argument passing, since most simulators don't
 352     # currently support it.  Bash value variable to be what we want.
 353     delete_breakpoints
 354     gdb_test "break factorial" "Breakpoint.*at.*" "break factorial #3"
 355     gdb_test "p value=5" "" "set value to 5 in test_command_prompt_position"
 356     # All this test should do is print 0xdeadbeef once.
 357     gdb_test "if value == 1\np/x 0xfeedface\nelse\np/x 0xdeadbeef\nend" \
 358             "\\\$\[0-9\]* = 0xdeadbeef" \
 359             "if test in test_command_prompt_position"
 360
 361     # Now let's test for the correct position of the '>' in gdb's
 362     # prompt for commands.  It should be at the beginning of the line,
 363     # and not after one space.
 364
 365     send_gdb "commands\n"
 366     gdb_expect {
 367         -re "Type commands.*End with.*\[\r\n\]>$" {
 368             send_gdb "printf \"Now the value is %d\\n\", value\n"
 369             gdb_expect {
 370                 -re "^printf.*value\r\n>$" {
 371                     send_gdb "end\n"
 372                     gdb_expect {
 373                         -re "^end\r\n$gdb_prompt $" {
 374                             pass "> OK in test_command_prompt_position"
 375                         }
 376                         -re ".*$gdb_prompt $" {
 377                             fail "some other message in test_command_prompt_position"
 378                         }
 379                         timeout  {
 380                             fail "(timeout) 1 in test_command_prompt_position"
 381                         }
 382                     }
 383                 }
 384                 -re "^ >$" { fail "> not OK in test_command_prompt_position" }
 385                 -re ".*$gdb_prompt $"   {
 386                     fail "wrong message in test_command_prompt_position"
 387                 }
 388                 timeout    {
 389                     fail "(timeout) 2 in test_command_prompt_position "
 390                 }
 391             }
 392         }
 393         -re "Type commands.*End with.*\[\r\n\] >$" {
 394             fail "prompt not OK in test_command_prompt_position"
 395         }
 396         -re ".*$gdb_prompt $" {
 397             fail "commands in test_command_prompt_position"
 398         }
 399         timeout { fail "(timeout) 3 commands in test_command_prompt_position" }
 400     }
 401
 402     gdb_stop_suppressing_tests;
 403 }
 404
 405
 406
 407 proc deprecated_command_test {} {
 408     gdb_test "maintenance deprecate blah" "Can't find command.*" \
 409           "tried to deprecate non-existing command"
 410
 411     gdb_test "maintenance deprecate p \"new_p\"" "" "maintenance deprecate p \"new_p\" /1/"
 412     gdb_test "p 5" \
 413             "Warning: 'p', an alias for the command 'print' is deprecated.*Use 'new_p'.*" \
 414             "p deprecated warning, with replacement"
 415     gdb_test "p 5" ".\[0-9\]* = 5.*" "Deprecated warning goes away /1/"
 416
 417     gdb_test "maintenance deprecate p \"new_p\"" "" "maintenance deprecate p \"new_p\" /2/"
 418     gdb_test "maintenance deprecate print \"new_print\"" ""
 419     gdb_test "p 5" \
 420             "Warning: command 'print' \\(p\\) is deprecated.*Use 'new_print'.*" \
 421             "both alias and command are deprecated"
 422     gdb_test "p 5" ".\[0-9\]* = 5.*" "Deprecated warning goes away /2/"
 423
 424     gdb_test "maintenance deprecate set remote memory-read-packet-size \"srm\" " \
 425             "" \
 426             "deprecate long command /1/"
 427     gdb_test "set remote memory-read-packet-size" \
 428             "Warning: command 'set remote memory-read-packet-size' is deprecated.*Use 'srm'.*" \
 429             "long command deprecated /1/"
 430
 431     gdb_test "maintenance deprecate set remote memory-read-packet-size" \
 432             "" \
 433             "deprecate long command /2/"
 434     gdb_test "set remote memory-read-packet-size" \
 435             "Warning: command 'set remote memory-read-packet-size' is deprecated.*No alternative known.*" \
 436             "long command deprecated with no alternative /2/"
 437
 438     gdb_test "maintenance deprecate" \
 439             "\"maintenance deprecate\".*" \
 440             "deprecate with no arguments"
 441 }
 442
 443 proc bp_deleted_in_command_test {} {
 444     global gdb_prompt
 445
 446     if [target_info exists noargs] {
 447         verbose "Skipping bp_deleted_in_command_test because of noargs."
 448         return
 449     }
 450
 451     gdb_test "set args 1" "" "set args in bp_deleted_in_command_test"
 452     delete_breakpoints
 453
 454     # Create a breakpoint, and associate a command-list to it, with
 455     # one command that deletes this breakpoint.
 456     gdb_test "break factorial" \
 457              "Breakpoint \[0-9\]+ at .*: file .*/run.c, line \[0-9\]+\." \
 458              "breakpoint in bp_deleted_in_command_test"
 459
 460     send_gdb "commands\n"
 461     gdb_expect {
 462       -re "Type commands for when breakpoint .* is hit, one per line.*>" {
 463           pass "begin commands in bp_deleted_in_command_test"
 464       }
 465       -re "$gdb_prompt $" {fail "begin commands in bp_deleted_in_command_test"}
 466       timeout             {fail "(timeout) begin commands bp_deleted_in_command_test"}
 467     }
 468     send_gdb "silent\n"
 469     gdb_expect {
 470         -re ">"               {pass "add silent command"}
 471         -re "$gdb_prompt $"   {fail "add silent command"}
 472         timeout               {fail "(timeout) add silent command"}
 473     }
 474     send_gdb "clear factorial\n"
 475     gdb_expect {
 476         -re ">"               {pass "add clear command"}
 477         -re "$gdb_prompt $"   {fail "add clear command"}
 478         timeout               {fail "(timeout) add clear command"} }
 479     send_gdb "printf \"factorial command-list executed\\n\"\n"
 480     gdb_expect {
 481         -re ">"               {pass "add printf command"}
 482         -re "$gdb_prompt $"   {fail "add printf command"}
 483         timeout               {fail "(timeout) add printf command"}
 484     }
 485     send_gdb "cont\n"
 486     gdb_expect {
 487         -re ">"               {pass "add cont command"}
 488         -re "$gdb_prompt $"   {fail "add cont command"}
 489         timeout               {fail "(timeout) add cont command"} }
 490     send_gdb "end\n"
 491     gdb_expect {
 492         -re "$gdb_prompt $"   {pass "end commands"}
 493         timeout               {fail "(timeout) end commands"}
 494     }
 495
 496     gdb_run_cmd
 497     gdb_expect {
 498         -re ".*factorial command-list executed.*1.*$gdb_prompt $" {
 499             pass "run factorial until breakpoint"
 500         }
 501         -re ".*$gdb_prompt $" {
 502             fail "run factorial until breakpoint"
 503         }
 504         default { fail "(timeout) run factorial until breakpoint" }
 505         timeout { fail "(timeout) run factorial until breakpoint" }
 506     }
 507 }
 508
 509 proc temporary_breakpoint_commands {} {
 510     global gdb_prompt
 511
 512     if [target_info exists noargs] {
 513         verbose "Skipping temporary_breakpoint_commands because of noargs."
 514         return
 515     }
 516
 517     gdb_test "set args 1" "" "set args in temporary_breakpoint_commands"
 518     delete_breakpoints
 519
 520     # Create a temporary breakpoint, and associate a commands list to it.
 521     # This test will verify that this commands list is executed when the
 522     # breakpoint is hit.
 523     gdb_test "tbreak factorial" \
 524             "Breakpoint \[0-9\]+ at .*: file .*/run.c, line \[0-9\]+\." \
 525             "breakpoint in temporary_breakpoint_commands"
 526
 527     send_gdb "commands\n"
 528     gdb_expect {
 529         -re "Type commands for when breakpoint .* is hit, one per line.*>" {
 530             pass "begin commands in bp_deleted_in_command_test"
 531         }
 532         -re "$gdb_prompt $" {fail "begin commands in bp_deleted_in_command_test"}
 533         timeout             {fail "(timeout) begin commands bp_deleted_in_command_test"}
 534     }
 535     send_gdb "silent\n"
 536     gdb_expect {
 537         -re ">"               {pass "add silent tbreak command"}
 538         -re "$gdb_prompt $"   {fail "add silent tbreak command"}
 539         timeout               {fail "(timeout) add silent tbreak command"}
 540      }
 541     send_gdb "printf \"factorial tbreak commands executed\\n\"\n"
 542     gdb_expect {
 543         -re ">"               {pass "add printf tbreak command"}
 544         -re "$gdb_prompt $"   {fail "add printf tbreak command"}
 545         timeout               {fail "(timeout) add printf tbreak command"}
 546      }
 547     send_gdb "cont\n"
 548     gdb_expect {
 549         -re ">"               {pass "add cont tbreak command"}
 550         -re "$gdb_prompt $"   {fail "add cont tbreak command"}
 551         timeout               {fail "(timeout) add cont tbreak command"} }
 552     send_gdb "end\n"
 553     gdb_expect {
 554         -re "$gdb_prompt $"   {pass "end tbreak commands"}
 555         timeout               {fail "(timeout) end tbreak commands"}
 556      }
 557
 558     gdb_run_cmd
 559     gdb_expect {
 560         -re ".*factorial tbreak commands executed.*1.*$gdb_prompt $" {
 561             pass "run factorial until temporary breakpoint"
 562         }
 563         timeout { fail "(timeout) run factorial until temporary breakpoint" }
 564     }
 565 }
 566
 567 # Test that GDB can handle $arg0 outside of user functions without
 568 # crashing.
 569 proc stray_arg0_test { } {
 570     gdb_test "print \$arg0" \
 571         "\\\$\[0-9\]* = void" \
 572         "stray_arg0_test #1"
 573
 574     gdb_test "if 1 == 1\nprint \$arg0\nend" \
 575         "\\\$\[0-9\]* = void" \
 576         "stray_arg0_test #2"
 577
 578     gdb_test "print \$arg0 = 1" \
 579         "\\\$\[0-9\]* = 1" \
 580         "stray_arg0_test #3"
 581
 582     gdb_test "print \$arg0" \
 583         "\\\$\[0-9\]* = 1" \
 584         "stray_arg0_test #4"
 585 }
 586
 587 # Test that GDB can handle arguments when sourcing files recursively.
 588 # If the arguments are overwritten with ####### then the test has failed.
 589 proc recursive_source_test {} {
 590     set fd [open "file1" w]
 591     puts $fd \
 592 {source file2
 593 abcdef qwerty}
 594     close $fd
 595
 596     set fd [open "file2" w]
 597     puts $fd \
 598 {define abcdef
 599   echo 1: <<<$arg0>>>\n
 600   source file3
 601   echo 2: <<<$arg0>>>\n
 602 end}
 603     close $fd
 604
 605     set fd [open "file3" w]
 606     puts $fd \
 607 "echo in file3\\n
 608 #################################################################"
 609     close $fd
 610
 611     gdb_test "source file1" \
 612         "1: <<<qwerty>>>\[\r\n]+in file3\[\r\n]+2: <<<qwerty>>>" \
 613         "recursive source test"
 614
 615     file delete file1
 616     file delete file2
 617     file delete file3
 618 }
 619
 620 proc gdb_test_no_prompt { command result msg } {
 621     global gdb_prompt
 622
 623     set msg "$command - $msg"
 624     set result "^[string_to_regexp $command]\r\n$result$"
 625     gdb_test_multiple $command $msg {
 626         -re "$result" {
 627             pass $msg
 628             return 1
 629         }
 630         -re "\r\n *>$" {
 631             fail $msg
 632             return 0
 633         }
 634     }
 635     return 0
 636 }
 637
 638 proc if_commands_test {} {
 639     global gdb_prompt
 640
 641     gdb_test "set \$tem = 1" "" "set \$tem in if_commands_test"
 642
 643     set test "if_commands_test 1"
 644     gdb_test_no_prompt "if \$tem == 2" { >} $test
 645     gdb_test_no_prompt "break main" { >} $test
 646     gdb_test_no_prompt "else" { >} $test
 647     gdb_test_no_prompt "break factorial" { >} $test
 648     gdb_test_no_prompt "commands" {  >} $test
 649     gdb_test_no_prompt "silent" {  >} $test
 650     gdb_test_no_prompt "set \$tem = 3" {  >} $test
 651     gdb_test_no_prompt "continue" {  >} $test
 652     gdb_test_multiple "end" "first end - $test" {
 653         -re " >\$" {
 654             pass "first end - $test"
 655         }
 656         -re "\r\n>\$" {
 657             fail "first end - $test"
 658         }
 659     }
 660     gdb_test_multiple "end" "second end - $test" {
 661         -re "Breakpoint \[0-9\]+ at .*: file .*/run.c, line \[0-9\]+\.\r\n$gdb_prompt $" {
 662             pass "second end - $test"
 663         }
 664         -re "Undefined command: \"silent\".*$gdb_prompt $" {
 665             fail "second end - $test"
 666         }
 667     }
 668
 669     set test "if_commands_test 2"
 670     gdb_test_no_prompt "if \$tem == 1" { >} $test
 671     gdb_test_no_prompt "break main" { >} $test
 672     gdb_test_no_prompt "else" { >} $test
 673     gdb_test_no_prompt "break factorial" { >} $test
 674     gdb_test_no_prompt "commands" {  >} $test
 675     gdb_test_no_prompt "silent" {  >} $test
 676     gdb_test_no_prompt "set \$tem = 3" {  >} $test
 677     gdb_test_no_prompt "continue" {  >} $test
 678     gdb_test_multiple "end" "first end - $test" {
 679         -re " >\$" {
 680             pass "first end - $test"
 681         }
 682         -re "\r\n>\$" {
 683             fail "first end - $test"
 684         }
 685     }
 686     gdb_test_multiple "end" "second end - $test" {
 687         -re "Breakpoint \[0-9\]+ at .*: file .*/run.c, line \[0-9\]+\.\r\n$gdb_prompt $" {
 688             pass "second end - $test"
 689         }
 690     }
 691 }
 692
 693 gdbvar_simple_if_test
 694 gdbvar_simple_while_test
 695 gdbvar_complex_if_while_test
 696 progvar_simple_if_test
 697 progvar_simple_while_test
 698 progvar_complex_if_while_test
 699 if_while_breakpoint_command_test
 700 infrun_breakpoint_command_test
 701 breakpoint_command_test
 702 user_defined_command_test
 703 watchpoint_command_test
 704 test_command_prompt_position
 705 deprecated_command_test
 706 bp_deleted_in_command_test
 707 temporary_breakpoint_commands
 708 stray_arg0_test
 709 recursive_source_test
 710 if_commands_test