2010-05-27 Michael Snyder <msnyder@msnyder-server.eng.vmware.com>

	* gdb.base/break.exp: Replace uses of send_gdb / gdb_expect.

1 files changed, 167 insertions, 338 deletions

diff --git a/gdb/testsuite/gdb.base/break.exp b/gdb/testsuite/gdb.base/break.exp
index a4df448a2ac..e76e2443eb0 100644
--- a/gdb/testsuite/gdb.base/break.exp
+++ b/gdb/testsuite/gdb.base/break.exp
@@ -243,36 +243,18 @@ gdb_test "tbreak $srcfile:factorial" "Temporary breakpoint.*at.* file .*$srcfile
 #
 # test break at line number
 #
-send_gdb "tbreak $bp_location1\n"
-gdb_expect {
-    -re "Temporary breakpoint.*at.* file .*$srcfile, line $bp_location1.*$gdb_prompt $" {
-	pass "Temporary breakpoint line number #1"
-    }
-    -re ".*$gdb_prompt $" {
-	fail "Temporary breakpoint line number #1"
-    }
-    timeout {
-	fail "Temporary breakpoint line number #1 (timeout)"
-    }
-}
+gdb_test "tbreak $bp_location1" \
+    "Temporary breakpoint.*at.* file .*$srcfile, line $bp_location1.*" \
+    "Temporary breakpoint line number #1"
 
 gdb_test "tbreak $bp_location6" "Temporary breakpoint.*at.* file .*$srcfile, line $bp_location6.*" "Temporary breakpoint line number #2"
 
 #
 # test break at line number in file
 #
-send_gdb "tbreak $srcfile:$bp_location2\n"
-gdb_expect {
-    -re "Temporary breakpoint.*at.* file .*$srcfile, line $bp_location2.*$gdb_prompt $" {
-	pass "Temporary breakpoint line number in file #1"
-    }
-    -re ".*$gdb_prompt $" {
-	fail "Temporary breakpoint line number in file #1"
-    }
-    timeout {
-	fail "Temporary breakpoint line number in file #1 (timeout)"
-    }
-}
+gdb_test "tbreak $srcfile:$bp_location2" \
+    "Temporary breakpoint.*at.* file .*$srcfile, line $bp_location2.*" \
+    "Temporary breakpoint line number in file #1"
 
 set bp_location11 [gdb_get_line_number "set breakpoint 11 here"]
 gdb_test  "tbreak $srcfile:$bp_location11" "Temporary breakpoint.*at.* file .*$srcfile, line $bp_location11.*" "Temporary breakpoint line number in file #2"
@@ -298,139 +280,97 @@ gdb_test "info break" "Num     Type.*Disp Enb Address.*What.*\[\r\n\]
 #
 if ![runto_main] then { fail "break tests suppressed" }
 
-send_gdb "catch\n"
-gdb_expect {
-  -re "Catch requires an event name.*$gdb_prompt $"\
-          {pass "catch requires an event name"}
-  -re "$gdb_prompt $"\
-          {fail "catch requires an event name"}
-  timeout {fail "(timeout) catch requires an event name"}
-}
+gdb_test "catch" \
+    "Catch requires an event name." \
+    "catch requires an event name"
 
 
 set name "set catch fork, never expected to trigger"
