From: Pedro Alves <palves@redhat.com>
Date: Tue, 28 Oct 2014 13:42:10 +0000 (+0000)
Subject: gdb.base/sigstep.exp: cleanup and make it easier to extend
X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=1df4399f27f8ee817d8eb4c73bba42bb65844303;p=binutils-gdb.git

gdb.base/sigstep.exp: cleanup and make it easier to extend

Hacking on sigstep.exp, I found it harder to understand and extend
than ideal.

 - GDB is currently not restarted between the different
   tests/combinations in the file, and some parts of the tests' setup
   are done on the top level, and shared between tests.  It's not
   trivial to understand which breakpoints each test procedure expects
   to be set or not set.  And it's not trivial to disable parts of the
   test if you want quickly try out just a subset of the tests
   (running the whole file takes a bit).

 - Because GDB is currently not restarted between tests, if some test
   triggers a ptrace/kernel bug, the following tests may end up with
   cascading fails.  That makes it hard to add a test to cover a
   kernel bug that isn't fixed yet, with a xfail/kfail.  E.g,. note
   how with kernels with bug gdb/8744 (stepi over sigreturn syscall
   exits program) the test program exits, and nothing restarts it
   afterwards...

 - The manual test message prefix management gets a bit in the way.
   Nowadays, we have with_test_prefix which makes it simpler.

 - 'i' is used as parameter name in the various procedures, meaning
   'the command the test', which isn't as obvious as it could.

This commit addresses all that.

gdb/testsuite/
2014-10-28  Pedro Alves  <palves@redhat.com>

	* gdb.base/sigstep.exp: Use build_executable instead of
	prepare_for_testing.
	(top level): Move code that starts GDB, runs to main and creates a
	display to ...
	(restart): ... this new procedure.
	(top level): Move backtrace from signal handler test to ...
	(validate_backtrace): ... this new procedure.
	(advance, advancei): Rename parameter from 'i' to 'cmd'.  Use
	with_test_prefix.  Always restart GDB.
	(skip_to_handler): Rename parameter from 'i' to 'cmd'.  Use
	with_test_prefix.  Always restart GDB.  No need to delete
	breakpoints after the test.
	(test_skip_handler): Remove prefix parameter.
	(skip_over_handler, breakpoint_to_handler)
	(breakpoint_to_handler_entry, breakpoint_over_handler): Rename
	parameter from 'i' to 'cmd'.  Use with_test_prefix.  Always
	restart GDB.  No need to delete breakpoints after the test.
	(top level): Use foreach to call the test procedures with
	different commands.
---

diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 2cf7003545a..a64289ea009 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,25 @@
+2014-10-28  Pedro Alves  <palves@redhat.com>
+
+	* gdb.base/sigstep.exp: Use build_executable instead of
+	prepare_for_testing.
+	(top level): Move code that starts GDB, runs to main and creates a
+	display to ...
+	(restart): ... this new procedure.
+	(top level): Move backtrace from signal handler test to ...
+	(validate_backtrace): ... this new procedure.
+	(advance, advancei): Rename parameter from 'i' to 'cmd'.  Use
+	with_test_prefix.  Always restart GDB.
+	(skip_to_handler): Rename parameter from 'i' to 'cmd'.  Use
+	with_test_prefix.  Always restart GDB.  No need to delete
+	breakpoints after the test.
+	(test_skip_handler): Remove prefix parameter.
+	(skip_over_handler, breakpoint_to_handler)
+	(breakpoint_to_handler_entry, breakpoint_over_handler): Rename
+	parameter from 'i' to 'cmd'.  Use with_test_prefix.  Always
+	restart GDB.  No need to delete breakpoints after the test.
+	(top level): Use foreach to call the test procedures with
+	different commands.
+
 2014-10-28  Pedro Alves  <palves@redhat.com>
 
 	* gdb.base/sigaltstack.exp: Update to use Bugzilla bug numbers
