+2016-12-01 Luis Machado <lgustavo@codesourcery.com>
+
+ Fix test names starting with uppercase throughout all the files below.
+
+ * gdb.ada/array_return.exp
+ * gdb.ada/catch_ex.exp
+ * gdb.ada/info_exc.exp
+ * gdb.ada/mi_catch_ex.exp
+ * gdb.ada/mi_dyn_arr.exp
+ * gdb.ada/mi_ex_cond.exp
+ * gdb.ada/mi_exc_info.exp
+ * gdb.ada/mi_interface.exp
+ * gdb.ada/mi_task_arg.exp
+ * gdb.ada/mi_task_info.exp
+ * gdb.ada/mi_var_array.exp
+ * gdb.arch/alpha-step.exp
+ * gdb.arch/amd64-disp-step.exp
+ * gdb.arch/arm-disp-step.exp
+ * gdb.arch/disp-step-insn-reloc.exp
+ * gdb.arch/e500-prologue.exp
+ * gdb.arch/ftrace-insn-reloc.exp
+ * gdb.arch/gdb1558.exp
+ * gdb.arch/i386-bp_permanent.exp
+ * gdb.arch/i386-disp-step.exp
+ * gdb.arch/i386-float.exp
+ * gdb.arch/i386-gnu-cfi.exp
+ * gdb.arch/ia64-breakpoint-shadow.exp
+ * gdb.arch/mips16-thunks.exp
+ * gdb.arch/pa-nullify.exp
+ * gdb.arch/powerpc-aix-prologue.exp
+ * gdb.arch/powerpc-power.exp
+ * gdb.arch/ppc-dfp.exp
+ * gdb.arch/s390-tdbregs.exp
+ * gdb.arch/spu-info.exp
+ * gdb.arch/spu-ls.exp
+ * gdb.arch/thumb-bx-pc.exp
+ * gdb.base/advance.exp
+ * gdb.base/annota-input-while-running.exp
+ * gdb.base/arrayidx.exp
+ * gdb.base/asmlabel.exp
+ * gdb.base/async.exp
+ * gdb.base/attach-wait-input.exp
+ * gdb.base/auto-connect-native-target.exp
+ * gdb.base/batch-preserve-term-settings.exp
+ * gdb.base/bfp-test.exp
+ * gdb.base/bigcore.exp
+ * gdb.base/bp-permanent.exp
+ * gdb.base/break-always.exp
+ * gdb.base/break-fun-addr.exp
+ * gdb.base/break-idempotent.exp
+ * gdb.base/break-main-file-remove-fail.exp
+ * gdb.base/break-probes.exp
+ * gdb.base/break-unload-file.exp
+ * gdb.base/break.exp
+ * gdb.base/call-ar-st.exp
+ * gdb.base/call-rt-st.exp
+ * gdb.base/call-sc.exp
+ * gdb.base/call-signal-resume.exp
+ * gdb.base/call-strs.exp
+ * gdb.base/callexit.exp
+ * gdb.base/callfuncs.exp
+ * gdb.base/catch-gdb-caused-signals.exp
+ * gdb.base/catch-signal-siginfo-cond.exp
+ * gdb.base/catch-syscall.exp
+ * gdb.base/compare-sections.exp
+ * gdb.base/cond-eval-mode.exp
+ * gdb.base/condbreak-call-false.exp
+ * gdb.base/consecutive-step-over.exp
+ * gdb.base/cursal.exp
+ * gdb.base/disabled-location.exp
+ * gdb.base/disasm-end-cu.exp
+ * gdb.base/display.exp
+ * gdb.base/double-prompt-target-event-error.exp
+ * gdb.base/dprintf-bp-same-addr.exp
+ * gdb.base/dprintf-detach.exp
+ * gdb.base/dprintf-next.exp
+ * gdb.base/dprintf-non-stop.exp
+ * gdb.base/dprintf-pending.exp
+ * gdb.base/dso2dso.exp
+ * gdb.base/ending-run.exp
+ * gdb.base/enum_cond.exp
+ * gdb.base/examine-backward.exp
+ * gdb.base/exe-lock.exp
+ * gdb.base/exec-invalid-sysroot.exp
+ * gdb.base/execl-update-breakpoints.exp
+ * gdb.base/execution-termios.exp
+ * gdb.base/fileio.exp
+ * gdb.base/fixsection.exp
+ * gdb.base/foll-exec-mode.exp
+ * gdb.base/foll-exec.exp
+ * gdb.base/fork-running-state.exp
+ * gdb.base/frame-args.exp
+ * gdb.base/fullpath-expand.exp
+ * gdb.base/func-ptr.exp
+ * gdb.base/gcore-relro-pie.exp
+ * gdb.base/gdb1090.exp
+ * gdb.base/gdb1555.exp
+ * gdb.base/global-var-nested-by-dso.exp
+ * gdb.base/gnu-ifunc.exp
+ * gdb.base/hbreak-in-shr-unsupported.exp
+ * gdb.base/hbreak-unmapped.exp
+ * gdb.base/hook-stop.exp
+ * gdb.base/infcall-input.exp
+ * gdb.base/info-fun.exp
+ * gdb.base/info-shared.exp
+ * gdb.base/interrupt-noterm.exp
+ * gdb.base/jit-so.exp
+ * gdb.base/jit.exp
+ * gdb.base/line-symtabs.exp
+ * gdb.base/list.exp
+ * gdb.base/longjmp.exp
+ * gdb.base/macscp.exp
+ * gdb.base/max-value-size.exp
+ * gdb.base/nodebug.exp
+ * gdb.base/nofield.exp
+ * gdb.base/overlays.exp
+ * gdb.base/paginate-after-ctrl-c-running.exp
+ * gdb.base/paginate-bg-execution.exp
+ * gdb.base/paginate-inferior-exit.exp
+ * gdb.base/pending.exp
+ * gdb.base/pr11022.exp
+ * gdb.base/printcmds.exp
+ * gdb.base/ptr-typedef.exp
+ * gdb.base/ptype.exp
+ * gdb.base/randomize.exp
+ * gdb.base/range-stepping.exp
+ * gdb.base/realname-expand.exp
+ * gdb.base/relativedebug.exp
+ * gdb.base/remote.exp
+ * gdb.base/savedregs.exp
+ * gdb.base/sepdebug.exp
+ * gdb.base/set-noassign.exp
+ * gdb.base/shlib-call.exp
+ * gdb.base/shreloc.exp
+ * gdb.base/sigaltstack.exp
+ * gdb.base/sigbpt.exp
+ * gdb.base/siginfo-addr.exp
+ * gdb.base/siginfo-obj.exp
+ * gdb.base/siginfo-thread.exp
+ * gdb.base/signest.exp
+ * gdb.base/signull.exp
+ * gdb.base/sigrepeat.exp
+ * gdb.base/skip.exp
+ * gdb.base/so-impl-ld.exp
+ * gdb.base/solib-corrupted.exp
+ * gdb.base/solib-disc.exp
+ * gdb.base/solib-display.exp
+ * gdb.base/solib-overlap.exp
+ * gdb.base/solib-search.exp
+ * gdb.base/solib-symbol.exp
+ * gdb.base/source-execution.exp
+ * gdb.base/sss-bp-on-user-bp-2.exp
+ * gdb.base/sss-bp-on-user-bp.exp
+ * gdb.base/stack-checking.exp
+ * gdb.base/stale-infcall.exp
+ * gdb.base/step-break.exp
+ * gdb.base/step-line.exp
+ * gdb.base/step-over-exit.exp
+ * gdb.base/step-test.exp
+ * gdb.base/structs.exp
+ * gdb.base/sym-file.exp
+ * gdb.base/symtab-search-order.exp
+ * gdb.base/term.exp
+ * gdb.base/type-opaque.exp
+ * gdb.base/unload.exp
+ * gdb.base/until-nodebug.exp
+ * gdb.base/until.exp
+ * gdb.base/unwindonsignal.exp
+ * gdb.base/watch-cond.exp
+ * gdb.base/watch-non-mem.exp
+ * gdb.base/watch_thread_num.exp
+ * gdb.base/watchpoint-reuse-slot.exp
+ * gdb.base/watchpoint-solib.exp
+ * gdb.base/watchpoint.exp
+ * gdb.btrace/dlopen.exp
+ * gdb.cell/arch.exp
+ * gdb.cell/break.exp
+ * gdb.cell/bt.exp
+ * gdb.cell/core.exp
+ * gdb.cell/data.exp
+ * gdb.cell/dwarfaddr.exp
+ * gdb.cell/ea-cache.exp
+ * gdb.cell/ea-standalone.exp
+ * gdb.cell/ea-test.exp
+ * gdb.cell/f-regs.exp
+ * gdb.cell/fork.exp
+ * gdb.cell/gcore.exp
+ * gdb.cell/mem-access.exp
+ * gdb.cell/ptype.exp
+ * gdb.cell/registers.exp
+ * gdb.cell/sizeof.exp
+ * gdb.cell/solib-symbol.exp
+ * gdb.cell/solib.exp
+ * gdb.compile/compile-tls.exp
+ * gdb.cp/exception.exp
+ * gdb.cp/gdb2495.exp
+ * gdb.cp/local.exp
+ * gdb.cp/mb-inline.exp
+ * gdb.cp/mb-templates.exp
+ * gdb.cp/pr10687.exp
+ * gdb.cp/pr9167.exp
+ * gdb.cp/scope-err.exp
+ * gdb.cp/templates.exp
+ * gdb.cp/virtfunc.exp
+ * gdb.dwarf2/dw2-dir-file-name.exp
+ * gdb.dwarf2/dw2-single-line-discriminators.exp
+ * gdb.fortran/complex.exp
+ * gdb.fortran/library-module.exp
+ * gdb.guile/guile.exp
+ * gdb.guile/scm-cmd.exp
+ * gdb.guile/scm-frame-inline.exp
+ * gdb.guile/scm-objfile.exp
+ * gdb.guile/scm-pretty-print.exp
+ * gdb.guile/scm-symbol.exp
+ * gdb.guile/scm-type.exp
+ * gdb.guile/scm-value.exp
+ * gdb.linespec/keywords.exp
+ * gdb.linespec/ls-errs.exp
+ * gdb.linespec/macro-relative.exp
+ * gdb.linespec/thread.exp
+ * gdb.mi/mi-breakpoint-changed.exp
+ * gdb.mi/mi-dprintf-pending.exp
+ * gdb.mi/mi-fullname-deleted.exp
+ * gdb.mi/mi-logging.exp
+ * gdb.mi/mi-pending.exp
+ * gdb.mi/mi-solib.exp
+ * gdb.mi/new-ui-mi-sync.exp
+ * gdb.mi/user-selected-context-sync.exp
+ * gdb.multi/dummy-frame-restore.exp
+ * gdb.multi/multi-arch-exec.exp
+ * gdb.multi/remove-inferiors.exp
+ * gdb.multi/watchpoint-multi-exit.exp
+ * gdb.opt/solib-intra-step.exp
+ * gdb.perf/backtrace.exp
+ * gdb.perf/single-step.exp
+ * gdb.perf/skip-command.exp
+ * gdb.perf/skip-prologue.exp
+ * gdb.perf/solib.exp
+ * gdb.python/lib-types.exp
+ * gdb.python/py-as-string.exp
+ * gdb.python/py-bad-printers.exp
+ * gdb.python/py-block.exp
+ * gdb.python/py-breakpoint.exp
+ * gdb.python/py-cmd.exp
+ * gdb.python/py-events.exp
+ * gdb.python/py-evthreads.exp
+ * gdb.python/py-finish-breakpoint.exp
+ * gdb.python/py-finish-breakpoint2.exp
+ * gdb.python/py-frame-inline.exp
+ * gdb.python/py-frame.exp
+ * gdb.python/py-inferior.exp
+ * gdb.python/py-infthread.exp
+ * gdb.python/py-mi.exp
+ * gdb.python/py-objfile.exp
+ * gdb.python/py-pp-maint.exp
+ * gdb.python/py-pp-registration.exp
+ * gdb.python/py-prettyprint.exp
+ * gdb.python/py-recurse-unwind.exp
+ * gdb.python/py-shared.exp
+ * gdb.python/py-symbol.exp
+ * gdb.python/py-symtab.exp
+ * gdb.python/py-template.exp
+ * gdb.python/py-type.exp
+ * gdb.python/py-unwind-maint.exp
+ * gdb.python/py-unwind.exp
+ * gdb.python/py-value.exp
+ * gdb.python/python.exp
+ * gdb.reverse/finish-reverse-bkpt.exp
+ * gdb.reverse/insn-reverse.exp
+ * gdb.reverse/next-reverse-bkpt-over-sr.exp
+ * gdb.reverse/solib-precsave.exp
+ * gdb.reverse/solib-reverse.exp
+ * gdb.stabs/gdb11479.exp
+ * gdb.stabs/weird.exp
+ * gdb.threads/fork-child-threads.exp
+ * gdb.threads/fork-plus-threads.exp
+ * gdb.threads/fork-thread-pending.exp
+ * gdb.threads/forking-threads-plus-breakpoint.exp
+ * gdb.threads/hand-call-in-threads.exp
+ * gdb.threads/interrupted-hand-call.exp
+ * gdb.threads/linux-dp.exp
+ * gdb.threads/local-watch-wrong-thread.exp
+ * gdb.threads/next-while-other-thread-longjmps.exp
+ * gdb.threads/non-ldr-exit.exp
+ * gdb.threads/pending-step.exp
+ * gdb.threads/print-threads.exp
+ * gdb.threads/process-dies-while-detaching.exp
+ * gdb.threads/process-dies-while-handling-bp.exp
+ * gdb.threads/pthreads.exp
+ * gdb.threads/queue-signal.exp
+ * gdb.threads/reconnect-signal.exp
+ * gdb.threads/signal-command-handle-nopass.exp
+ * gdb.threads/signal-command-multiple-signals-pending.exp
+ * gdb.threads/signal-delivered-right-thread.exp
+ * gdb.threads/signal-sigtrap.exp
+ * gdb.threads/sigthread.exp
+ * gdb.threads/staticthreads.exp
+ * gdb.threads/stepi-random-signal.exp
+ * gdb.threads/thread-unwindonsignal.exp
+ * gdb.threads/thread_check.exp
+ * gdb.threads/thread_events.exp
+ * gdb.threads/tid-reuse.exp
+ * gdb.threads/tls-nodebug.exp
+ * gdb.threads/tls-shared.exp
+ * gdb.threads/tls-so_extern.exp
+ * gdb.threads/tls.exp
+ * gdb.threads/wp-replication.exp
+ * gdb.trace/actions-changed.exp
+ * gdb.trace/actions.exp
+ * gdb.trace/backtrace.exp
+ * gdb.trace/change-loc.exp
+ * gdb.trace/collection.exp
+ * gdb.trace/deltrace.exp
+ * gdb.trace/disconnected-tracing.exp
+ * gdb.trace/entry-values.exp
+ * gdb.trace/ftrace-lock.exp
+ * gdb.trace/ftrace.exp
+ * gdb.trace/infotrace.exp
+ * gdb.trace/mi-trace-frame-collected.exp
+ * gdb.trace/mi-trace-unavailable.exp
+ * gdb.trace/mi-traceframe-changed.exp
+ * gdb.trace/mi-tracepoint-changed.exp
+ * gdb.trace/mi-tsv-changed.exp
+ * gdb.trace/no-attach-trace.exp
+ * gdb.trace/packetlen.exp
+ * gdb.trace/passc-dyn.exp
+ * gdb.trace/passcount.exp
+ * gdb.trace/pending.exp
+ * gdb.trace/pr16508.exp
+ * gdb.trace/qtro.exp
+ * gdb.trace/range-stepping.exp
+ * gdb.trace/read-memory.exp
+ * gdb.trace/report.exp
+ * gdb.trace/save-trace.exp
+ * gdb.trace/signal.exp
+ * gdb.trace/stap-trace.exp
+ * gdb.trace/status-stop.exp
+ * gdb.trace/strace.exp
+ * gdb.trace/tfile.exp
+ * gdb.trace/tfind.exp
+ * gdb.trace/trace-break.exp
+ * gdb.trace/trace-condition.exp
+ * gdb.trace/trace-enable-disable.exp
+ * gdb.trace/trace-mt.exp
+ * gdb.trace/tracecmd.exp
+ * gdb.trace/tracefile-pseudo-reg.exp
+ * gdb.trace/tspeed.exp
+ * gdb.trace/tstatus.exp
+ * gdb.trace/tsv.exp
+ * gdb.trace/unavailable.exp
+ * gdb.trace/while-dyn.exp
+ * gdb.trace/while-stepping.exp
+ * lib/gdb-guile.exp
+ * lib/gdb.exp
+ * lib/mi-support.exp
+ * lib/pascal.exp
+ * lib/perftest.exp
+ * lib/prelink-support.exp
+ * lib/selftest-support.exp
+
2016-11-30 Simon Marchi <simon.marchi@polymtl.ca>
* Makefile.in: Include disable-implicit-rules.mk.
# Start the inferior
if ![runto_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
####################################
if ![runto_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
# - continue, the program exits.
if ![runto_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
# the program.
if ![runto_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
####################################
if ![mi_run_to_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
# - continue, the program exits.
if ![mi_run_to_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
mi_gdb_load ${binfile}
if ![mi_run_to_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
}
if ![mi_run_to_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
mi_gdb_load ${binfile}
if ![mi_run_to_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
mi_gdb_test "-gdb-set debug-file-directory \"\"" ".*"
if ![mi_runto "task_switch.break_me"] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
####################################
if ![mi_runto "task_switch.break_me"] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
mi_gdb_load ${binfile}
if ![mi_run_to_main] then {
- fail "Cannot run to main, testcase aborted"
+ fail "cannot run to main, testcase aborted"
return 0
}
set binfile ${objdir}/${subdir}/${testfile}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {}] != "" } {
- unsupported "Testcase compile failed."
+ unsupported "testcase compile failed."
return -1
}
# of the previous tests, this makes sure that it doesn't affect
# this series of tests.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_test "show displaced-stepping" ".* displaced stepping .* is on.*"
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_test_no_output "set displaced-stepping off"
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
set n_testcases [get_integer_valueof "n_testcases" 0]
if { ${n_testcases} == 0 } {
- untested "No instruction relocation to test"
+ untested "no instruction relocation to test"
return 1
}
set srcfile ${testfile}.c
set binfile ${objdir}/${subdir}/${testfile}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {}] != "" } {
- unsupported "Testcase compile failed."
+ unsupported "testcase compile failed."
return -1
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main for ftrace tests"
+ fail "can't run to main for ftrace tests"
return 0
}
gdb_reinitialize_dir $srcdir/$subdir
if { [gdb_test "info sharedlibrary" ".*${remote_libipa}.*" "IPA loaded"] != 0 } {
- untested "Could not find IPA lib loaded"
+ untested "could not find IPA lib loaded"
return 1
}
set n_testcases [gdb_readexpr "n_testcases"]
if { ${n_testcases} == 0 } {
- untested "No instruction relocation to test"
+ untested "no instruction relocation to test"
return 1
}
gdb_run_cmd
-set test "Hits breakpoint at main after function called from main"
+set test "hits breakpoint at main after function called from main"
gdb_test_multiple "" $test {
-re "Breakpoint 1.*main .*$gdb_prompt $" {
pass $test
}]
if {$retcode != 0} {
- fail "Disassemble failed, skipping entire test."
+ fail "disassemble failed, skipping entire test."
return -1
}
gdb_test "show displaced-stepping" ".* displaced stepping .* is on.*"
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_test_multiple "info frame" "Existence of the CFI inserted register" {
-re "Stack level 3, frame at (0x\[0-9a-f\]+):.*Saved registers:.* ecx at (0x\[0-9a-f\]+),.*" {
- pass "Existence of the CFI inserted register"
+ pass "existence of the CFI inserted register"
if { [string compare $expect_out(1,string) $expect_out(2,string)] } then {
- fail "Value of the CFI inserted register"
+ fail "value of the CFI inserted register"
} else {
- pass "Value of the CFI inserted register"
+ pass "value of the CFI inserted register"
}
}
}
set srcfile ${testfile}.S
set binfile ${objdir}/${subdir}/${testfile}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested "Couldn't compile test program"
+ untested "couldn't compile test program"
return -1
}
set binfile [standard_output_file ${testname}]
set options [list debug nowarnings]
if { [gdb_compile ${objfiles} ${binfile} executable ${options}] != "" } then {
- unsupported "No MIPS16 support in the toolchain."
+ unsupported "no MIPS16 support in the toolchain."
return
}
clean_restart ${testname}
verbose "MIPS16 support check successful."
}
-re "$gdb_prompt $" {
- unsupported "No MIPS16 support in the processor."
+ unsupported "no MIPS16 support in the processor."
return
}
default {
- unsupported "No MIPS16 support in the processor."
+ unsupported "no MIPS16 support in the processor."
return
}
}
}
-re "$gdb_prompt $" {
- unsupported "No MIPS16 support in the processor."
+ unsupported "no MIPS16 support in the processor."
return
}
default {
- unsupported "No MIPS16 support in the processor."
+ unsupported "no MIPS16 support in the processor."
return
}
}
set gcorefile ${objdir}/${subdir}/${testfile}.gcore
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {}] != "" } {
- unsupported "Testcase compile failed."
+ unsupported "testcase compile failed."
return -1
}
set srcfile ${testfile}.c
set binfile ${objdir}/${subdir}/${testfile}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {}] != "" } {
- unsupported "Testcase compile failed."
+ unsupported "testcase compile failed."
return -1
}
proc func_check {offset instr} {
global func
- set test "Found $offset: $instr"
+ set test "found $offset: $instr"
if [regexp -nocase -line [instr_to_patt $offset $instr] $func] {
pass $test
} else {
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {quiet debug}] != "" } {
- unsupported "This machine doesn't support Decimal Floating Point."
+ unsupported "this machine doesn't support Decimal Floating Point."
return -1
}
# Unless the program bails out after checking AT_HWCAP.
gdb_expect {
-re "$inferior_exited_re with code 01.\[\r\n\]+$gdb_prompt $" {
- unsupported "This machine doesn't support Decimal Floating Point."
+ unsupported "this machine doesn't support Decimal Floating Point."
return -1
}
gdb_test_multiple "next" "check for TE support" {
-re "Program received signal SIGILL,.*\r\n$gdb_prompt $" {
- unsupported "No TE support."
+ unsupported "no TE support."
return
}
-re "\[0-9\]+.*\r\n$gdb_prompt $" {
pass "TE support available"
}
-re "$gdb_prompt $" {
- unsupported "No TE support (unknown error)."
+ unsupported "no TE support (unknown error)."
return
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_load ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
set opts {}
if [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $opts] {
- untested "Failed to compile $srcfile"
+ untested "failed to compile $srcfile"
return -1
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Because runto_main doesn't know how to handle the prompt with annotations,
# run to main before we set the annotation level.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 1
}
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested "Couldn't compile ${srcfile}"
+ untested "couldn't compile ${srcfile}"
return -1
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
fail "$message"
}
-re ".*Asynchronous execution not supported on this target\..*" {
- unsupported "Asynchronous execution not supported: $message"
+ unsupported "asynchronous execution not supported: $message"
}
timeout {
fail "$message (timeout)"
clean_restart $binfile
if ![runto setup_done] then {
- fail "Can't run to setup_done"
+ fail "can't run to setup_done"
return 0
}
}
if { !$have_native } {
- unsupported "No \"target native\" support."
+ unsupported "no \"target native\" support."
return
}
# Testing against the extended-remote board, for example?
if { $topmost != "exec" } {
- unsupported "Already connected to target $topmost."
+ unsupported "already connected to target $topmost."
return
}
# Check which target this board connects to. If testing with a native
# target board, this should cause the native target to auto connect.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Testing against a remote board, for example?
if { ![check_native_target "check whether board tests the native target"] } {
- unsupported "Not testing the native target."
+ unsupported "not testing the native target."
return
}
set res [remote_spawn host "/bin/sh"]
if { $res < 0 || $res == "" } {
- unsupported "Spawning shell failed."
+ unsupported "spawning shell failed."
return 0
}
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested "Couldn't compile ${srcfile}"
+ untested "couldn't compile ${srcfile}"
return -1
}
# mechanism that would let it efficiently access a remote corefile.
if ![isnative] then {
- untested "Remote system"
+ untested "remote system"
return
}
|| [istarget "*-*-solaris*"]
|| [istarget "*-*-darwin*"]
|| [istarget "*-*-cygwin*"] } {
- untested "Kernel lacks sparse corefile support (PR gdb/1551)"
+ untested "kernel lacks sparse corefile support (PR gdb/1551)"
return
}
}
if { $file == "" } {
- untested "Can't generate a core file"
+ untested "can't generate a core file"
return 0
}
# Some targets (QEMU for one) will disallow writes to the
# .text section under certain circumstances. It is no use
# continuing with the test at this point. Just return.
- unsupported "Cannot modify memory"
+ unsupported "cannot modify memory"
return
}
-re " = .*$gdb_prompt $" {
# Some targets do not allow manually writing a breakpoint to a
# certain memory address, like QEMU. In that case, just bail out.
- unsupported "Cannot write to address $bp_address"
+ unsupported "cannot write to address $bp_address"
return -1
}
-re " = .*$gdb_prompt $" {
set binfile1 [standard_output_file ${testfile1}]
if { [gdb_compile "${srcdir}/${subdir}/${srcfile1}" "${binfile1}" executable {debug}] != "" } {
- untested "Couldn't compile ${srcfile1}"
+ untested "couldn't compile ${srcfile1}"
return -1
}
set binfile2 [standard_output_file ${testfile2}]
if { [gdb_compile "${srcdir}/${subdir}/${srcfile2}" "${binfile2}" executable {debug}] != "" } {
- untested "Couldn't compile ${srcfile2}"
+ untested "couldn't compile ${srcfile2}"
return -1
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
delete_breakpoints
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
set GDBFLAGS $saved_gdbflags
if ![runto start] {
- fail "Can't run to start"
+ fail "can't run to start"
return
}
if { [gdb_compile_shlib $srcfile_lib $binfile_lib \
[list additional_flags=-fPIC]] != "" } {
- untested "Could not compile $binfile_lib."
+ untested "could not compile $binfile_lib."
return -1
}
set GDBFLAGS $saved_gdbflags
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
send_gdb "y\n"
gdb_expect {
-re "$gdb_prompt $" {
- fail "Delete all breakpoints when none (unexpected prompt)"
+ fail "delete all breakpoints when none (unexpected prompt)"
}
- timeout { fail "Delete all breakpoints when none (timeout after unexpected prompt)" }
+ timeout { fail "delete all breakpoints when none (timeout after unexpected prompt)" }
}
}
- -re ".*$gdb_prompt $" { pass "Delete all breakpoints when none" }
- timeout { fail "Delete all breakpoints when none (timeout)" }
+ -re ".*$gdb_prompt $" { pass "delete all breakpoints when none" }
+ timeout { fail "delete all breakpoints when none (timeout)" }
}
#
# Some targets can't call functions, so don't even bother with this
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
# Some targets can't do function calls, so don't even bother with this
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
# Some targets can't do function calls, so don't even bother with this
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
clean_restart ${binfile}
if { ![runto_main] } {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Some targets can't call functions, so don't even bother with this
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
# Some targets can't do function calls, so don't even bother with this
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
clean_restart ${binfile}
if { ![runto_main] } {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Some targets can't do function calls, so don't even bother with this
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
}
if ![runto_main] {
- fail "Can't run to main to make the tests"
+ fail "can't run to main to make the tests"
return -1
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Check target supports catch syscall or not.
clean_restart $binfile
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
# Now get past startup code.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
standard_testfile
if {[gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != ""} {
- untested "Couldn't compile $srcfile"
+ untested "couldn't compile $srcfile"
return -1
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
set dummy_3_addr [get_hexadecimal_valueof "&dummy_3" "0"]
if {$main_addr == 0 || $dummy_3_addr == 0 || $dummy_3_addr <= $main_addr} {
- fail "Unable to extract required addresses, or addresses out of order"
+ fail "unable to extract required addresses, or addresses out of order"
return -1
}
gdb_test_multiple "disassemble /m ${main_addr},${dummy_3_addr}" "Disassemble address range with source" {
-re "Dump of assembler code from ${main_addr} to ${dummy_3_addr}:\r\nEnd of assembler dump\." {
- fail "No output from the disassemble command"
+ fail "no output from the disassemble command"
}
-re "Line number 0 out of range;.* has $decimal lines\." {
- fail "The disassemble command failed"
+ fail "the disassemble command failed"
}
-re "Dump of assembler code from ${main_addr} to ${dummy_3_addr}:\r\n.*main.*End of assembler dump\." {
pass "disassemble command returned some output"
}
-re ".*$gdb_prompt $" {
- fail "Unexpected output from disassemble command"
+ fail "unexpected output from disassemble command"
}
}
# Ok, on to real life
#
if ![runto_main] then {
- fail "Could not run to main - other tests will fail."
+ fail "could not run to main - other tests will fail."
continue
}
clean_restart $binfile
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
gdb_test_no_output "set disconnected-dprintf ${disconnected_dprintf}"
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
if [is_remote target] then {
# Testing with remote/non-stop is racy at the moment.
- unsupported "Testing dprintf with remote/non-stop is not supported."
+ unsupported "testing dprintf with remote/non-stop is not supported."
return 0
}
}
if ![runto main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
if { [gdb_compile_shlib $libsrc $lib_sl $lib_opts] != ""
|| [gdb_compile $srcdir/$subdir/$srcfile $binfile executable $exec_opts] != ""} {
- untested "Could not compile either $libsrc or $srcdir/$subdir/$srcfile."
+ untested "could not compile either $libsrc or $srcdir/$subdir/$srcfile."
return -1
}
if { [gdb_compile_shlib $srcfile_libdso2 $binfile_libdso2 \
[list debug additional_flags=-fPIC]] != "" } {
- untested "Could not compile $binfile_libdso2."
+ untested "could not compile $binfile_libdso2."
return -1
}
if { [gdb_compile_shlib $srcfile_libdso1 $binfile_libdso1 \
[list debug additional_flags=-fPIC]] != "" } {
- untested "Could not compile $binfile_libdso1."
+ untested "could not compile $binfile_libdso1."
return -1
}
set exec_output [remote_exec host "ls core"]
if [ regexp "core not found" $exec_output] {
- pass "No core dumped on quit"
+ pass "no core dumped on quit"
} else {
if [ regexp "No such file or directory" $exec_output] {
pass "ls: core (No core dumped on quit)"
set opts [list debug additional_flags=-fshort-enums]
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable $opts] != "" } {
- untested "Could not compile ${srcfile}"
+ untested "could not compile ${srcfile}"
return -1
}
set addr $expect_out(1,string)
}
-re "$gdb_prompt $" {
- unsupported "Current target does not support 'info proc mappings'"
+ unsupported "current target does not support 'info proc mappings'"
}
}
return ${addr}
append binfile $EXEEXT
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested "Couldn't compile ${srcfile}"
+ untested "couldn't compile ${srcfile}"
return -1
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "Couldn't run ${testfile}"
+ fail "couldn't run ${testfile}"
return
}
clean_restart ${exec1}
if ![runto_main] then {
- fail "Couldn't run to main"
+ fail "couldn't run to main"
return -1
}
clean_restart ${exec2}
if ![runto_main] then {
- fail "Couldn't run to main"
+ fail "couldn't run to main"
return -1
}
gdb_test_no_output "set breakpoint always-inserted $always_inserted"
if ![runto_main] then {
- fail "Couldn't run to main"
+ fail "couldn't run to main"
return -1
}
proc test { prefix body } {
with_test_prefix $prefix {
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
uplevel 1 $body
"Continuing\\..*rename 2:.*EISDIR$stop_msg" \
"Renaming a file to existing directory returns EISDIR"
-set test "Renaming a directory to a non-empty directory returns ENOTEMPTY or EEXIST"
+set test "renaming a directory to a non-empty directory returns ENOTEMPTY or EEXIST"
gdb_test_multiple continue "${test}" {
-re "Continuing\\..*rename 3:.*(ENOTEMPTY|EEXIST)$stop_msg$gdb_prompt $" {
pass "${test}"
if { [gdb_compile_shlib $libsrc $lib_sl $lib_opts] != ""
|| [gdb_compile $srcdir/$subdir/$srcfile $binfile \
executable $exec_opts] != ""} {
- untested "Could not compile either $libsrc or $srcfile."
+ untested "could not compile either $libsrc or $srcfile."
return -1
}
gdb_load_shlib ${lib_sl}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 1
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "Couldn't run ${testfile}"
+ fail "couldn't run ${testfile}"
return
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "Couldn't run ${testfile}"
+ fail "couldn't run ${testfile}"
return
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "Couldn't run ${testfile}"
+ fail "couldn't run ${testfile}"
return
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "Couldn't run ${testfile}"
+ fail "couldn't run ${testfile}"
return
}
# Execute the code setting up variable PROG.
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "Couldn't run ${testfile} (2nd try)"
+ fail "couldn't run ${testfile} (2nd try)"
return
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "Couldn't run ${testfile} (3rd try)"
+ fail "couldn't run ${testfile} (3rd try)"
return
}
# Execute the code setting up variable PROG.
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "Couldn't run ${testfile} (4th try)"
+ fail "couldn't run ${testfile} (4th try)"
return
}
# Execute the code setting up variable PROG.
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "Couldn't run ${testfile} (5th try)"
+ fail "couldn't run ${testfile} (5th try)"
return
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested "Couldn't compile ${srcfile}"
+ untested "couldn't compile ${srcfile}"
return -1
}
standard_testfile .c fullpath-expand-func.c
if [is_remote host] {
- unsupported "Compiling on a remote host does not support a filename with directory."
+ unsupported "compiling on a remote host does not support a filename with directory."
return 0
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# The binary is stripped of debug info, but not minsyms.
if ![runto break_here] {
- fail "Can't run to break_here"
+ fail "can't run to break_here"
return -1
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 1
}
gdb_load_shlib $libobj
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
if { [gdb_compile_shlib $srcfile_lib1 $binfile_lib1 \
[list debug additional_flags=-fPIC]] != "" } {
- untested "Could not compile $binfile_lib1."
+ untested "could not compile $binfile_lib1."
return -1
}
if { [gdb_compile_shlib $srcfile_lib2 $binfile_lib2 \
[list debug additional_flags=-fPIC]] != "" } {
- untested "Could not compile $binfile_lib2."
+ untested "could not compile $binfile_lib2."
return -1
}
if { [gdb_compile_shlib ${srcdir}/${subdir}/$libsrc $lib_so $lib_opts] != ""
|| [gdb_compile ${srcdir}/${subdir}/$srcfile $binfile executable $exec_opts] != ""} {
- untested "Could not compile dynamic executable $binfile."
+ untested "could not compile dynamic executable $binfile."
return -1
}
gdb_load_shlib ${lib_so}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 1
}
if { [gdb_compile ${srcdir}/${subdir}/$libsrc $lib_o object {}] != ""
|| [gdb_compile "${srcdir}/${subdir}/$srcfile $lib_o" $staticbinfile executable {debug}] != "" } {
- untested "Could not compile static executable $staticbinfile."
+ untested "could not compile static executable $staticbinfile."
return -1
}
if { [gdb_compile_shlib ${srcdir}/${subdir}/${lib_src} ${lib_so} $lib_opts] != ""
|| [gdb_compile ${srcdir}/${subdir}/${main_src} ${binfile} executable $exec_opts] != ""} {
- untested "Could not compile ${subdir}/$lib_src or ${subdir}/$srcfile."
+ untested "could not compile ${subdir}/$lib_src or ${subdir}/$srcfile."
return -1
}
gdb_load_shlib $lib_so
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# If we can read the memory at address 0, skip the test.
if { [is_address_zero_readable] } {
- untested "Memory at address 0 is readable"
+ untested "memory at address 0 is readable"
return
}
clean_restart $binfile
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return -code return
}
}
if ![runto_main] then {
- fail "Couldn't run to main"
+ fail "couldn't run to main"
return -1
}
if { [gdb_compile_shlib ${srcfile_lib} ${binfile_lib} $sep_lib_flags] != ""
|| [gdb_compile $srcdir/$subdir/${srcfile} ${binfile} \
executable $bin_flags] != "" } {
- untested "Could not compile $binfile_lib or $binfile."
+ untested "could not compile $binfile_lib or $binfile."
return -1
}
if {$libsepdebug == "SEP"} {
if {[gdb_gnu_strip_debug $binfile_lib] != 0} {
- unsupported "Could not split debug of $binfile_lib."
+ unsupported "could not split debug of $binfile_lib."
return
} else {
pass "split solib"
clean_restart $executable
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
if { [gdb_compile_shlib $srcfile_lib1 $binfile_lib1 \
[list additional_flags=-fPIC]] != "" } {
- untested "Could not compile $binfile_lib1."
+ untested "could not compile $binfile_lib1."
return -1
}
if { [gdb_compile_shlib $srcfile_lib2 $binfile_lib2 \
[list additional_flags=-fPIC]] != "" } {
- untested "Could not compile $binfile_lib2."
+ untested "could not compile $binfile_lib2."
return -1
}
gdb_test_no_output "set interactive-mode off"
if ![runto main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
}
if { ![runto_main] } {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
}
if { ![runto_main] } {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart $binfile
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
}
if {$macro_support == 0} {
- unsupported "Skipping test because debug information does not include macro information."
+ unsupported "skipping test because debug information does not include macro information."
return 0
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if { [gdb_compile $srcdir/$subdir/$srcfile $binfile executable $exec_opts] != "" } {
- untested "Couldn't compile $srcfile."
+ untested "couldn't compile $srcfile."
return -1
}
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested "Couldn't compile ${srcfile}"
+ untested "couldn't compile ${srcfile}"
return -1
}
-re ".*ovly2, " { fail ".ovly2 not unmapped by .ovly3" }
-re ".*data00," { fail ".data00 not unmapped by .data01" }
-re ".*data02," { fail ".data02 not unmapped by .data03" }
- -re ".*$gdb_prompt $" { pass "Automatic unmapping" }
+ -re ".*$gdb_prompt $" { pass "automatic unmapping" }
timeout { fail "(timeout) Automatic unmapping" }
}
clean_restart $binfile
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
if { [gdb_compile_shlib $libsrc $lib_sl $lib_opts] != ""
|| [gdb_compile $srcdir/$subdir/$srcfile $binfile executable $exec_opts] != ""} {
- untested "Could not compile either $libsrc or $srcdir/$subdir/$srcfile."
+ untested "could not compile either $libsrc or $srcdir/$subdir/$srcfile."
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_test_no_output "set print elements 50"
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
return
}
proc test_print_array_constants {} {
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
return
}
gdb_load ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested "Couldn't compile test program"
+ untested "couldn't compile test program"
return -1
}
clean_restart ${binfile}
if ![runto marker1] {
- untested "Couldn't run to marker1"
+ untested "couldn't run to marker1"
}
gdb_test "print foo_ptr" "\\\$$decimal = \\\(struct foo \\\*\\\) $hex"
if [runto_main] then {
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
set test "set disable-randomization off"
gdb_test_multiple "${test}" "${test}" {
-re "Disabling randomization .* unsupported .*$gdb_prompt $" {
- untested "Disabling randomization is not supported on this Linux GDB"
+ untested "disabling randomization is not supported on this Linux GDB"
return -1
}
-re "No symbol .* in current context.*$gdb_prompt $" {
- untested "Disabling randomization is not supported on this GDB platform"
+ untested "disabling randomization is not supported on this GDB platform"
return -1
}
-re "$gdb_prompt $" {
set addr2 [address_get "randomized second address"]
set test "randomized addresses should not match"
if [string equal $addr1 $addr2] {
- untested "No randomization detected on this system"
+ untested "no randomization detected on this system"
return -1
} else {
pass $test
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
standard_testfile .c realname-expand-real.c
if [is_remote host] {
- unsupported "Compiling on a remote host does not support a filename with directory."
+ unsupported "compiling on a remote host does not support a filename with directory."
return 0
}
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested "Couldn't compile test program"
+ untested "couldn't compile test program"
return -1
}
# Part THREE: Check the upload behavour
#
if ![runto_main] then {
- fail "Cannot run to main"
+ fail "cannot run to main"
}
# Carefully check memory around each of the most common packet edge
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested "Couldn't compile ${srcfile}"
+ untested "couldn't compile ${srcfile}"
return -1
}
foreach func $inner {
set saved_regs($func) "error"
- set test "Get $func info frame"
+ set test "get $func info frame"
# Both dummy and sigtramp frames have problems.
switch $func {
dummy {
remote_exec build "ln -s ${binfile}${EXEEXT} $new_name"
clean_restart ${testfile}${EXEEXT}
if { $gdb_file_cmd_debug_info != "debug" } then {
- fail "No debug information found."
+ fail "no debug information found."
}
# Restore subdir
clean_restart ${testfile}${EXEEXT}
if { $gdb_file_cmd_debug_info != "debug" } then {
- fail "No debug information found."
+ fail "no debug information found."
}
#
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
if { [gdb_compile_shlib ${lib1src} ${lib1} $lib_opts] != ""
|| [gdb_compile_shlib ${lib2src} ${lib2} $lib_opts] != ""
|| [gdb_compile ${srcfile} ${binfile} executable $exec_opts] != ""} {
- untested "Could not compile $lib1, $lib2, or $srcfile."
+ untested "could not compile $lib1, $lib2, or $srcfile."
return -1
}
}
if { [gdb_compile_shlib $lib1src $lib1_sl $lib_opts] != ""} {
- untested "Could not build $lib1_sl."
+ untested "could not build $lib1_sl."
return -1
} elseif { [gdb_compile_shlib $lib2src $lib2_sl $lib_opts] != ""} {
- untested "Could not build $lib1_s2."
+ untested "could not build $lib1_s2."
return -1
} elseif { [gdb_compile $srcfile $binfile executable $exec_opts] != ""} {
- untested "Could not build $binfile."
+ untested "could not build $binfile."
return -1
}
# Load up the shared objects
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# A better approach would be include absolute symbols via the assembler.
#
if {[check_same "_minor_os_version__" "${msymfile}"]} {
- pass "Absolute symbols not relocated"
+ pass "absolute symbols not relocated"
} else {
- fail "Absolute symbols not relocated"
+ fail "absolute symbols not relocated"
}
}
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested "Couldn't compile ${srcfile}.c"
+ untested "couldn't compile ${srcfile}.c"
return -1
}
# case.
if { [is_address_zero_readable] } {
- untested "Memory at address 0 is possibly executable"
+ untested "memory at address 0 is possibly executable"
return
}
# Check that the address table and SIGSEGV correspond.
-set test "Verify that ${signame} occurs at the last STEPI insn"
+set test "verify that ${signame} occurs at the last STEPI insn"
if {[string compare $segv_addr [at_segv]] == 0} {
pass "$test"
} else {
standard_testfile
if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested "Couldn't compile ${srcfile}.c"
+ untested "couldn't compile ${srcfile}.c"
return -1
}
set gcore_created [gdb_gcore_cmd $gcorefile "save a core file"]
set ssi_addr ""
-set test "Extract si_addr"
+set test "extract si_addr"
gdb_test_multiple "p \$_siginfo" "$test" {
-re "si_addr = ($hex).*$gdb_prompt $" {
set ssi_addr $expect_out(1,string)
}
}
-set test "Extract si_errno"
+set test "extract si_errno"
gdb_test_multiple "p \$_siginfo" "$test" {
-re "si_errno = (\[0-9\]\+).*$gdb_prompt $" {
set ssi_errno $expect_out(1,string)
}
}
-set test "Extract si_code"
+set test "extract si_code"
gdb_test_multiple "p \$_siginfo" "$test" {
-re "si_code = (\[0-9\]\+).*$gdb_prompt $" {
set ssi_code $expect_out(1,string)
}
}
-set test "Extract si_signo"
+set test "extract si_signo"
gdb_test_multiple "p \$_siginfo" "$test" {
-re "si_signo = (\[0-9\]\+).*$gdb_prompt $" {
set ssi_signo $expect_out(1,string)
# Run to the signal.
gdb_test "continue" ".*Program received signal SIGSEGV.*" "continue to signal"
-set test "Set si_addr"
+set test "set si_addr"
gdb_test "p \$_siginfo._sifields._sigfault.si_addr = 0x666" " = \\(void \\*\\) 0x666"
gdb_test "p \$_siginfo.si_errno = 666" " = 666"
gdb_test "p \$_siginfo.si_code = 999" " = 999"
set gcore_created [gdb_gcore_cmd $gcorefile "save a core file"]
set ssi_addr ""
-set test "Extract si_addr"
+set test "extract si_addr"
gdb_test_multiple "p \$_siginfo" "$test" {
-re "si_addr = ($hex).*$gdb_prompt $" {
set ssi_addr $expect_out(1,string)
}
}
-set test "Extract si_errno"
+set test "extract si_errno"
gdb_test_multiple "p \$_siginfo" "$test" {
-re "si_errno = (\[0-9\]\+).*$gdb_prompt $" {
set ssi_errno $expect_out(1,string)
}
}
-set test "Extract si_code"
+set test "extract si_code"
gdb_test_multiple "p \$_siginfo" "$test" {
-re "si_code = (\[0-9\]\+).*$gdb_prompt $" {
set ssi_code $expect_out(1,string)
}
}
-set test "Extract si_signo"
+set test "extract si_signo"
gdb_test_multiple "p \$_siginfo" "$test" {
-re "si_signo = (\[0-9\]\+).*$gdb_prompt $" {
set ssi_signo $expect_out(1,string)
# case.
if { [is_address_zero_readable] } {
- untested "Memory at address 0 is possibly executable"
+ untested "memory at address 0 is possibly executable"
return -1
}
# case.
if { [is_address_zero_readable] } {
- untested "Memory at address 0 is possibly executable"
+ untested "memory at address 0 is possibly executable"
return
}
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested "Couldn't compile ${srcfile}"
+ untested "couldn't compile ${srcfile}"
return -1
}
gdb_test "skip -rfu foo.* xyzzy" "Invalid argument: xyzzy"
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
# right over it and go to the second line of main().
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
"info skip (delete 1)"
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
"info skip shows entry as disabled"
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
"info skip shows entry as enabled"
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
with_test_prefix "step using -fi" {
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
with_test_prefix "step using -gfi" {
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
with_test_prefix "step using -fu for baz" {
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
with_test_prefix "step using -rfu for baz" {
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
gdb_test_no_output "skip delete"
if ![runto test_skip_file_and_function no-message] {
- fail "Can't run to test_skip_file_and_function"
+ fail "can't run to test_skip_file_and_function"
return
}
if { [gdb_compile_shlib $libsrc $lib_sl $lib_opts] != ""
|| [gdb_compile $srcdir/$subdir/$srcfile $binfile \
executable $exec_opts] != ""} {
- untested "Couldn't compile $libsrc or $srcfile."
+ untested "couldn't compile $libsrc or $srcfile."
return -1
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
gdb_load_shlib $libobj
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if { [gdb_compile_shlib ${srcfile_lib} ${binfile_lib} $sep_lib_flags] != ""
|| [gdb_compile ${srcfile} ${binfile} executable $bin_flags] != "" } {
- untested "Could not compile $binfile_lib or $binfile."
+ untested "could not compile $binfile_lib or $binfile."
return -1
}
if {$libsepdebug == "SEP"} {
if {[gdb_gnu_strip_debug $binfile_lib] != 0} {
- unsupported "Could not split debug of $binfile_lib."
+ unsupported "could not split debug of $binfile_lib."
return
} else {
pass "split solib"
clean_restart $executable
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_test "display c_global" "3: c_global = 43"
if { [gdb_start_cmd] < 0 } {
- fail "Can't run to main (2)"
+ fail "can't run to main (2)"
continue
}
# Now rebuild the library without b_global
if { [gdb_compile_shlib ${srcfile_lib} ${binfile_lib} \
"$sep_lib_flags additional_flags=-DNO_B_GLOBAL"] != ""} {
- fail "Can't rebuild $binfile_lib"
+ fail "can't rebuild $binfile_lib"
}
if {$libsepdebug == "SEP"} {
}
if { [gdb_start_cmd] < 0 } {
- fail "Can't run to main (3)"
+ fail "can't run to main (3)"
continue
}
gdb_test "display a_static" "6: a_static = 46"
if { [gdb_start_cmd] < 0 } {
- fail "Can't run to main (4)"
+ fail "can't run to main (4)"
continue
}
if { [gdb_compile_shlib ${srcfile_lib} ${binfile_lib1} $lib_flags] != ""
|| [gdb_compile_shlib ${srcfile_lib} ${binfile_lib2} $lib_flags] != ""
|| [gdb_compile ${srcfile} ${binfile} executable $bin_flags] != "" } {
- untested "Could not compile ${binfile_lib1_test_msg}, ${binfile_lib2_test_msg} or ${binfile_test_msg}."
+ untested "could not compile ${binfile_lib1_test_msg}, ${binfile_lib2_test_msg} or ${binfile_test_msg}."
return -1
}
if {[catch "system \"prelink -N -r ${prelink_lib1} ${binfile_lib1}\""] != 0
|| [catch "system \"prelink -N -r ${prelink_lib2} ${binfile_lib2}\""] != 0} {
# Maybe we don't have prelink.
- untested "Could not prelink ${binfile_lib1_test_msg} or ${binfile_lib2_test_msg}."
+ untested "could not prelink ${binfile_lib1_test_msg} or ${binfile_lib2_test_msg}."
return -1
}
if { [gdb_compile_shlib ${srcfile_lib} ${binfile_lib1} $lib_flags] != ""
|| [gdb_compile_shlib ${srcfile_lib} ${binfile_lib2} $lib_flags] != ""} {
- untested "Could not recompile ${binfile_lib1_test_msg} or ${binfile_lib2_test_msg}."
+ untested "could not recompile ${binfile_lib1_test_msg} or ${binfile_lib2_test_msg}."
kill_wait_spawned_process $test_spawn_id
return -1
}
|| [gdb_compile_shlib ${srcfile2_lib} ${wrong_binfile2_lib} $wrong_lib_flags] != ""
|| [gdb_compile_shlib ${srcfile1_lib} ${right_binfile1_lib} $right_lib_flags] != ""
|| [gdb_compile_shlib ${srcfile2_lib} ${right_binfile2_lib} $right_lib_flags] != "" } {
- untested "Could not compile libs."
+ untested "could not compile libs."
return -1
}
remote_exec build "ln -sf ${right_lib_subdir}/${libname2}.so ${binfile2_lib}"
if { [gdb_compile $srcdir/$subdir/${srcfile} ${binfile} \
executable $bin_flags] != "" } {
- untested "Could not compile $binfile."
+ untested "could not compile $binfile."
return -1
}
clean_restart $testfile
if { ![runto_main] } {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
if { [gdb_compile_shlib ${srcfile_lib} ${binfile_lib} $lib_flags] != ""
|| [gdb_compile ${srcfile} ${binfile} executable $bin_flags] != "" } {
- untested "Could not compile $binfile_lib or $binfile."
+ untested "could not compile $binfile_lib or $binfile."
return -1
}
delete_breakpoints
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
-re "( test-fail .*|\r\nCannot insert breakpoint 0\\.\r\n.*)\r\n$gdb_prompt $" {
xfail $test
- untested "System lacks support for tracking longjmps"
+ untested "system lacks support for tracking longjmps"
return -1
}
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Start with a fresh gdb.
clean_restart ${testfile}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
gdb_load_shlib ${lib_so}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
if { [gdb_compile_shlib $lib1src $lib1 $lib_opts] != ""
|| [gdb_compile [list $srcfile $srcfile2] $binfile executable \
$exec_opts] != ""} {
- untested "Could not compile $lib1, or $srcfile."
+ untested "could not compile $lib1, or $srcfile."
return -1
}
gdb_load_shlib $lib1
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
"test info terminal"
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_load_shlib ${libobj}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
if { [gdb_compile_shlib $libsrc $lib_sl $lib_opts] != ""
|| [gdb_compile_shlib $libsrc2 $lib_sl2 $lib_opts] != ""
|| [gdb_compile $srcfile $binfile executable $exec_opts] != ""} {
- untested "Couldn't compile $libsrc or $libsrc2 or $srcfile."
+ untested "couldn't compile $libsrc or $libsrc2 or $srcfile."
return -1
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
set bp_location21 [gdb_get_line_number "set breakpoint 21 here"]
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Some targets can't do function calls, so don't even bother with this
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
}
if { ![runto_main] } {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
gdb_test_multiple "thread" "Thread command" {
-re ".*Current thread is (\[0-9\]*).*$gdb_prompt $" {
- pass "Thread command"
+ pass "thread command"
}
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
if { [gdb_compile_shlib $libsrc $lib_sl $lib_opts] != ""
|| [gdb_compile $srcfile $binfile executable $exec_opts] != ""} {
- untested "Couldn't compile $libsrc or $srcfile."
+ untested "couldn't compile $libsrc or $srcfile."
return -1
}
# Run until we get to the first marker function.
set x 0
set y 0
- set testname "Watch buffer passed to read syscall"
+ set testname "watch buffer passed to read syscall"
if [runto marker2] then {
gdb_test "watch buf\[0\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[0\\\]"
gdb_test "watch buf\[1\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[1\\\]"
if { [gdb_compile_shlib $srcfile_lib $binfile_lib \
[list additional_flags=-fPIC]] != "" } {
- untested "Could not compile $binfile_lib."
+ untested "could not compile $binfile_lib."
return -1
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
"startup architecture is powerpc:common"
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
send_gdb "thread\n"
gdb_expect 10 {
-re "Current thread is (\[0-9\]*) .*\r\n$gdb_prompt $" {
- pass "Retrieve current thread"
+ pass "retrieve current thread"
set thread_id $expect_out(1,string)
}
-re "$gdb_prompt $" {
- fail "Retrieve current thread"
+ fail "retrieve current thread"
return 0
}
timeout {
- fail "Retrieve current thread (timed out)"
+ fail "retrieve current thread (timed out)"
return 0
}
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
"breakpoint main in ppu"
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
-re ".*$spu_file.c.*Make breakpoint pending.*y or \\\[n\\\]. $" {
gdb_test "y" "Breakpoint.*$spu_file.*pending." "set pending breakpoint"
}
- timeout { fail "Timeout while setting breakpoint in spu binary" }
+ timeout { fail "timeout while setting breakpoint in spu binary" }
}
# Check breakpoints.
# Compile SPU binaries.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
if { [gdb_compile_cell_spu $spu2_src $spu2_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_cell_embedspu $spu2_bin $spu2_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o $spu2_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
gdb_load ${ppu_bin}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
gdb_load ${ppu_bin}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $srcfile $binary executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
gdb_load ${binary}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
gdb_load ${ppu_bin}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $srcfile $binary executable {debug}] != "" } {
- unsupported "Compile spu binary failed, so all tests in this file will automatically fail."
+ unsupported "compile spu binary failed, so all tests in this file will automatically fail."
return -1
}
gdb_load ${binary}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $source $binary executable {debug}] != "" } {
- unsupported "Compile spu binary failed, so all tests in this file will automatically fail."
+ unsupported "compile spu binary failed, so all tests in this file will automatically fail."
return -1
}
gdb_load ${binary}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
"info all-registers"
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
gdb_load ${ppu_bin}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
gdb_load ${ppu_bin}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
gdb_load ${ppu_bin}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
gdb_load ${ppu_bin}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
"info all-registers"
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
gdb_load ${ppu_bin}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
gdb_load ${ppu_bin}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile SPU binary.
if { [gdb_compile_cell_spu $spu_src $spu_bin executable {debug}] != "" } {
- unsupported "Compiling spu binary failed."
+ unsupported "compiling spu binary failed."
return -1
}
# Compile PPU binary.
if { [gdb_cell_embedspu $spu_bin $spu_bin-embed.o {debug}] != "" } {
- unsupported "Embedding spu binary failed."
+ unsupported "embedding spu binary failed."
return -1
}
if { [gdb_compile_cell_ppu [list $ppu_src $spu_bin-embed.o] $ppu_bin executable {debug}] != "" } {
- unsupported "Compiling ppu binary failed."
+ unsupported "compiling ppu binary failed."
return -1
}
"no shared library is loaded"
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_run_cmd
gdb_test_multiple "" "Run to main" {
-re "Temporary breakpoint 4,.*$gdb_prompt $" {
- pass "Run to main"
+ pass "run to main"
set ok 1
}
}
# Some targets can't do function calls, so don't even bother with this
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
set eol "\[\t \]*\[\r\n\]+\[\t \]*"
gdb_test_multiple "ptype Local" "Local out of scope" {
-re "No symbol \"Local\" in current context.*${gdb_prompt} $" {
- pass "Local out of scope"
+ pass "local out of scope"
}
-re "ptype Local${eol}type = class Local {${eol} public:${eol} int loc1;${eol}.*${eol} char loc_foo\\(char\\);${eol}}${eol}${gdb_prompt} " {
# GCC emits STABS debugging information in a way that doesn't
set bp_location [gdb_get_line_number "set multi-line breakpoint here" $hdrfile]
if { ![runto_main] } {
- fail "Can't run to main for multi_line_foo tests."
+ fail "can't run to main for multi_line_foo tests."
return 0
}
set bp_location [gdb_get_line_number "set multi-line breakpoint here"]
if { ![runto_main] } {
- fail "Can't run to main for multi_line_foo tests."
+ fail "can't run to main for multi_line_foo tests."
return 0
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
}
if {![runto_main]} {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
global gdb_prompt
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
return
}
global nl
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
return 0
}
lappend opts "additional_flags=-DFILE=\"${srctmpfile}\""
if { [gdb_compile "${asmsrcfile} ${srcdir}/${subdir}/$srcfile" "${binfile}" executable $opts] != "" } {
- untested "Cannot compile ${asmsrcfile} or $srcfile"
+ untested "cannot compile ${asmsrcfile} or $srcfile"
return -1
}
}
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
continue
}
standard_testfile .f
if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug f90 quiet}]} {
- untested "Couldn't compile ${srcfile}"
+ untested "couldn't compile ${srcfile}"
return -1
}
}
if { [gdb_compile_shlib "${srcdir}/${subdir}/${srclibfile}" $libfile {debug f90}] != "" } {
- untested "Couldn't compile ${srclibfile}"
+ untested "couldn't compile ${srclibfile}"
return -1
}
# warnings on ignored $libfile abort the process.
if { [gdb_compile $srcdir/$subdir/$srcfile $binfile executable [list debug f90 shlib=$libfile]] != "" } {
- untested "Couldn't compile ${srcfile}"
+ untested "couldn't compile ${srcfile}"
return -1
}
# We want to do some tests when Guile is not present.
gdb_test_multiple "guile (display 23) (newline)" "verify guile support" {
-re "Undefined command.*$gdb_prompt $" {
- unsupported "Guile not supported."
+ unsupported "guile not supported."
return
}
-re "not supported.*$gdb_prompt $" {
if { [skip_guile_tests] } { continue }
if ![gdb_guile_runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
if { [skip_guile_tests] } { continue }
if ![runto main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
if { [skip_guile_tests] } { continue }
if ![gdb_guile_runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
proc run_lang_tests {exefile lang} {
global srcdir subdir srcfile testfile hex
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${exefile}" executable "debug $lang"] != "" } {
- untested "Couldn't compile ${srcfile} in $lang mode"
+ untested "couldn't compile ${srcfile} in $lang mode"
return
}
# C++ tests
# Recompile binary.
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}-cxx" executable "debug c++"] != "" } {
- untested "Couldn't compile ${srcfile} in c++ mode"
+ untested "couldn't compile ${srcfile} in c++ mode"
return -1
}
global srcdir subdir srcfile
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${exefile}" executable "debug $lang"] != "" } {
- untested "Couldn't compile ${srcfile} in $lang mode"
+ untested "couldn't compile ${srcfile} in $lang mode"
return -1
}
return 0
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${objfile}" object "debug $lang"] != ""
|| [gdb_compile "${objfile}" "${exefile}" executable "debug $lang"] != "" } {
- untested "Couldn't compile ${srcfile} in $lang mode"
+ untested "couldn't compile ${srcfile} in $lang mode"
return -1
}
return 0
clean_restart ${exefile}
if ![gdb_guile_runto_main ] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
# The following tests require execution.
if ![gdb_guile_runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_test_no_output "set max-completions unlimited"
if {![runto_main]} {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if [is_remote host] {
- unsupported "Compiling on a remote host does not support a filename with directory."
+ unsupported "compiling on a remote host does not support a filename with directory."
return 0
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
if { [gdb_compile_shlib $libsrc1 $lib_sl1 $lib_opts] != ""
|| [gdb_compile_shlib $libsrc2 $lib_sl2 $lib_opts] != ""} {
- untested "Could not compile either $libsrc1 or $libsrc2"
+ untested "could not compile either $libsrc1 or $libsrc2"
return -1
}
set exec_opts [list debug shlib=$lib_sl1 shlib_load]
if { [gdb_compile $srcdir/$subdir/$srcfile $binfile executable $exec_opts] != "" } {
- untested "Failed to compile $srcfile"
+ untested "failed to compile $srcfile"
return -1
}
}
if {[gdb_compile_shlib $libsrc1 $lib_sl1 $lib_opts] != ""} {
- untested "Could not compile $libsrc1"
+ untested "could not compile $libsrc1"
return -1
}
if {[gdb_compile $srcdir/$subdir/$srcfile $binfile executable $exec_opts] != ""} {
- untested "Could not compile $srcdir/$subdir/$srcfile"
+ untested "could not compile $srcdir/$subdir/$srcfile"
return -1
}
# "//$srcfile" It is used for the test of compare_filenames_for_search.
if { [regsub {/[^/]+$} $srcfileabs {/\0} srcfileabs] != 1 } {
- xfail "Cannot double the last slash separator"
+ xfail "cannot double the last slash separator"
return -1
}
if { [regsub {^(/[^/]+)/} $srcfileabs {\1subst/} srcfileabssubst] != 1
|| [regsub {^(/[^/]+)/.*$} $srcfileabs {\1} initdir] != 1 } {
- xfail "Missing root subdirectory"
+ xfail "missing root subdirectory"
return -1
}
set mi_log_prompt "\[(\]gdb\[)\] \[\r\n\]+"
if [regexp "\\^done\[\r\n\]+$mi_log_prompt\\^running\[\r\n\]+\\*running,thread-id=\"all\"\[\r\n\]+$mi_log_prompt\\*stopped,reason=\"end-stepping-range\",.*\[\r\n\]+$mi_log_prompt\\^running\[\r\n\]+\\*running,thread-id=\"all\"\[\r\n\]+$mi_log_prompt\\*stopped,reason=\"end-stepping-range\",.*\[\r\n\]+$mi_log_prompt" $logcontent] {
- pass "Log file contents"
+ pass "log file contents"
} else {
- fail "Log file contents"
+ fail "log file contents"
}
# Now try the redirect, which writes into the file only.
close $chan
if [regexp "1001\\^done\[\r\n\]+$mi_log_prompt.*1002\\^running\[\r\n\]+\\*running,thread-id=\"all\"\[\r\n\]+$mi_log_prompt\\*stopped,reason=\"end-stepping-range\",.*\[\r\n\]+$mi_log_prompt.*1003\\^running\[\r\n\]+\\*running,thread-id=\"all\"\[\r\n\]+$mi_log_prompt\\*stopped,reason=\"end-stepping-range\",.*\[\r\n\]+$mi_log_prompt" $logcontent] {
- pass "Redirect log file contents"
+ pass "redirect log file contents"
} else {
- fail "Redirect log file contents"
+ fail "redirect log file contents"
}
mi_gdb_exit
if { [gdb_compile_shlib $libsrc1 $lib_sl1 $lib_opts] != ""
|| [gdb_compile_shlib $libsrc2 $lib_sl2 $lib_opts] != ""} {
- untested "Could not compile either $libsrc1 or $libsrc2"
+ untested "could not compile either $libsrc1 or $libsrc2"
return -1
}
if { [gdb_compile_pthreads $srcdir/$subdir/$srcfile $binfile executable $exec_opts] != ""} {
- untested "Could not compile $srcdir/$subdir/$srcfile."
+ untested "could not compile $srcdir/$subdir/$srcfile."
return -1
}
mi_send_resuming_command "exec-continue" "continuing execution to thread condition"
# Check if we stopped in thread 2 like we should.
-set testname "Run till MI pending breakpoint on pendfunc3 on thread 2"
+set testname "run till MI pending breakpoint on pendfunc3 on thread 2"
gdb_expect {
-re "\\*stopped,reason=\"breakpoint-hit\",disp=\"keep\",bkptno=\"4\",frame=\{addr=\"$hex\",func=\"pendfunc3\".*thread-id=\"2\".*" {
pass $testname
if { [gdb_compile_shlib ${srcfile_lib} ${binfile_lib} $lib_flags] != ""
|| [gdb_compile ${srcfile_main} ${binfile} executable $bin_flags] != "" } {
- untested "Could not compile $binfile_lib or $binfile."
+ untested "could not compile $binfile_lib or $binfile."
return -1
}
mi_gdb_exit
if {[mi_gdb_start "separate-mi-tty"] != 0} {
- fail "Could not start gdb"
+ fail "could not start gdb"
return
}
mi_gdb_load $binfile
if { [mi_runto main] < 0 } {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
# Inferior 1 stops at f1.
if ![runto f1] then {
- fail "Can't run to f1"
+ fail "can't run to f1"
return 0
}
# Inferior 2 stops at f2.
if ![runto f2] then {
- fail "Can't run to f2"
+ fail "can't run to f2"
return 0
}
clean_restart ${exec1}
if ![runto_main] then {
- fail "Couldn't run to main"
+ fail "couldn't run to main"
return -1
}
"load binary"
if {![runto_main]} {
- fail "Couldn't run to main."
+ fail "couldn't run to main."
return
}
gdb_test_no_output "set detach-on-fork off"
if ![runto "child_function"] {
- fail "Can't run to child_function"
+ fail "can't run to child_function"
return
}
if { [gdb_compile_shlib ${srcfile_lib} ${binfile_lib} $lib_flags] != ""
|| [gdb_compile ${srcfile} ${binfile} executable $bin_flags] != "" } {
- untested "Could not compile $binfile_lib or $binfile."
+ untested "could not compile $binfile_lib or $binfile."
return -1
}
clean_restart $binfile
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart $binfile
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
return 0
global SKIP_STEP_COUNT SKIP_DIRECTIVE_COUNT
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart $binfile
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
return 0
clean_restart $binfile
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
return 0
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "Couldn't run to main."
+ fail "couldn't run to main."
return 0
}
if { [skip_python_tests] } { continue }
if ![runto_main ] then {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_test "python print (gdb.breakpoints())" "\\(\\)"
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
}
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
gdb_test_no_output "set can-use-hw-watchpoints 0" ""
}
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
delete_breakpoints
gdb_test_no_output "set can-use-hw-watchpoints 0" ""
}
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
delete_breakpoints
clean_restart ${testfile}
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
delete_breakpoints
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
if { [gdb_compile_shlib $libsrc $lib_sl $lib_opts] != ""
|| [gdb_compile $srcdir/$subdir/$srcfile $binfile executable $exec_opts] != ""} {
- untested "Could not compile either $libsrc or $srcdir/$subdir/$srcfile."
+ untested "could not compile either $libsrc or $srcdir/$subdir/$srcfile."
return -1
}
gdb_breakpoint "thread3"
gdb_run_cmd
-set test "Run to breakpoint 1"
+set test "run to breakpoint 1"
gdb_test_multiple "" $test {
-re "event type: stop\r\nstop reason: breakpoint\r\nfirst breakpoint number: 1\r\nbreakpoint number: 1\r\nthread num: 1\r\n.*$gdb_prompt $" {
pass $test
if { [gdb_compile_shlib $libsrc $lib_sl $lib_opts] != ""
|| [gdb_compile $srcdir/$subdir/$srcfile $binfile executable $exec_opts] != ""} {
- untested "Could not compile either $libsrc or $srcdir/$subdir/$srcfile."
+ untested "could not compile either $libsrc or $srcdir/$subdir/$srcfile."
return -1
}
gdb_load_shlib ${lib_sl}
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
set cond_line [gdb_get_line_number "Condition Break."]
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
"import python scripts"
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
"import python scripts"
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
#
if ![runto "test_exec_exit"] then {
- fail "Cannot run to test_exec_exit."
+ fail "cannot run to test_exec_exit."
return 0
}
#
if ![runto "test_exec_exit"] then {
- fail "Cannot run to test_exec_exit."
+ fail "cannot run to test_exec_exit."
return 0
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
if { [skip_python_tests] } { continue }
if ![runto main] then {
- fail "Can't run to function f"
+ fail "can't run to function f"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_exit
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}-cxx" \
executable {debug c++ additional_flags=-DMI}] != "" } {
- untested "Couldn't compile ${srcfile} in c++ mode"
+ untested "couldn't compile ${srcfile} in c++ mode"
return -1
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
if { [skip_python_tests] } { continue }
if ![runto_main ] then {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
${srcdir}/${subdir}/${testfile}.py]
if ![runto_main ] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
proc run_lang_tests {exefile lang} {
global srcdir subdir srcfile testfile hex
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${exefile}" executable "debug $lang"] != "" } {
- untested "Couldn't compile ${srcfile} in $lang mode"
+ untested "couldn't compile ${srcfile} in $lang mode"
return -1
}
# The following tests require execution.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
set library [standard_output_file ${libfile}.sl]
if { [gdb_compile_shlib ${srcdir}/${subdir}/${libsrc} ${library} "debug"] != "" } {
- untested "Could not compile shared library."
+ untested "could not compile shared library."
return -1
}
set exec_opts [list debug shlib=${library}]
if { [gdb_compile ${srcdir}/${subdir}/${srcfile} ${binfile} executable $exec_opts] != "" } {
- untested "Could not compile $binfile."
+ untested "could not compile $binfile."
return -1
}
# The following tests require execution.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# C++ tests
# Recompile binary.
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}-cxx" executable "debug c++"] != "" } {
- untested "Couldn't compile ${srcfile} in c++ mode"
+ untested "couldn't compile ${srcfile} in c++ mode"
return -1
}
gdb_load ${binfile}-cxx
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Start with a fresh gdb.
clean_restart ${testfile}
if ![runto_main] then {
- fail "Cannot run to main."
+ fail "cannot run to main."
return 0
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
standard_testfile .cc
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable \
{debug c++}] != "" } {
- untested "Couldn't compile ${srcfile}"
+ untested "couldn't compile ${srcfile}"
return -1
}
global srcdir subdir srcfile testfile hex
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${exefile}" executable "debug $lang"] != "" } {
- untested "Couldn't compile ${srcfile} in $lang mode"
+ untested "couldn't compile ${srcfile} in $lang mode"
return -1
}
set pyfile [gdb_remote_download host ${srcdir}/${subdir}/${testfile}.py]
if ![runto_main ] then {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# The following tests require execution.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${objfile}" object "debug $lang"] != ""
|| [gdb_compile "${objfile}" "${exefile}" executable "debug $lang"] != "" } {
- untested "Couldn't compile ${srcfile} in $lang mode"
+ untested "couldn't compile ${srcfile} in $lang mode"
return -1
}
return 0
# The following tests require execution.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_test_multiple "python gdb.prompt_hook = None" "Delete hook" {
-re "\[\r\n\]$newprompt2 $" {
- pass "Delete old hook"
+ pass "delete old hook"
}
}
# The following tests require execution.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
set n_testcases [get_integer_valueof "n_testcases" 0]
if { ${n_testcases} == 0 } {
- untested "No test"
+ untested "no test"
return 1
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Compile the first without debug info so that
# stepping and reverse stepping doesn't end up inside them.
if { [gdb_compile_shlib ${srcdir}/${subdir}/${lib1src} ${library1} ""] != "" } {
- untested "Could not compile shared library1."
+ untested "could not compile shared library1."
return -1
}
if { [gdb_compile_shlib ${srcdir}/${subdir}/${lib2src} ${library2} "debug"] != "" } {
- untested "Could not compile shared library2."
+ untested "could not compile shared library2."
return -1
}
if { [gdb_compile ${srcdir}/${subdir}/${srcfile} ${binfile} executable \
[concat $exec_opts additional_flags=-Wl,-z,norelro]] != ""
&& [gdb_compile ${srcdir}/${subdir}/${srcfile} ${binfile} executable $exec_opts] != "" } {
- untested "Could not compile $binfile."
+ untested "could not compile $binfile."
return -1
}
# Compile the first without debug info so that
# stepping and reverse stepping doesn't end up inside them.
if { [gdb_compile_shlib ${srcdir}/${subdir}/${lib1src} ${library1} ""] != "" } {
- untested "Could not compile shared library1."
+ untested "could not compile shared library1."
return -1
}
if { [gdb_compile_shlib ${srcdir}/${subdir}/${lib2src} ${library2} "debug"] != "" } {
- untested "Could not compile shared library2."
+ untested "could not compile shared library2."
return -1
}
set exec_opts [list debug shlib=${library1} shlib=${library2}]
if { [gdb_compile ${srcdir}/${subdir}/${srcfile} ${binfile} executable $exec_opts] != "" } {
- untested "Could not compile $binfile."
+ untested "could not compile $binfile."
return -1
}
proc do_test {version} {
if ![runto_main] {
- fail "Can't run to main $version"
+ fail "can't run to main $version"
return -1
}
gdb_test "rb test" "" "Set breakpoints $version"
pass "weirdx.o read without error"
}
-re ".*$gdb_prompt $" {
- fail "Errors reading weirdx.o"
+ fail "errors reading weirdx.o"
}
timeout {
perror "couldn't load $binfile into $GDB (timed out)."
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
set GDBFLAGS $saved_gdbflags
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_load ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_test_no_output "set displaced on"
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
set GDBFLAGS $saved_gdbflags
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Some targets can't do function calls, so don't even bother with this
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
clean_restart ${binfile}
if { ![runto_main] } {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Some targets can't do function calls, so don't even bother with this
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
clean_restart ${binfile}
if { ![runto_main] } {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# It would be nice if we could catch the message that GDB prints
# when it first notices that the thread library doesn't support
# debugging, or if we could explicitly ask GDB somehow.
- unsupported "This GDB does not support threads on this system."
+ unsupported "this GDB does not support threads on this system."
return -1
}
-re "$gdb_prompt $" {
gdb_test_no_output "set can-use-hw-watchpoints 1" ""
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_test_multiple "continue" "all threads ran once" {
-re "Breakpoint \[0-9\]+, thread_function \\(arg=.*\\) at .*print-threads.c:\[0-9\]+.*$gdb_prompt" {
set i [expr $i + 1]
- pass "Hit thread_function breakpoint, $i ($name)"
+ pass "hit thread_function breakpoint, $i ($name)"
send_gdb "continue\n"
exp_continue
}
-re "Breakpoint \[0-9\]+, .* kill \\(.*\\) .*$gdb_prompt" {
set j [expr $j + 1]
if { $kill == 1 } {
- pass "Hit kill breakpoint, $j ($name)"
+ pass "hit kill breakpoint, $j ($name)"
} else {
- fail "Hit kill breakpoint, $j ($name) (unexpected)"
+ fail "hit kill breakpoint, $j ($name) (unexpected)"
}
send_gdb "continue\n"
exp_continue
if { $kill == 1 } {
kfail "gdb/1265" "Running threads ($name) (zombie thread)"
} else {
- fail "Running threads ($name) (unknown output)"
+ fail "running threads ($name) (unknown output)"
}
}
}
clean_restart ${binfile}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
set GDBFLAGS $saved_gdbflags
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Verify that all threads are running.
if [all_threads_running] then {
- pass "All threads running after startup"
+ pass "all threads running after startup"
}
# Send a continue followed by ^C to the process to stop it.
gdb_test_multiple "continue" "continue with all threads running" {
-re "Continuing." {
- pass "Continue with all threads running"
+ pass "continue with all threads running"
}
}
after 2000
# Verify that all threads can be run again after a ^C stop.
if [all_threads_running] then {
- pass "All threads running after continuing from ^C stop"
+ pass "all threads running after continuing from ^C stop"
}
return 0
}
clean_restart ${binfile}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
"${srcdir}/${subdir}/${srcfile}" \
"${binfile}" \
executable {debug}] != "" } {
- untested "Couldn't compile test program."
+ untested "couldn't compile test program."
return -1
}
clean_restart $executable
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto "thread_function"] then {
- fail "Can't run to thread_function"
+ fail "can't run to thread_function"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
runto_main
gdb_test "break sem_post"
-set test "Continue to main's call of sem_post"
+set test "continue to main's call of sem_post"
gdb_test_multiple "continue" "$test" {
-re "Breakpoint .*, .*sem_post .*$gdb_prompt " {
pass "$test"
rerun_to_main
gdb_test "handle $sig nostop noprint pass"
-set test "Handle $sig helps"
+set test "handle $sig helps"
gdb_test "continue" " .*sem_post .*" "handle $sig helps"
"${srcdir}/${subdir}/${srcfile}" \
"${binfile}" \
executable {debug}] != "" } {
- untested "Couldn't compile test program."
+ untested "couldn't compile test program."
return -1
}
# Some targets can't do function calls, so don't even bother with this
# test.
if [target_info exists gdb,cannot_call_functions] {
- unsupported "This target can not call functions"
+ unsupported "this target can not call functions"
continue
}
clean_restart ${binfile}
if { ![runto_main] } {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 1
}
# The initial thread may log a 'New Thread' message, but we don't
# check for it.
if ![runto_main] then {
- fail "Can't run to main $enabled_string"
+ fail "can't run to main $enabled_string"
return 1
}
clean_restart ${binfile}
if ![runto main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_load_shlib ${binfile_lib}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
gdb_load_shlib ${binfile_lib}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
"Cannot read .a_thread_local. without registers"
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
if {$thrs_in_spin == 0} {
- fail "No thread backtrace reported spin (vsyscall kernel problem?)"
+ fail "no thread backtrace reported spin (vsyscall kernel problem?)"
}
gdb_test "continue" ".*Breakpoint 4.*before exit.*" "threads exited"
send_gdb "info thread\n"
gdb_expect {
-re ".* 1 *Thread.*2 *Thread.*$gdb_prompt $" {
- fail "Too many threads left at end"
+ fail "too many threads left at end"
}
-re ".*\\\* 1 *Thread.*main.*$gdb_prompt $" {
- pass "Expect only base thread at end"
+ pass "expect only base thread at end"
}
-re ".*No stack.*$gdb_prompt $" {
fail "runaway at end"
# Run to `main' where we begin our tests.
if ![runto_main] then {
- fail "Failed to run to main"
+ fail "failed to run to main"
return 0
}
# (through board settings) that it did not support them in the first place.
# Just exit.
if { $hwatch_count == 0} {
- fail "No hardware watchpoints available"
+ fail "no hardware watchpoints available"
return 0
}
clean_restart $testfile
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
if ![gdb_target_supports_trace] {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return -1
}
set baseline [gdb_find_recursion_test_baseline $srcfile]
if { $baseline == -1 } then {
- fail "Could not find gdb_recursion_test function"
+ fail "could not find gdb_recursion_test function"
return
}
gdb_breakpoint "main"
gdb_run_cmd
if {[gdb_test "" "Breakpoint .*"] != 0} {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return 1
}
set baseline [gdb_find_recursion_test_baseline $srcfile]
if { $baseline == -1 } {
- fail "Could not find gdb_recursion_test function"
+ fail "could not find gdb_recursion_test function"
return
}
if { [gdb_compile_shlib $libsrc1 $lib_sl1 $lib_opts] != ""
|| [gdb_compile_shlib $libsrc2 $lib_sl2 $lib_opts] != ""
|| [gdb_compile $srcdir/$subdir/$srcfile $binfile executable $additional_flags] != ""} {
- untested "Could not compile either $libsrc1 or $srcdir/$subdir/$srcfile."
+ untested "could not compile either $libsrc1 or $srcdir/$subdir/$srcfile."
return -1
}
gdb_load_shlib $lib_sl2
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return -1
}
clean_restart ${testfile}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
gdb_test_no_output "delete break 1"
clean_restart ${testfile}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
runto_main
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return 1
}
# all subsequent line numbers are relative to this first one (baseline)
set baseline [gdb_find_recursion_test_baseline $srcfile]
if { $baseline == -1 } then {
- fail "Could not find gdb_recursion_test function"
+ fail "could not find gdb_recursion_test function"
return
}
set testline1 [expr $baseline + 4]
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
}
if { [string equal $returned_from_foo ""] } {
- fail "Find the call or branch instruction offset in bar"
+ fail "find the call or branch instruction offset in bar"
# The following test makes no sense if the offset is unknown. We need
# to update the pattern above to match call or branch instruction for
# the target architecture.
clean_restart ${testfile}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
load_lib "trace-support.exp"
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
# Check that the target supports trace.
if { [gdb_compile_pthreads "$srcdir/$subdir/$srcfile" $binfile executable $options] != "" } {
- untested "Couldn't compile test program"
+ untested "couldn't compile test program"
return -1
}
clean_restart ${testfile}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
lappend options shlib=$libipa
if { [gdb_compile_pthreads "$srcdir/$subdir/$srcfile" $binfile executable $options] != "" } {
- untested "Couldn't compile test program with in-process agent library"
+ untested "couldn't compile test program with in-process agent library"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
if { [gdb_test "info sharedlibrary" ".*${remote_libipa}.*" "IPA loaded"] != 0 } {
- untested "Could not find IPA lib loaded"
+ untested "could not find IPA lib loaded"
return 1
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main for ftrace tests"
+ fail "can't run to main for ftrace tests"
return 0
}
gdb_reinitialize_dir $srcdir/$subdir
if { [gdb_test "info sharedlibrary" ".*${remote_libipa}.*" "IPA loaded"] != 0 } {
- untested "Could not find IPA lib loaded"
+ untested "could not find IPA lib loaded"
return 1
}
"collect gdb_struct1_test" "^$"
gdb_run_cmd
if {[gdb_test "" "Breakpoint ${decimal}, main.*"] != 0} {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return 1
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
if ![gdb_target_supports_trace] {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return -1
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
if ![gdb_target_supports_trace] {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return -1
}
clean_restart $executable
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
if ![gdb_target_supports_trace] {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return -1
}
if { [gdb_compile_shlib $libsrc1 $lib_sl1 $lib_opts] != ""
|| [gdb_compile_shlib $libsrc2 $lib_sl2 $lib_opts] != ""} {
- untested "Could not compile either $libsrc1 or $libsrc2"
+ untested "could not compile either $libsrc1 or $libsrc2"
return -1
}
set exec_opts [list debug shlib=$lib_sl1 shlib_load]
if { [gdb_compile $srcdir/$subdir/$srcfile $binfile executable $exec_opts] != "" } {
- untested "Failed to compile $srcfile"
+ untested "failed to compile $srcfile"
return -1
}
gdb_load_shlib $lib_sl1
gdb_load_shlib $lib_sl2
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
# Create tracepoints on marker and main, and leave them in the
gdb_load_shlib $lib_sl2
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
if ![gdb_target_supports_trace] {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return -1
}
clean_restart $testfile
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
if ![gdb_target_supports_trace] {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return -1
}
gdb_exit
clean_restart $testfile
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
clean_restart $testfile
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
if ![gdb_target_supports_trace] {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return -1
}
clean_restart $testfile
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return 1
}
with_test_prefix "after tstart" {
if ![runto_main] {
- fail "Can't run to main, target may have died unexpectedly"
+ fail "can't run to main, target may have died unexpectedly"
return -1
}
}
gdb_reinitialize_dir $srcdir/$subdir
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return 1
}
gdb_reinitialize_dir $srcdir/$subdir
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return 1
}
set baseline [gdb_find_recursion_test_baseline $srcfile]
if { $baseline == -1 } then {
- fail "Could not find gdb_recursion_test function"
+ fail "could not find gdb_recursion_test function"
return
}
# all subsequent line numbers are relative to this first one (baseline)
set baseline [gdb_find_recursion_test_baseline $srcfile]
if { $baseline == -1 } then {
- fail "Could not find gdb_recursion_test function"
+ fail "could not find gdb_recursion_test function"
return
}
if { [gdb_compile_shlib $libsrc1 $lib_sl1 $lib_opts] != ""
|| [gdb_compile_shlib $libsrc2 $lib_sl2 $lib_opts] != ""} {
- untested "Could not compile either $libsrc1 or $libsrc2"
+ untested "could not compile either $libsrc1 or $libsrc2"
return -1
}
set exec_opts [list debug shlib=$lib_sl1 shlib_load]
if { [gdb_compile $srcdir/$subdir/$srcfile $binfile executable $exec_opts] != "" } {
- untested "Failed to compile $srcfile"
+ untested "failed to compile $srcfile"
return -1
}
gdb_load_shlib $lib_sl2
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
if ![gdb_target_supports_trace] {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return -1
}
# Start with a fresh gdb.
clean_restart $executable
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart $executable
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart $executable
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart $executable
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart $executable
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
lappend exec_opts "shlib=$libipa"
if { [gdb_compile $srcdir/$subdir/$srcfile $binfile executable $exec_opts] != "" } {
- untested "Failed to compile $srcfile"
+ untested "failed to compile $srcfile"
return -1
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
clean_restart $testfile
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
}
if ![gdb_target_supports_trace] {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return -1
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main for ftrace tests"
+ fail "can't run to main for ftrace tests"
return 0
}
gdb_reinitialize_dir $srcdir/$subdir
if { [gdb_test "info sharedlibrary" ".*${remote_libipa}.*" "IPA loaded"] != 0 } {
- untested "Could not find IPA lib loaded"
+ untested "could not find IPA lib loaded"
} else {
range_stepping_with_tracepoint "ftrace"
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
# Start with a fresh gdb.
clean_restart ${testfile}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
gdb_test "break end" "Breakpoint \[0-9\] at .*"
gdb_reinitialize_dir $srcdir/$subdir
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return 1
}
set gdb_recursion_test_baseline [gdb_find_recursion_test_baseline $srcfile]
if { $gdb_recursion_test_baseline == -1 } {
- fail "Could not find gdb_recursion_test function"
+ fail "could not find gdb_recursion_test function"
return
}
# all subsequent line numbers are relative to this first one (baseline)
set baseline [gdb_find_recursion_test_baseline $srcfile]
if { $baseline == -1 } then {
- fail "Could not find gdb_recursion_test function"
+ fail "could not find gdb_recursion_test function"
return
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
# Start with a fresh gdb.
clean_restart ${testfile}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
if { [gdb_compile "$srcdir/$subdir/$srcfile" \
[standard_output_file $exec_name] \
executable [concat $arg debug nowarnings]] != "" } {
- untested "Could not compile ${srcfile}"
+ untested "could not compile ${srcfile}"
return 0
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart $executable
gdb_load_shlib $libipa
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart $executable
gdb_load_shlib $libipa
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart $executable
gdb_load_shlib $libipa
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart $executable
gdb_load_shlib $libipa
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart $executable
gdb_load_shlib $libipa
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart $executable
gdb_load_shlib $libipa
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
if { ![gdb_target_supports_trace] } then {
# file can be removed. Note that GDB simply kill inferior doesn't remove
# the socket file.
gdb_test "detach" "Detaching .*, process .*"
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return -1
}
remote_file target delete $tfile_error
if { ![generate_tracefile $binfile] } {
- unsupported "Unable to generate trace file"
+ unsupported "unable to generate trace file"
return -1
}
gdb_reinitialize_dir $srcdir/$subdir
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return 1
}
# all subsequent line numbers are relative to this first one (baseline)
set baseline [gdb_find_recursion_test_baseline $srcfile]
if { $baseline == -1 } then {
- fail "Could not find gdb_recursion_test function"
+ fail "could not find gdb_recursion_test function"
return
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main for ftrace tests"
+ fail "can't run to main for ftrace tests"
return 0
}
gdb_reinitialize_dir $srcdir/$subdir
if { [gdb_test "info sharedlibrary" ".*${remote_libipa}.*" "IPA loaded"] != 0 } {
- untested "Could not find IPA lib loaded"
+ untested "could not find IPA lib loaded"
} else {
foreach break_always_inserted { "on" "off" } {
break_trace_same_addr_1 "ftrace" ${break_always_inserted}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main for ftrace tests"
+ fail "can't run to main for ftrace tests"
return 0
}
if { [gdb_test "info sharedlibrary" ".*${remote_libipa}.*" "IPA loaded"] != 0 } {
- untested "Could not find IPA lib loaded"
+ untested "could not find IPA lib loaded"
return 1
}
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main for ftrace tests"
+ fail "can't run to main for ftrace tests"
return 0
}
# Check that the target supports trace.
if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile executable $options] != "" } {
- untested "Couldn't compile test program"
+ untested "couldn't compile test program"
return -1
}
clean_restart ${testfile}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
lappend options shlib=$libipa
if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile executable $options] != "" } {
- untested "Couldn't compile test program with in-process agent library"
+ untested "couldn't compile test program with in-process agent library"
return -1
}
set expected 0
if ![runto_main] {
- fail "Can't run to main."
+ fail "can't run to main."
return -1
}
if { [gdb_compile_pthreads "$srcdir/$subdir/$srcfile" $binfile \
executable [list debug $additional_flags] ] != "" } {
- untested "Couldn't compile test program"
+ untested "couldn't compile test program"
return -1
}
clean_restart ${testfile}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
# Make sure inferior is running in all-stop mode.
gdb_test_no_output "set non-stop 0"
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "Can't run to main for ftrace tests"
+ fail "can't run to main for ftrace tests"
return 0
}
gdb_reinitialize_dir $srcdir/$subdir
if { [gdb_test "info sharedlibrary" ".*${remote_libipa}.*" "IPA loaded"] != 0 } {
- untested "Could not find IPA lib loaded"
+ untested "could not find IPA lib loaded"
} else {
foreach break_always_inserted { "on" "off" } {
break_trace_same_addr "ftrace" ${break_always_inserted}
# all subsequent line numbers are relative to this first one (baseline)
set baseline [gdb_find_recursion_test_baseline $srcfile]
if { $baseline == -1 } then {
- fail "Could not find gdb_recursion_test function"
+ fail "could not find gdb_recursion_test function"
return
}
# Acceptance vs rejection of a location are target-specific, so allow both.
gdb_test_multiple "ftrace gdb_recursion_test" "Set a fast tracepoint" {
-re "Fast tracepoint $decimal at $hex: file.*$srcfile, line $testline1.*$gdb_prompt $" {
- pass "Set a fast tracepoint"
+ pass "set a fast tracepoint"
}
-re ".*May not have a fast tracepoint at $hex.*$gdb_prompt $" {
- pass "Declined to set a fast tracepoint"
+ pass "declined to set a fast tracepoint"
}
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
runto_main
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return 1
}
}
if ![runto_main] {
- fail "Can't run to main to check for trace support"
+ fail "can't run to main to check for trace support"
return -1
}
# The rest of the testing needs actual tracing to work.
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return 1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "Can't run to main"
+ fail "can't run to main"
return
}
runto_main
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return 1
}
gdb_reinitialize_dir $srcdir/$subdir
if { ![gdb_target_supports_trace] } then {
- unsupported "Current target does not support trace"
+ unsupported "current target does not support trace"
return 1
}
gdb_delete_tracepoints
set trcpt1 [gdb_gettpnum gdb_c_test]
if { $trcpt1 <= 0 } then {
- fail "Could not find gdb_c_test function"
+ fail "could not find gdb_c_test function"
return
}
gdb_breakpoint "main"
gdb_run_cmd
if {[gdb_test "" "Breakpoint .*"] != 0} {
- fail "Can't run to main"
+ fail "can't run to main"
return -1
}
proc gdb_guile_runto_main { } {
if ![runto_main] {
- fail "Can't run to main"
+ fail "can't run to main"
return 0
}
}
-re "The target does not support running in non-stop mode.\r\n$gdb_prompt $" {
if { $print_fail } {
- unsupported "Non-stop mode not supported"
+ unsupported "non-stop mode not supported"
}
return 0
}
global gdb_prompt
set is_gdbserver -1
- set test "Probing for GDBserver"
+ set test "probing for GDBserver"
gdb_test_multiple "monitor help" $test {
-re "The following monitor commands are supported.*Quit GDBserver.*$gdb_prompt $" {
}
}
if {!$built_binfile} {
- unsupported "Couldn't compile [file tail $source]: ${why_msg}"
+ unsupported "couldn't compile [file tail $source]: ${why_msg}"
return -1
}
}
}
}
if {!$built_binfile} {
- unsupported "Couldn't compile $sources: ${why_msg}"
+ unsupported "couldn't compile $sources: ${why_msg}"
return -1
}
}
}
}
if {!$built_binfile} {
- unsupported "Couldn't compile [file tail $source]: ${why_msg}"
+ unsupported "couldn't compile [file tail $source]: ${why_msg}"
return -1
}
}
verbose "GDB initialized."
}
-re ".*unrecognized option.*for a complete list of options." {
- untested "Skip mi tests (not compiled with mi support)."
+ untested "skip mi tests (not compiled with mi support)."
remote_close host
return -1
}
-re ".*Interpreter `mi' unrecognized." {
- untested "Skip mi tests (not compiled with mi support)."
+ untested "skip mi tests (not compiled with mi support)."
remote_close host
return -1
}
continue
}
-re "Non-stop mode requested, but remote does not support non-stop.*$mi_gdb_prompt" {
- unsupported "Non-stop mode not supported"
+ unsupported "non-stop mode not supported"
return 1
}
-re "Timeout reading from remote system.*$mi_gdb_prompt$" {
-re "${run_match}\\^running\r\n(\\*running,thread-id=\"\[^\"\]+\"\r\n|=thread-created,id=\"1\",group-id=\"\[0-9\]+\"\r\n)*(${library_loaded_re})*(${thread_selected_re})?${mi_gdb_prompt}" {
}
-re "\\^error,msg=\"The target does not support running in non-stop mode.\"" {
- unsupported "Non-stop mode not supported"
+ unsupported "non-stop mode not supported"
return -1
}
timeout {
} elseif { $pascal_compiler_is_gpc == 1 } {
set result [gpc_compile $source $destfile $type $options]
} else {
- unsupported "No pascal compiler found"
+ unsupported "no pascal compiler found"
return "No pascal compiler. Compilation failed."
}
if { [string compare $GDB_PERFTEST_MODE "run"] != 0 } {
if { [eval compile {$compile}] } {
- untested "Could not compile source files."
+ untested "could not compile source files."
return
}
}
set loop [expr $loop + 1]
if {$loop > 30} {
- fail "Looping symlink resolution for $file"
+ fail "looping symlink resolution for $file"
return ""
}
}
}
if { $gdb_file_cmd_debug_info != "debug" } then {
- untested "No debug information, skipping testcase."
+ untested "no debug information, skipping testcase."
return -1
}
projects / binutils-gdb.git / commitdiff