-send_gdb "catch fork\n"
-gdb_expect {
-  -re "Catchpoint \[0-9\]* .fork..*$gdb_prompt $"
-          {pass $name}
-  -re "Catch of fork not yet implemented.*$gdb_prompt $"
-	  {pass $name}
-  -re "$gdb_prompt $"
-          {fail $name}
-  timeout {fail "(timeout) $name"}
+gdb_test_multiple "catch fork" "$name" {
+    -re "Catchpoint \[0-9\]* .fork..*$gdb_prompt $" {
+	pass $name
+    }
+    -re "Catch of fork not yet implemented.*$gdb_prompt $" {
+	pass $name
+    }
 }
 
 
-set name "set catch vfork, never expected to trigger"
-send_gdb "catch vfork\n"
-
 # If we are on HP-UX 10.20, we expect an error message to be
 # printed if we type "catch vfork" at the gdb gdb_prompt.  This is
 # because on HP-UX 10.20, we cannot catch vfork events.
 
+set name "set catch vfork, never expected to trigger"
+
 if [istarget "hppa*-hp-hpux10.20"] then {
-    gdb_expect {
-	-re "Catch of vfork events not supported on HP-UX 10.20..*$gdb_prompt $"
-		{pass $name}
-	-re "$gdb_prompt $"
-		{fail $name}
-	timeout {fail "(timeout) $name"}
-    }
+    gdb_test "catch vfork" \
+	"Catch of vfork events not supported on HP-UX 10.20..*" \
+	"$name"
 } else {
-    gdb_expect {
-	-re "Catchpoint \[0-9\]* .vfork..*$gdb_prompt $"
-		{pass $name}
-	-re "Catch of vfork not yet implemented.*$gdb_prompt $"
-		{pass $name}
-	-re "$gdb_prompt $"
-		{fail $name}
-	timeout {fail "(timeout) $name"}
+    gdb_test_multiple "catch vfork" "$name" {
+	-re "Catchpoint \[0-9\]* .vfork..*$gdb_prompt $" {
+	    pass $name
+	}
+	-re "Catch of vfork not yet implemented.*$gdb_prompt $" {
+	    pass $name
+	}
     }
 }
 
 set name "set catch exec, never expected to trigger"
-send_gdb "catch exec\n"
-gdb_expect {
-  -re "Catchpoint \[0-9\]* .exec..*$gdb_prompt $"
-          {pass $name}
-  -re "Catch of exec not yet implemented.*$gdb_prompt $"
-	  {pass $name}
-  -re "$gdb_prompt $" {fail $name}
-  timeout {fail "(timeout) $name"}
+gdb_test_multiple "catch exec" "$name" {
+    -re "Catchpoint \[0-9\]* .exec..*$gdb_prompt $" {
+	pass $name
+    }
+    -re "Catch of exec not yet implemented.*$gdb_prompt $" {
+	pass $name
+    }
 }
 
 # Verify that GDB responds gracefully when asked to set a breakpoint
 # on a nonexistent source line.
 #
-send_gdb "break 999\n"
-gdb_expect {
-  -re "No line 999 in file .*$gdb_prompt $"\
-          {pass "break on non-existent source line"}
-  -re "$gdb_prompt $"\
-          {fail "break on non-existent source line"}
-  timeout {fail "(timeout) break on non-existent source line"}
-}
+gdb_test "break 999" \
+    "No line 999 in file .*" \
+    "break on non-existent source line"
 
 # Run to the desired default location. If not positioned here, the
 # tests below don't work.
 #
-gdb_test "until $bp_location1" "main .* at .*:$bp_location1.*" "until bp_location1"
-
+gdb_test "until $bp_location1" "main .* at .*:$bp_location1.*" \
+    "until bp_location1"
 
 # Verify that GDB allows one to just say "break", which is treated
 # as the "default" breakpoint.  Note that GDB gets cute when printing
 # the informational message about other breakpoints at the same
 # location.  We'll hit that bird with this stone too.
 #
-send_gdb "break\n"
-gdb_expect {
-  -re "Breakpoint \[0-9\]*.*$gdb_prompt $"\
-          {pass "break on default location, 1st time"}
-  -re "$gdb_prompt $"\
-          {fail "break on default location, 1st time"}
-  timeout {fail "(timeout) break on default location, 1st time"}
-}
+gdb_test "break" "Breakpoint \[0-9\]*.*" \
+    "break on default location, 1st time"
 
-send_gdb "break\n"
-gdb_expect {
-  -re "Note: breakpoint \[0-9\]* also set at .*Breakpoint \[0-9\]*.*$gdb_prompt $"\
-          {pass "break on default location, 2nd time"}
-  -re "$gdb_prompt $"\
-          {fail "break on default location, 2nd time"}
-  timeout {fail "(timeout) break on default location, 2nd time"}
-}
+gdb_test "break" \
+    "Note: breakpoint \[0-9\]* also set at .*Breakpoint \[0-9\]*.*" \
+    "break on default location, 2nd time"
 
-send_gdb "break\n"
-gdb_expect {
-  -re "Note: breakpoints \[0-9\]* and \[0-9\]* also set at .*Breakpoint \[0-9\]*.*$gdb_prompt $"\
-          {pass "break on default location, 3rd time"}
-  -re "$gdb_prompt $"\
-          {fail "break on default location, 3rd time"}
-  timeout {fail "(timeout) break on default location, 3rd time"}
-}
+gdb_test "break" \
+    "Note: breakpoints \[0-9\]* and \[0-9\]* also set at .*Breakpoint \[0-9\]*.*" \
+    "break on default location, 3rd time"
 
-send_gdb "break\n"
-gdb_expect {
-  -re "Note: breakpoints \[0-9\]*, \[0-9\]* and \[0-9\]* also set at .*Breakpoint \[0-9\]*.*$gdb_prompt $"\
-          {pass "break on default location, 4th time"}
-  -re "$gdb_prompt $"\
-          {fail "break on default location, 4th time"}
-  timeout {fail "(timeout) break on default location, 4th time"}
-}
+gdb_test "break" \
+    "Note: breakpoints \[0-9\]*, \[0-9\]* and \[0-9\]* also set at .*Breakpoint \[0-9\]*.*" \
+    "break on default location, 4th time"
 
 # Verify that a "silent" breakpoint can be set, and that GDB is indeed
 # "silent" about its triggering.
 #
 if ![runto_main] then { fail "break tests suppressed" }
 
-send_gdb "break $bp_location1\n"
-gdb_expect {
-  -re "Breakpoint (\[0-9\]*) at .*, line $bp_location1.*$gdb_prompt $"\
-          {pass "set to-be-silent break bp_location1"}
-  -re "$gdb_prompt $"\
-          {fail "set to-be-silent break bp_location1"}
-  timeout {fail "(timeout) set to-be-silent break bp_location1"}
-}
+gdb_test_multiple "break $bp_location1" \
+    "set to-be-silent break bp_location1" {
+	-re "Breakpoint (\[0-9\]*) at .*, line $bp_location1.*$gdb_prompt $" {
+	    pass "set to-be-silent break bp_location1"
+	}
+    }
 
 send_gdb "commands $expect_out(1,string)\n"
 send_gdb "silent\n"
@@ -441,30 +381,15 @@ gdb_expect {
   timeout {fail "(timeout) set silent break bp_location1"}
 }
 
-send_gdb "info break $expect_out(1,string)\n"
-gdb_expect {
-  -re "\[0-9\]*\[ \t\]*breakpoint.*:$bp_location1\r\n\[ \t\]*silent.*$gdb_prompt $"\
-          {pass "info silent break bp_location1"}
-  -re "$gdb_prompt $"\
-          {fail "info silent break bp_location1"}
-  timeout {fail "(timeout) info silent break bp_location1"}
-}
-send_gdb "continue\n"
-gdb_expect {
-  -re "Continuing.\r\n$gdb_prompt $"\
-          {pass "hit silent break bp_location1"}
-  -re "$gdb_prompt $"\
-          {fail "hit silent break bp_location1"}
-  timeout {fail "(timeout) hit silent break bp_location1"}
-}
-send_gdb "bt\n"
-gdb_expect {
-  -re "#0  main .* at .*:$bp_location1.*$gdb_prompt $"\
-          {pass "stopped for silent break bp_location1"}
-  -re "$gdb_prompt $"\
-          {fail "stopped for silent break bp_location1"}
-  timeout {fail "(timeout) stopped for silent break bp_location1"}
-}
+gdb_test "info break $expect_out(1,string)" \
+    "\[0-9\]*\[ \t\]*breakpoint.*:$bp_location1\r\n\[ \t\]*silent.*" \
+    "info silent break bp_location1"
+
+gdb_test "continue" "Continuing." \
+    "hit silent break bp_location1"
+
+gdb_test "bt" "#0  main .* at .*:$bp_location1.*" \
+    "stopped for silent break bp_location1"
 
 # Verify that GDB can at least parse a breakpoint with the
 # "thread" keyword.  (We won't attempt to test here that a
@@ -472,61 +397,31 @@ gdb_expect {
 # The gdb.threads subdirectory contains tests for that.)
 #
 set bp_location12 [gdb_get_line_number "set breakpoint 12 here"]
-send_gdb "break $bp_location12 thread 999\n"
-gdb_expect {
-  -re "Unknown thread 999.*$gdb_prompt $"\
-          {pass "thread-specific breakpoint on non-existent thread disallowed"}
-  -re "$gdb_prompt $"\
-          {fail "thread-specific breakpoint on non-existent thread disallowed"}
-  timeout {fail "(timeout) thread-specific breakpoint on non-existent thread disallowed"}
-}
-send_gdb "break $bp_location12 thread foo\n"
-gdb_expect {
-  -re "Junk after thread keyword..*$gdb_prompt $"\
-          {pass "thread-specific breakpoint on bogus thread ID disallowed"}
-  -re "$gdb_prompt $"\
-          {fail "thread-specific breakpoint on bogus thread ID disallowed"}
-  timeout {fail "(timeout) thread-specific breakpoint on bogus thread ID disallowed"}
-}
+gdb_test "break $bp_location12 thread 999" "Unknown thread 999.*" \
+    "thread-specific breakpoint on non-existent thread disallowed"
+
+gdb_test "break $bp_location12 thread foo" \
+    "Junk after thread keyword.*" \
+    "thread-specific breakpoint on bogus thread ID disallowed"
 
 # Verify that GDB responds gracefully to a breakpoint command with
 # trailing garbage.
 #
-send_gdb "break $bp_location12 foo\n"
-gdb_expect {
-  -re "Junk at end of arguments..*$gdb_prompt $"\
-          {pass "breakpoint with trailing garbage disallowed"}
-  -re "$gdb_prompt $"\
-          {fail "breakpoint with trailing garbage disallowed"}
-  timeout {fail "(timeout) breakpoint with trailing garbage disallowed"}
-}
+gdb_test "break $bp_location12 foo" \
+    "Junk at end of arguments.*" \
+    "breakpoint with trailing garbage disallowed"
 
 # Verify that GDB responds gracefully to a "clear" command that has
 # no matching breakpoint.  (First, get us off the current source line,
 # which we know has a breakpoint.)
 #
-send_gdb "next\n"
-gdb_expect {
-  -re ".*$gdb_prompt $"\
-          {pass "step over breakpoint"}
-  timeout {fail "(timeout) step over breakpoint"}
-}
-send_gdb "clear 81\n"
-gdb_expect {
-  -re "No breakpoint at 81..*$gdb_prompt $"\
-          {pass "clear line has no breakpoint disallowed"}
-  -re "$gdb_prompt $"\
-          {fail "clear line has no breakpoint disallowed"}
-  timeout {fail "(timeout) clear line has no breakpoint disallowed"}
-}
-send_gdb "clear\n"
-gdb_expect {
-  -re "No breakpoint at this line..*$gdb_prompt $"\
-          {pass "clear current line has no breakpoint disallowed"}
-  -re "$gdb_prompt $"\
-          {fail "clear current line has no breakpoint disallowed"}
-  timeout {fail "(timeout) clear current line has no breakpoint disallowed"}
-}
+gdb_test "next" "marker1.*" "step over breakpoint"
+
+gdb_test "clear 81" "No breakpoint at 81.*" \
+    "clear line has no breakpoint disallowed"
+
+gdb_test "clear" "No breakpoint at this line.*" \
+    "clear current line has no breakpoint disallowed"
 
 # Verify that we can set and clear multiple breakpoints.
 #
@@ -539,57 +434,32 @@ gdb_test "clear marker3" {Deleted breakpoints [0-9]+ [0-9]+.*}
 
 # Verify that a breakpoint can be set via a convenience variable.
 #
-send_gdb "set \$foo=$bp_location11\n"
-gdb_expect {
-  -re "$gdb_prompt $"\
-          {pass "set convenience variable \$foo to bp_location11"}
-  timeout {fail "(timeout) set convenience variable \$foo to bp_location11"}
-}
-send_gdb "break \$foo\n"
-gdb_expect {
-  -re "Breakpoint (\[0-9\]*) at .*, line $bp_location11.*$gdb_prompt $"\
-          {pass "set breakpoint via convenience variable"}
-  -re "$gdb_prompt $"\
-          {fail "set breakpoint via convenience variable"}
-  timeout {fail "(timeout) set breakpoint via convenience variable"}
-}
+gdb_test_no_output "set \$foo=$bp_location11" \
+    "set convenience variable \$foo to bp_location11"
+
+gdb_test "break \$foo" \
+    "Breakpoint (\[0-9\]*) at .*, line $bp_location11.*" \
+    "set breakpoint via convenience variable"
 
 # Verify that GDB responds gracefully to an attempt to set a
 # breakpoint via a convenience variable whose type is not integer.
 #
-send_gdb "set \$foo=81.5\n"
-gdb_expect {
-  -re "$gdb_prompt $"\
-          {pass "set convenience variable \$foo to 81.5"}
-  timeout {fail "(timeout) set convenience variable \$foo to 81.5"}
-}
-send_gdb "break \$foo\n"
-gdb_expect {
-  -re "Convenience variables used in line specs must have integer values..*$gdb_prompt $"\
-          {pass "set breakpoint via non-integer convenience variable disallowed"}
-  -re "$gdb_prompt $"\
-          {fail "set breakpoint via non-integer convenience variable disallowed"}
-  timeout {fail "(timeout) set breakpoint via non-integer convenience variable disallowed"}
-}
+gdb_test_no_output "set \$foo=81.5" \
+    "set convenience variable \$foo to 81.5"
+
+gdb_test "break \$foo" \
+    "Convenience variables used in line specs must have integer values.*" \
+    "set breakpoint via non-integer convenience variable disallowed"
 
 # Verify that we can set and trigger a breakpoint in a user-called function.
 #
-send_gdb "break marker2\n"
-gdb_expect {
-    -re "Breakpoint (\[0-9\]*) at .*, line ($bp_location8|$bp_location9).*$gdb_prompt $"\
-          {pass "set breakpoint on to-be-called function"}
-  -re "$gdb_prompt $"\
-          {fail "set breakpoint on to-be-called function"}
-  timeout {fail "(timeout) set breakpoint on to-be-called function"}
-}
-send_gdb "print marker2(99)\n"
-gdb_expect {
-  -re "The program being debugged stopped while in a function called from GDB.\r\nEvaluation of the expression containing the function\r\n.marker2$proto. will be abandoned.\r\nWhen the function is done executing, GDB will silently stop..*$gdb_prompt $"\
-          {pass "hit breakpoint on called function"}
-  -re "$gdb_prompt $"\
-          {fail "hit breakpoint on called function"}
-  timeout {fail "(timeout) hit breakpoint on called function"}
-}
+gdb_test "break marker2" \
+    "Breakpoint (\[0-9\]*) at .*, line ($bp_location8|$bp_location9).*" \
+    "set breakpoint on to-be-called function"
+
+gdb_test "print marker2(99)" \
+    "The program being debugged stopped while in a function called from GDB.\r\nEvaluation of the expression containing the function\r\n.marker2$proto. will be abandoned.\r\nWhen the function is done executing, GDB will silently stop.*" \
+    "hit breakpoint on called function"
 
 # As long as we're stopped (breakpointed) in a called function,
 # verify that we can successfully backtrace & such from here.
@@ -597,32 +467,29 @@ gdb_expect {
 # In this and the following test, the _sr4export check apparently is needed
 # for hppa*-*-hpux.
 #
-send_gdb "bt\n"
-gdb_expect {
-    -re "#0\[ \t\]*($hex in )?marker2.*:($bp_location8|$bp_location9)\r\n#1.*_sr4export.*$gdb_prompt $"\
-            {pass "backtrace while in called function"}
-    -re "#0\[ \t\]*($hex in )?marker2.*:($bp_location8|$bp_location9)\r\n#1.*function called from gdb.*$gdb_prompt $"\
-	    {pass "backtrace while in called function"}
-    -re "$gdb_prompt $"\
-            {fail "backtrace while in called function"}
-    timeout {fail "(timeout) backtrace while in called function"}
+gdb_test_multiple "bt" "backtrace while in called function" {
+    -re "#0\[ \t\]*($hex in )?marker2.*:($bp_location8|$bp_location9)\r\n#1.*_sr4export.*$gdb_prompt $" {
+	pass "backtrace while in called function"
+    }
+    -re "#0\[ \t\]*($hex in )?marker2.*:($bp_location8|$bp_location9)\r\n#1.*function called from gdb.*$gdb_prompt $" {
+	pass "backtrace while in called function"
+    }
 }
 
 # Return from the called function.  For remote targets, it's important to do
 # this before runto_main, which otherwise may silently stop on the dummy
 # breakpoint inserted by GDB at the program's entry point.
 #
-send_gdb "finish\n"
-gdb_expect {
-    -re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.* in _sr4export.*$gdb_prompt $"\
-            {pass "finish from called function"}
-    -re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.*function called from gdb.*$gdb_prompt $"\
-            {pass "finish from called function"}
-    -re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.*Value returned.*$gdb_prompt $"\
-            {pass "finish from called function"}
-    -re "$gdb_prompt $"\
-            {fail "finish from called function"}
-    timeout {fail "(timeout) finish from called function"}
+gdb_test_multiple "finish" "finish from called function" {
+    -re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.* in _sr4export.*$gdb_prompt $" {
+	pass "finish from called function"
+    }
+    -re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.*function called from gdb.*$gdb_prompt $" {
+	pass "finish from called function"
+    }
+    -re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.*Value returned.*$gdb_prompt $" {
+	pass "finish from called function"
+    }
 }
 
 # Verify that GDB responds gracefully to a "finish" command with
@@ -645,79 +512,47 @@ gdb_expect {
 # second condition.
 #
 
-send_gdb "finish\n"
-gdb_expect {
-  -re "\"finish\" not meaningful in the outermost frame.\r\n$gdb_prompt $"\
-          {pass "finish from outermost frame disallowed"}
-  -re "Run till exit from.*\r\n$gdb_prompt $" {
-     pass "finish from outermost frame disallowed"
-  }
-  -re "$gdb_prompt $"\
-          {fail "finish from outermost frame disallowed"}
-  timeout {fail "(timeout) finish from outermost frame disallowed"}
+gdb_test_multiple "finish" "finish from outermost frame disallowed" {
+    -re "\"finish\" not meaningful in the outermost frame.\r\n$gdb_prompt $" {
+	pass "finish from outermost frame disallowed"
+    }
+    -re "Run till exit from.*\r\n$gdb_prompt $" {
+	pass "finish from outermost frame disallowed"
+    }
 }
 
 # Verify that we can explicitly ask GDB to stop on all shared library
 # events, and that it does so.
 #
 if [istarget "hppa*-*-hpux*"] then {
-  if ![runto_main] then { fail "break tests suppressed" }
-
-  send_gdb "set stop-on-solib-events 1\n"
-  gdb_expect {
-    -re "$gdb_prompt $"\
-            {pass "set stop-on-solib-events"}
-    timeout {fail "(timeout) set stop-on-solib-events"}
-  }
-
-  send_gdb "run\n"
-  gdb_expect {
-    -re ".*Start it from the beginning.*y or n. $"\
-            {send_gdb "y\n"
-             gdb_expect {
-               -re ".*Stopped due to shared library event.*$gdb_prompt $"\
-                       {pass "triggered stop-on-solib-events"}
-               -re "$gdb_prompt $"\
-                       {fail "triggered stop-on-solib-events"}
-               timeout {fail "(timeout) triggered stop-on-solib-events"}
-             }
-            }
-    -re "$gdb_prompt $"\
-            {fail "rerun for stop-on-solib-events"}
-    timeout {fail "(timeout) rerun for stop-on-solib-events"}
-  }
-
-  send_gdb "set stop-on-solib-events 0\n"
-  gdb_expect {
-    -re "$gdb_prompt $"\
-            {pass "reset stop-on-solib-events"}
-    timeout {fail "(timeout) reset stop-on-solib-events"}
-  }
+    if ![runto_main] then { fail "break tests suppressed" }
+
+    gdb_test_no_output "set stop-on-solib-events 1" \
+	"set stop-on-solib-events"
+
+    gdb_test "run" \
+	"Stopped due to shared library event.*" \
+	"triggered stop-on-solib-events" \
+	"Start it from the beginning.*y or n. $" \
+	"y" 
+
+    gdb_test_no_output "set stop-on-solib-events 0" \
+	"reset stop-on-solib-events"
 }
 
 # Hardware breakpoints are unsupported on HP-UX.  Verify that GDB
 # gracefully responds to requests to create them.
 #
 if [istarget "hppa*-*-hpux*"] then {
-  if ![runto_main] then { fail "break tests suppressed" }
-
-  send_gdb "hbreak\n"
-  gdb_expect {
-    -re "No hardware breakpoint support in the target.*$gdb_prompt $"\
-            {pass "hw breaks disallowed"}
-    -re "$gdb_prompt $"\
-            {fail "hw breaks disallowed"}
-    timeout {fail "(timeout) hw breaks disallowed"}
-  }
-
-  send_gdb "thbreak\n"
-  gdb_expect {
-    -re "No hardware breakpoint support in the target.*$gdb_prompt $"\
-            {pass "temporary hw breaks disallowed"}
-    -re "$gdb_prompt $"\
-            {fail "temporary hw breaks disallowed"}
-    timeout {fail "(timeout) temporary hw breaks disallowed"}
-  }
+    if ![runto_main] then { fail "break tests suppressed" }
+
+    gdb_test "hbreak" \
+	"No hardware breakpoint support in the target.*" \
+	"hw breaks disallowed"
+
+    gdb_test "thbreak" \
+	"No hardware breakpoint support in the target.*" \
+	"temporary hw breaks disallowed"
 }
 
 #********
@@ -868,32 +703,27 @@ gdb_expect {
 
 set bp_location13 [gdb_get_line_number "set breakpoint 13 here" $srcfile1]
 set bp_location14 [gdb_get_line_number "set breakpoint 14 here" $srcfile1]
-send_gdb "continue\n"
-gdb_expect {
-    -re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile1:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*" {
-	pass "run until breakpoint set at small function, optimized file"
-    }
-    -re "Breakpoint $decimal, $hex in marker4 \\(d=177601976\\) at .*$srcfile1:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*" {
-	pass "run until breakpoint set at small function, optimized file"
-    }
-    -re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile1:$bp_location14\[\r\n\]+$bp_location14\[\t \]+void marker4.*" {
-        # marker4() is defined at line 46 when compiled with -DPROTOTYPES
-	pass "run until breakpoint set at small function, optimized file (line bp_location14)"
-    }
-    -re "Breakpoint $decimal, factorial \\(.*\\) .*\{\r\n$gdb_prompt" {
-	# GCC 4.3 emits bad line number information - see gcc/36748.
-	if { [test_compiler_info "gcc-4-3-*"] } {
-	    setup_xfail *-*-*
+
+gdb_test_multiple "continue" \
+    "run until breakpoint set at small function, optimized file" {
+	-re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile1:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*" {
+	    pass "run until breakpoint set at small function, optimized file"
+	}
+	-re "Breakpoint $decimal, $hex in marker4 \\(d=177601976\\) at .*$srcfile1:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*" {
+	    pass "run until breakpoint set at small function, optimized file"
+	}
+	-re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile1:$bp_location14\[\r\n\]+$bp_location14\[\t \]+void marker4.*" {
+	    # marker4() is defined at line 46 when compiled with -DPROTOTYPES
+	    pass "run until breakpoint set at small function, optimized file (line bp_location14)"
+	}
+	-re "Breakpoint $decimal, factorial \\(.*\\) .*\{\r\n$gdb_prompt" {
+	    # GCC 4.3 emits bad line number information - see gcc/36748.
+	    if { [test_compiler_info "gcc-4-3-*"] } {
+		setup_xfail *-*-*
+	    }
+	    fail "run until breakpoint set at small function, optimized file"
 	}
-	fail "run until breakpoint set at small function, optimized file"
-    }
-    -re ".*$gdb_prompt " {
-	fail "run until breakpoint set at small function, optimized file"
-    }
-    timeout {
-	fail "run until breakpoint set at small function, optimized file (timeout)"
     }
-}
 
 clean_restart breako2
 
@@ -934,6 +764,5 @@ gdb_expect {
 if [istarget "*-*-vxworks*"] {
     set timeout 10
     verbose "Timeout is now $timeout seconds" 2
-    send_gdb "set args main\n"
-    gdb_expect -re ".*$gdb_prompt $" {}
+    gdb_test_no_output "set args main"
 }