diff --git a/gdb/testsuite/gdb.base/sigstep.exp b/gdb/testsuite/gdb.base/sigstep.exp
index 85d41789a0e..ef98b3d0e11 100644
--- a/gdb/testsuite/gdb.base/sigstep.exp
+++ b/gdb/testsuite/gdb.base/sigstep.exp
@@ -29,16 +29,24 @@ if [target_info exists gdb,nosignals] {
 
 standard_testfile
 
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[build_executable $testfile.exp $testfile $srcfile debug]} {
     untested $testfile.exp
     return -1
 }
 
-gdb_test "display/i \$pc"
+set clear_done [gdb_get_line_number {done = 0}]
+set infinite_loop [gdb_get_line_number {while (!done)}]
+
+# Restart GDB, set a display showing $PC, and run to main.
+
+proc restart {} {
+    global binfile
+
+    clean_restart $binfile
 
-# Advance to main
-if { ![runto_main] } then {
-    gdb_suppress_tests
+    gdb_test "display/i \$pc"
+
+    runto_main
 }
 
 # Pass all the alarms straight through (but verbosely)
@@ -47,127 +55,145 @@ if { ![runto_main] } then {
 # gdb_test "handle SIGPROF print pass nostop"
 
 # Run to the signal handler, validate the backtrace.
-gdb_test "break handler"
-gdb_test "continue" ".* handler .*" "continue to stepi handler"
-gdb_test_sequence "bt" "backtrace for nexti" {
-    "\[\r\n\]+.0 \[^\r\n\]* handler "
-    "\[\r\n\]+.1  .signal handler called."
-    "\[\r\n\]+.2 \[^\r\n\]* main "
+
+proc validate_backtrace {} {
+    with_test_prefix "validate backtrace" {
+	restart
+
+	gdb_test "break handler"
+	gdb_test "continue" ".* handler .*" "continue to stepi handler"
+	gdb_test_sequence "bt" "backtrace for nexti" {
+	    "\[\r\n\]+.0 \[^\r\n\]* handler "
+	    "\[\r\n\]+.1  .signal handler called."
+	    "\[\r\n\]+.2 \[^\r\n\]* main "
+	}
+    }
 }
 
-proc advance { i } {
+validate_backtrace
+
+proc advance { cmd } {
     global gdb_prompt inferior_exited_re
-    set prefix "$i from handler"
 
-    # Get us back into the handler
-    gdb_test "continue" ".* handler .*" "$prefix; continue to handler"
+    with_test_prefix "$cmd from handler" {
+	restart
 
-    set test "$prefix; leave handler"
-    gdb_test_multiple "$i" "${test}" {
-	-re "Could not insert single-step breakpoint.*$gdb_prompt $" {
-	    setup_kfail gdb/8841 "sparc*-*-openbsd*"
-	    fail "$test (could not insert single-step breakpoint)"
-	}
-	-re "done = 1;.*${gdb_prompt} $" {
-	    send_gdb "$i\n"
-	    exp_continue -continue_timer
-	}
-	-re "\} .. handler .*${gdb_prompt} $" {
-	    send_gdb "$i\n"
-	    exp_continue -continue_timer
-	}
-	-re "$inferior_exited_re normally.*${gdb_prompt} $" {
-	    setup_kfail gdb/8744 powerpc-*-*bsd*
-	    fail "$test (program exited)"
-	}
-	-re "(while ..done|done = 0).*${gdb_prompt} $" {
-	    # After stepping out of a function /r signal-handler, GDB will
-	    # advance the inferior until it is at the first instruction of
-	    # a code-line.  While typically things return to the middle of
-	    # the "while..." (and hence GDB advances the inferior to the
-	    # "return..." line) it is also possible for the return to land
-	    # on the first instruction of "while...".  Accept both cases.
-	    pass "$test"
+	gdb_test "break handler"
+
+	# Get us into the handler
+	gdb_test "continue" ".* handler .*" "continue to handler"
+
+	set test "leave handler"
+	gdb_test_multiple "$cmd" "${test}" {
+	    -re "Could not insert single-step breakpoint.*$gdb_prompt $" {
+		setup_kfail gdb/8841 "sparc*-*-openbsd*"
+		fail "$test (could not insert single-step breakpoint)"
+	    }
+	    -re "done = 1;.*${gdb_prompt} $" {
+		send_gdb "$cmd\n"
+		exp_continue -continue_timer
+	    }
+	    -re "\} .. handler .*${gdb_prompt} $" {
+		send_gdb "$cmd\n"
+		exp_continue -continue_timer
+	    }
+	    -re "$inferior_exited_re normally.*${gdb_prompt} $" {
+		setup_kfail gdb/8744 powerpc-*-*bsd*
+		fail "$test (program exited)"
+	    }
+	    -re "(while ..done|done = 0).*${gdb_prompt} $" {
+		# After stepping out of a function /r signal-handler, GDB will
+		# advance the inferior until it is at the first instruction of
+		# a code-line.  While typically things return to the middle of
+		# the "while..." (and hence GDB advances the inferior to the
+		# "return..." line) it is also possible for the return to land
+		# on the first instruction of "while...".  Accept both cases.
+		pass "$test"
+	    }
 	}
     }
 }
 
-proc advancei { i } {
+proc advancei { cmd } {
     global gdb_prompt inferior_exited_re
-    set prefix "$i from handleri"
-    set program_exited 0
-
-    # Get us back into the handler
-    gdb_test "continue" ".* handler .*" "$prefix; continue to handler"
-
-    set test "$prefix; leave handler"
-    gdb_test_multiple "$i" "${test}" {
-        -re "Cannot insert breakpoint 0.*${gdb_prompt} $" {
-            # Some platforms use a special read-only page for signal
-            # trampolines.  We can't set a breakpoint there, and we
-            # don't gracefully fall back to single-stepping.
-	    setup_kfail gdb/8841 "i?86-*-linux*"
-	    setup_kfail gdb/8841 "*-*-openbsd*"
-            fail "$test (could not set breakpoint)"
-	    return
-        }
-	-re "Could not insert single-step breakpoint.*$gdb_prompt $" {
-	    setup_kfail gdb/8841 "sparc*-*-openbsd*"
-	    fail "$test (could not insert single-step breakpoint)"
-	}
-	-re "Breakpoint \[0-9\]*, handler .*${gdb_prompt} $" {
-	    fail "$test (hit breakpoint again)"
-	}
-	-re "done = 1;.*${gdb_prompt} $" {
-	    send_gdb "$i\n"
-	    exp_continue -continue_timer
-	}
-	-re "\} .. handler .*${gdb_prompt} $" {
-	    send_gdb "$i\n"
-	    exp_continue -continue_timer
-	}
-	-re "signal handler called.*${gdb_prompt} $" {
-	    pass "$test"
-	}
-	-re "main .*${gdb_prompt} $" {
-	    fail "$test (in main)"
-	}
-	-re "$inferior_exited_re normally.*${gdb_prompt} $" {
-	    fail "$test (program exited)"
-	    set program_exited 1
-	}
-	-re "Make handler return now.*y or n. $" {
-	    send_gdb "y\n"
-	    exp_continue -continue_timer
-	}
-    }
 
-    set test "$prefix; leave signal trampoline"
-    gdb_test_multiple "$i" "${test}" {
-	-re "while .*${gdb_prompt} $" {
-	    pass "$test (in main)"
-	}
-	-re "signal handler called.*${gdb_prompt} $" {
-	    send_gdb "$i\n"
-	    exp_continue -continue_timer
-	}
-	-re "return .*${gdb_prompt} $" {
-	    fail "$test (stepped)"
-	}
-	-re "Make .*frame return now.*y or n. $" {
-	    send_gdb "y\n"
-	    exp_continue -continue_timer
-	}
-	-re "$inferior_exited_re normally.*${gdb_prompt} $" {
-	    kfail gdb/8744 "$test (program exited)"
-	    set program_exited 1
+    with_test_prefix "$cmd from handleri" {
+	restart
+
+	# Get us into the handler.
+	gdb_test "break handler"
+	gdb_test "continue" ".* handler .*" "continue to handler"
+
+	set program_exited 0
+	set test "leave handler"
+	gdb_test_multiple "$cmd" "${test}" {
+	    -re "Cannot insert breakpoint 0.*${gdb_prompt} $" {
+		# Some platforms use a special read-only page for signal
+		# trampolines.  We can't set a breakpoint there, and we
+		# don't gracefully fall back to single-stepping.
+		setup_kfail gdb/8841 "i?86-*-linux*"
+		setup_kfail gdb/8841 "*-*-openbsd*"
+		fail "$test (could not set breakpoint)"
+		return
+	    }
+	    -re "Could not insert single-step breakpoint.*$gdb_prompt $" {
+		setup_kfail gdb/8841 "sparc*-*-openbsd*"
+		fail "$test (could not insert single-step breakpoint)"
+	    }
+	    -re "Breakpoint \[0-9\]*, handler .*${gdb_prompt} $" {
+		fail "$test (hit breakpoint again)"
+	    }
+	    -re "done = 1;.*${gdb_prompt} $" {
+		send_gdb "$cmd\n"
+		exp_continue -continue_timer
+	    }
+	    -re "\} .. handler .*${gdb_prompt} $" {
+		send_gdb "$cmd\n"
+		exp_continue -continue_timer
+	    }
+	    -re "signal handler called.*${gdb_prompt} $" {
+		pass "$test"
+	    }
+	    -re "main .*${gdb_prompt} $" {
+		fail "$test (in main)"
+	    }
+	    -re "$inferior_exited_re normally.*${gdb_prompt} $" {
+		fail "$test (program exited)"
+		set program_exited 1
+	    }
+	    -re "Make handler return now.*y or n. $" {
+		send_gdb "y\n"
+		exp_continue -continue_timer
+	    }
 	}
-	-re "The program is not being run.*${gdb_prompt} $" {
-	    if { $program_exited } {
-		# Previously kfailed with an exit
-		pass "$test (the program is not being run)"
-	    } else {
-		fail "$test (the program is not being run)"
+
+	set test "leave signal trampoline"
+	gdb_test_multiple "$cmd" "${test}" {
+	    -re "while .*${gdb_prompt} $" {
+		pass "$test (in main)"
+	    }
+	    -re "signal handler called.*${gdb_prompt} $" {
+		send_gdb "$cmd\n"
+		exp_continue -continue_timer
+	    }
+	    -re "return .*${gdb_prompt} $" {
+		fail "$test (stepped)"
+	    }
+	    -re "Make .*frame return now.*y or n. $" {
+		send_gdb "y\n"
+		exp_continue -continue_timer
+	    }
+	    -re "$inferior_exited_re normally.*${gdb_prompt} $" {
+		kfail gdb/8744 "$test (program exited)"
+		set program_exited 1
+	    }
+	    -re "The program is not being run.*${gdb_prompt} $" {
+		if { $program_exited } {
+		    # Previously kfailed with an exit
+		    pass "$test (the program is not being run)"
+		} else {
+		    fail "$test (the program is not being run)"
+		}
 	    }
 	}
     }
@@ -175,62 +201,49 @@ proc advancei { i } {
 
 # Check that we can step/next our way out of a signal handler.
 
-advance step
-advancei stepi
-
-advance next
-advancei nexti
-
-advancei finish
-advancei return
-gdb_test_no_output "set done = 1" "Set done as return will have skipped it"
+foreach cmd {"step" "next"} {
+    advance $cmd
+}
 
+foreach cmd {"stepi" "nexti" "finish" "return"} {
+    advancei $cmd
+}
 
 # Check that we can step/next our way into / over a signal handler.
 
 # There are at least the following cases: breakpoint @pc VS breakpoint
 # in handler VS step / next / continue.
 
-# Use the real-time itimer, as otherwize the process never gets enough
-# time to expire the timer.
-
-delete_breakpoints
-set infinite_loop [gdb_get_line_number {while (!done)}]
-gdb_test_no_output "set itimer = itimer_real"
-gdb_test "break [gdb_get_line_number {done = 0}]"
 
 # Try stepping when there's a signal pending, and a breakpoint at the
 # handler.  Should step into the signal handler.
 
-proc skip_to_handler { i } {
-    global gdb_prompt
+proc skip_to_handler { cmd } {
     global infinite_loop
-    set prefix "$i to handler"
-    
-    # Run around to the done
-    # You can add more patterns to this if you need them.
-    set test "$prefix; resync"
-    gdb_test_multiple "continue" "$test" {
-	-re "done = 0.*$gdb_prompt " {
-	    pass "$test"
-	}
+
+    with_test_prefix "$cmd to handler" {
+	restart
+	# Use the real-time itimer, as otherwize the process never gets
+	# enough time to expire the timer.
+	gdb_test_no_output "set itimer = itimer_real"
+
+	# Advance to the infinite loop.
+	gdb_test "advance $infinite_loop" ".*" "advance to infinite loop"
+
+	# Make the signal pending.
+	sleep 1
+
+	# Insert the handler breakpoint.
+	gdb_test "break handler" ".*" "break handler"
+
+	# Step into the handler.
+	gdb_test "$cmd" " handler .*" "performing $cmd"
     }
-    
-    # Advance to the infinite loop
-    gdb_test "advance $infinite_loop" ".*" "$prefix; advance to infinite loop"
-
-    # Make the signal pending
-    sleep 1
-    
-    # Insert / remove the handler breakpoint.
-    gdb_test "break handler" ".*" "$prefix; break handler"
-    gdb_test "$i" " handler .*" "$prefix; performing $i"
-    gdb_test "clear handler" ".*" "$prefix; clear handler"
 }
 
-skip_to_handler step
-skip_to_handler next
-skip_to_handler continue
+foreach cmd {"step" "next" "continue"} {
+    skip_to_handler $cmd
+}
 
 # Try stepping when there's a signal pending, and a breakpoint at the
 # handler's entry-point.  Should step into the signal handler stopping
@@ -243,30 +256,25 @@ skip_to_handler continue
 # have been called by the trampoline code.  This test checks that it
 # is possible to stop the inferior, even at that first instruction.
 
-proc skip_to_handler_entry { i } {
-    global gdb_prompt
+proc skip_to_handler_entry { cmd } {
     global infinite_loop
-    set prefix "$i to handler entry"
-    
-    # Run around to the done
-    # You can add more patterns to this if you need them.
-    set test "$prefix; resync"
-    gdb_test_multiple "continue" "$test" {
-	-re "done = 0.*$gdb_prompt " {
-	    pass "$test"
-	}
+
+    with_test_prefix "$cmd to handler entry" {
+	restart
+	# Use the real-time itimer, as otherwize the process never gets
+	# enough time to expire the timer.
+	gdb_test_no_output "set itimer = itimer_real"
+
+	# Advance to the infinite loop.
+	gdb_test "advance $infinite_loop" ".*" "advance to infinite loop"
+
+	# Make the signal pending.
+	sleep 1
+
+	# Insert / remove the handler breakpoint.
+	gdb_test "break *handler" ".*" "break handler"
+	gdb_test "$cmd" " handler .*" "performing $cmd"
     }
-    
-    # Advance to the infinite loop
-    gdb_test "advance $infinite_loop" ".*" "$prefix; advance to infinite loop"
-
-    # Make the signal pending
-    sleep 1
-    
-    # Insert / remove the handler breakpoint.
-    gdb_test "break *handler" ".*" "$prefix; break handler"
-    gdb_test "$i" " handler .*" "$prefix; performing $i"
-    gdb_test "clear *handler" ".*" "$prefix; clear handler"
 }
 
 foreach cmd {"stepi" "nexti" "step" "next" "continue"} {
@@ -292,40 +300,39 @@ proc get_next_pc {test} {
 
 # Test that the command skipped over the handler.
 
-proc test_skip_handler {prefix i} {
-    if {$i == "stepi" || $i == "nexti"} {
-	set next_pc [get_next_pc "$prefix; get next PC"]
-	gdb_test "$i" "dummy = 0.*" "$prefix; performing $i"
-	gdb_test "p /x \$pc" " = $next_pc" "$prefix; advanced"
+proc test_skip_handler {cmd} {
+    if {$cmd == "stepi" || $cmd == "nexti"} {
+	set next_pc [get_next_pc "get next PC"]
+	gdb_test "$cmd" "dummy = 0.*" "performing $cmd"
+	gdb_test "p /x \$pc" " = $next_pc" "advanced"
     } else {
-	gdb_test "$i" "done = 0.*" "$prefix; performing $i"
+	gdb_test "$cmd" "done = 0.*" "performing $cmd"
     }
 }
 
 # Try stepping when there's a signal pending but no breakpoints.
 # Should skip the handler advancing to the next line.
 
-proc skip_over_handler { i } {
-    global gdb_prompt
+proc skip_over_handler { cmd } {
     global infinite_loop
-    set prefix "$i over handler"
-    
-    # Run around to the done
-    # You can add more patterns to this if you need them.
-    set test "$prefix; resync"
-    gdb_test_multiple "continue" "$test" {
-	-re "done = 0.*$gdb_prompt " {
-	    pass "$test"
-	}
-    }
-    
-    # Advance to the infinite loop
-    gdb_test "advance $infinite_loop" ".*" "$prefix; advance to infinite loop"
+    global clear_done
+
+    with_test_prefix "$cmd over handler" {
+	restart
+	# Use the real-time itimer, as otherwize the process never gets
+	# enough time to expire the timer.
+	gdb_test_no_output "set itimer = itimer_real"
+
+	gdb_test "break $clear_done" ".*" "break clear done"
+
+	# Advance to the infinite loop.
+	gdb_test "advance $infinite_loop" ".*" "advance to infinite loop"
 
-    # Make the signal pending
-    sleep 1
+	# Make the signal pending.
+	sleep 1
 
-    test_skip_handler $prefix $i
+	test_skip_handler $cmd
+    }
 }
 
 foreach cmd {"stepi" "nexti" "step" "next" "continue"} {
@@ -336,37 +343,31 @@ foreach cmd {"stepi" "nexti" "step" "next" "continue"} {
 # breakpoint at the current instruction, and a breakpoint in the
 # handler.  Should advance to the signal handler.
 
-proc breakpoint_to_handler { i } {
-    global gdb_prompt
+proc breakpoint_to_handler { cmd } {
     global infinite_loop
-    set prefix "$i on breakpoint, to handler"
-    
-    # Run around to the done
-    # You can add more patterns to this if you need them.
-    set test "$prefix; resync"
-    gdb_test_multiple "continue" "$test" {
-	-re "done = 0.*$gdb_prompt " {
-	    pass "$test"
-	}
+
+    with_test_prefix "$cmd on breakpoint, to handler" {
+	restart
+	# Use the real-time itimer, as otherwize the process never gets
+	# enough time to expire the timer.
+	gdb_test_no_output "set itimer = itimer_real"
+
+	gdb_test "break $infinite_loop" ".*" "break infinite loop"
+	gdb_test "break handler" ".*" "break handler"
+
+	# Continue to the infinite loop.
+	gdb_test "continue" "while ..done.*" "continue to infinite loop"
+
+	# Make the signal pending.
+	sleep 1
+
+	gdb_test "$cmd" " handler .*" "performing $cmd"
     }
-    
-    gdb_test "break $infinite_loop" ".*" "$prefix; break infinite loop"
-    gdb_test "break handler" ".*" "$prefix; break handler"
-
-    # Continue to the infinite loop
-    gdb_test "continue" "while ..done.*" "$prefix; continue to infinite loop"
-
-    # Make the signal pending
-    sleep 1
-    
-    gdb_test "$i" " handler .*" "$prefix; performing $i"
-    gdb_test "clear $infinite_loop" ".*" "$prefix; clear infinite loop"
-    gdb_test "clear handler" ".*" "$prefix; clear handler"
 }
 
-breakpoint_to_handler step
-breakpoint_to_handler next
-breakpoint_to_handler continue
+foreach cmd {"step" "next" "continue"} {
+    breakpoint_to_handler $cmd
+}
 
 # Try stepping when there's a signal pending, and a breakpoint at the
 # handler's entry instruction and a breakpoint at the current
@@ -380,66 +381,58 @@ breakpoint_to_handler continue
 # have been called by the trampoline code.  This test checks that it
 # is possible to stop the inferior, even at that first instruction.
 
-proc breakpoint_to_handler_entry { i } {
-    global gdb_prompt
+proc breakpoint_to_handler_entry { cmd } {
     global infinite_loop
-    set prefix "$i on breakpoint, to handler entry"
-    
-    # Run around to the done
-    # You can add more patterns to this if you need them.
-    set test "$prefix; resync"
-    gdb_test_multiple "continue" "$test" {
-	-re "done = 0.*$gdb_prompt " {
-	    pass "$test"
-	}
+
+    with_test_prefix "$cmd on breakpoint, to handler entry" {
+	restart
+	# Use the real-time itimer, as otherwize the process never gets
+	# enough time to expire the timer.
+	gdb_test_no_output "set itimer = itimer_real"
+
+	gdb_test "break $infinite_loop" ".*" "break infinite loop"
+	gdb_test "break *handler" ".*" "break handler"
+
+	# Continue to the infinite loop.
+	gdb_test "continue" "while ..done.*" "continue to infinite loop"
+
+	# Make the signal pending.
+	sleep 1
+
+	gdb_test "$cmd" " handler .*" "performing $cmd"
     }
-    
-    gdb_test "break $infinite_loop" ".*" "$prefix; break infinite loop"
-    gdb_test "break *handler" ".*" "$prefix; break handler"
-
-    # Continue to the infinite loop
-    gdb_test "continue" "while ..done.*" "$prefix; continue to infinite loop"
-
-    # Make the signal pending
-    sleep 1
-    
-    gdb_test "$i" " handler .*" "$prefix; performing $i"
-    gdb_test "clear $infinite_loop" ".*" "$prefix; clear infinite loop"
-    gdb_test "clear *handler" ".*" "$prefix; clear handler"
 }
 
-breakpoint_to_handler_entry step
-breakpoint_to_handler_entry next
-breakpoint_to_handler_entry continue
+foreach cmd {"step" "next" "continue"} {
+    breakpoint_to_handler_entry $cmd
+}
 
 # Try stepping when there's a signal pending, and a pre-existing
 # breakpoint at the current instruction, and no breakpoint in the
 # handler.  Should advance to the next line/instruction.
 
-proc breakpoint_over_handler { i } {
-    global gdb_prompt
+proc breakpoint_over_handler { cmd } {
     global infinite_loop
-    set prefix "$i on breakpoint, skip handler"
-    
-    # Run around to the done
-    # You can add more patterns to this if you need them.
-    set test "$prefix; resync"
-    gdb_test_multiple "continue" "$test" {
-	-re "done = 0.*$gdb_prompt " {
-	    pass "$test"
-	}
-    }
-    
-    gdb_test "break $infinite_loop" ".*" "$prefix; break infinite loop"
+    global clear_done
+
+    with_test_prefix "$cmd on breakpoint, skip handler" {
+	restart
+	# Use the real-time itimer, as otherwize the process never gets
+	# enough time to expire the timer.
+	gdb_test_no_output "set itimer = itimer_real"
+
+	gdb_test "break $infinite_loop" ".*" "break infinite loop"
 
-    # Continue to the infinite loop
-    gdb_test "continue" "while ..done.*" "$prefix; continue to infinite loop"
+	gdb_test "break $clear_done" ".*" "break clear done"
 
-    # Make the signal pending
-    sleep 1
-    
-    test_skip_handler $prefix $i
-    gdb_test "clear $infinite_loop" ".*" "$prefix; clear infinite loop"
+	# Continue to the infinite loop
+	gdb_test "continue" "while ..done.*" "continue to infinite loop"
+
+	# Make the signal pending
+	sleep 1
+
+	test_skip_handler $cmd
+    }
 }
 
 foreach cmd {"stepi" "nexti" "step" "next" "continue"} {