This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[RFC/A] testsuite/gdb.c++/ref-types.exp "cleanup"
- To: <gdb-patches at sources dot redhat dot com>
- Subject: [RFC/A] testsuite/gdb.c++/ref-types.exp "cleanup"
- From: Keith Seitz <keiths at cygnus dot com>
- Date: Thu, 18 Oct 2001 22:51:59 -0700 (PDT)
Hi,
I will be submitting some additional tests to ref-types.exp in the next
day or so, and I thought that it would be nice to clean up ref-types.exp a
little beforehand.
The following "patch" (which is bigger than the file) uses gdb_test and
gdb_test_exact when appropriate, and it cleans up some common tcl "errors"
(not really syntax errors, but common syntax usages which are, umm,
offensive).
I think this is much easier to read than the "normal" things that are done
in the testsuite.
I have only tested this on linux native and solaris native. If more are
required, just name them.
What do others think?
Keith
ChangeLog
2001-10-18 Keith Seitz <keiths@redhat.com>
* gdb.c++/ref-types.exp: Cleanup.
Use gdb_test and gdb_test_exact where appropriate.
Insert braces around expressions, whack the "then" from
"if" statements and other tcl-style nicities (which also
speed up the execution of the code).
Rewrite regular expressions to avoid escaping and re-escaping
regexps because of gdb_test whackiness.
Update copyright.
Patch
Index: ref-types.exp
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.c++/ref-types.exp,v
retrieving revision 1.5
diff -u -p -r1.5 ref-types.exp
--- ref-types.exp 2001/03/16 17:59:58 1.5
+++ ref-types.exp 2001/10/19 03:51:58
@@ -1,5 +1,5 @@
# Tests for reference types with short type variables in GDB.
-# Copyright 1998, 1999, 2000 Free Software Foundation, Inc.
+# Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
@@ -20,9 +20,10 @@
# written by Elena Zannoni (ezannoni@cygnus.com)
-if $tracelevel then {
- strace $tracelevel
- }
+if {$tracelevel} {
+ strace $tracelevel
+}
+
#
# test running programs
@@ -49,12 +50,12 @@ gdb_load ${binfile}
#
# set it up at a breakpoint so we can play with the variable values
#
-if ![runto_main] then {
+if {![runto_main]} {
perror "couldn't run to breakpoint"
continue
}
-if ![runto 'marker1'] then {
+if {![runto "marker1"]} {
perror "couldn't run to marker1"
continue
}
@@ -77,12 +78,12 @@ proc gdb_start_again {} {
#
# set it up at a breakpoint so we can play with the variable values
#
- if ![runto_main] then {
+ if {![runto_main]} {
perror "couldn't run to breakpoint"
continue
}
- if ![runto 'marker1'] then {
+ if {![runto "marker1"]} {
perror "couldn't run to marker1"
continue
}
@@ -90,574 +91,164 @@ proc gdb_start_again {} {
gdb_test "up" ".*main.*" "up from marker1 2"
}
-
-
-send_gdb "print s\n"
-gdb_expect {
- -re ".\[0-9\]* = -1.*$gdb_prompt $" {
- pass "print value of s"
- }
- -re ".*$gdb_prompt $" { fail "print value of s" }
- timeout { fail "(timeout) print value of s" }
- }
-
-
-send_gdb "ptype s\n"
-gdb_expect {
- -re "type = short.*$gdb_prompt $" { pass "ptype s" }
- -re ".*$gdb_prompt $" { fail "ptype s" }
- timeout { fail "(timeout) ptype s" }
-}
+gdb_test {print s} {.[0-9]* = -1} {print value of s}
-send_gdb "print *ps\n"
-gdb_expect {
- -re ".\[0-9\]* = -1.*$gdb_prompt $" {
- pass "print value of ps"
- }
- -re ".*$gdb_prompt $" { fail "print value of ps" }
- timeout { fail "(timeout) print value of ps" }
- }
+gdb_test {ptype s} {type = short (int)?} {ptype s}
+gdb_test {print *ps} {.[0-9]* = -1} {print value of ps}
-send_gdb "ptype ps\n"
-gdb_expect {
- -re "type = short \*.*$gdb_prompt $" { pass "ptype ps" }
- -re ".*$gdb_prompt $" { fail "ptype ps" }
- timeout { fail "(timeout) ptype ps" }
-}
+gdb_test {ptype ps} {type = short (int)? \*} {ptype ps}
-send_gdb "print as\[0\]\n"
-gdb_expect {
- -re ".\[0-9\]* = 0.*$gdb_prompt $" {
- pass "print value of as\[0\]"
- }
- -re ".*$gdb_prompt $" { fail "print value of as\[0\]" }
- timeout { fail "(timeout) print value of as\[0\]" }
- }
+gdb_test {print as[0]} {.[0-9]* = 0} {print value of as[0]}
+gdb_test {ptype as} {type = short (int)? \[4\]} {ptype as}
-send_gdb "ptype as\n"
-gdb_expect {
- -re "type = short \\\[4\\\].*$gdb_prompt $" { pass "ptype as" }
- -re "type = short int \\\[4\\\].*$gdb_prompt $" { pass "ptype as" }
- -re ".*$gdb_prompt $" { fail "ptype as" }
- timeout { fail "(timeout) ptype as" }
-}
+gdb_test {print as[1]} {.[0-9]* = 1} {print value of as[1]}
-send_gdb "print as\[1\]\n"
-gdb_expect {
- -re ".\[0-9\]* = 1.*$gdb_prompt $" {
- pass "print value of as\[1\]"
- }
- -re ".*$gdb_prompt $" { fail "print value of as\[1\]" }
- timeout { fail "(timeout) print value of as\[1\]" }
- }
+gdb_test {print as[2]} {.[0-9]* = 2} {print value of as[2]}
-send_gdb "print as\[2\]\n"
-gdb_expect {
- -re ".\[0-9\]* = 2.*$gdb_prompt $" {
- pass "print value of as\[2\]"
- }
- -re ".*$gdb_prompt $" { fail "print value of as\[2\]" }
- timeout { fail "(timeout) print value of as\[2\]" }
- }
+gdb_test {print as[3]} {.[0-9]* = 3} {print value of as[3]}
-send_gdb "print as\[3\]\n"
-gdb_expect {
- -re ".\[0-9\]* = 3.*$gdb_prompt $" {
- pass "print value of as\[3\]"
- }
- -re ".*$gdb_prompt $" { fail "print value of as\[3\]" }
- timeout { fail "(timeout) print value of as\[3\]" }
- }
-
+set pattern {.[0-9]* = \(short (int)? &\) @}
+append pattern "$hex: -1"
send_gdb "print rs\n"
gdb_expect {
- -re ".\[0-9\]* = \\(short &\\) @$hex: -1.*$gdb_prompt $" {
- pass "print value of rs"
- }
- -re ".\[0-9\]* = \\(short int &\\) @$hex: -1.*$gdb_prompt $" {
- pass "print value of rs"
- }
- -re ".*$gdb_prompt $" { fail "print value of rs" }
- timeout { fail "(timeout) print value of rs" }
- eof { fail "print rs ($GDB dumped core) (FIXME)" ; gdb_start_again ; }
-
+ -re $pattern {
+ pass "print value of rs"
}
-
-send_gdb "ptype rs\n"
-gdb_expect {
- -re "type = short &.*$gdb_prompt $" { pass "ptype rs" }
- -re "type = short int &.*$gdb_prompt $" { pass "ptype rs" }
- -re ".*$gdb_prompt $" { fail "ptype rs" }
- timeout { fail "(timeout) ptype rs" }
+ -re ".*$gdb_prompt $" { fail "print value of rs" }
+ timeout { fail "(timeout) print value of rs" }
+ eof { fail "print rs ($GDB dumped core) (FIXME)" ; gdb_start_again ; }
}
+gdb_test {ptype rs} {type = short (int)? &} {ptype rs}
-send_gdb "print *rps\n"
-gdb_expect {
- -re ".\[0-9\]* = -1.*$gdb_prompt $" {
- pass "print value of *rps"
- }
- -re ".*$gdb_prompt $" { fail "print value of *rps" }
- timeout { fail "(timeout) print value of *rps" }
- }
+gdb_test {print *rps} {.[0-9]* = -1} {print value of *rps}
+gdb_test {ptype rps} {type = short (int)? \*&} {ptype rps}
-send_gdb "ptype rps\n"
-gdb_expect {
- -re "type = short \\*&.*$gdb_prompt $" { pass "ptype rps" }
- -re "type = short int \\*&.*$gdb_prompt $" { pass "ptype rps" }
- -re ".*$gdb_prompt $" { fail "ptype rps" }
- timeout { fail "(timeout) ptype rps" }
-}
+gdb_test {print ras[0]} {.[0-9]* = 0} {print value of ras[0]}
+gdb_test {ptype ras} {type = short (int)? \(&\)\[4\]} {ptype ras}
+gdb_test {print ras[1]} {.[0-9]* = 1} {print value of ras[1]}
-send_gdb "print ras\[0\]\n"
-gdb_expect {
- -re ".\[0-9\]* = 0.*$gdb_prompt $" {
- pass "print value of ras\[0\]"
- }
- -re ".*$gdb_prompt $" { fail "print value of ras\[0\]" }
- timeout { fail "(timeout) print value of ras\[0\]" }
- }
+gdb_test {print ras[2]} {.[0-9]* = 2} {print value of ras[2]}
-
-send_gdb "ptype ras\n"
-gdb_expect {
- -re "type = short \\\(&\\\)\\\[4\\\].*$gdb_prompt $" { pass "ptype ras" }
- -re "type = short int \\\(&\\\)\\\[4\\\].*$gdb_prompt $" { pass "ptype ras" }
- -re ".*$gdb_prompt $" { fail "ptype ras" }
- timeout { fail "(timeout) ptype ras" }
-}
-
-send_gdb "print ras\[1\]\n"
-gdb_expect {
- -re ".\[0-9\]* = 1.*$gdb_prompt $" {
- pass "print value of ras\[1\]"
- }
- -re ".*$gdb_prompt $" { fail "print value of ras\[1\]" }
- timeout { fail "(timeout) print value of ras\[1\]" }
- }
-
-send_gdb "print ras\[2\]\n"
-gdb_expect {
- -re ".\[0-9\]* = 2.*$gdb_prompt $" {
- pass "print value of ras\[2\]"
- }
- -re ".*$gdb_prompt $" { fail "print value of ras\[2\]" }
- timeout { fail "(timeout) print value of ras\[2\]" }
- }
-
-send_gdb "print ras\[3\]\n"
-gdb_expect {
- -re ".\[0-9\]* = 3.*$gdb_prompt $" {
- pass "print value of ras\[3\]"
- }
- -re ".*$gdb_prompt $" { fail "print value of ras\[3\]" }
- timeout { fail "(timeout) print value of ras\[3\]" }
- }
+gdb_test {print ras[3]} {.[0-9]* = 3} {print value of ras[3]}
-if ![runto 'f'] then {
+if {![runto "f"]} {
perror "couldn't run to f"
continue
}
gdb_test "up" ".main2.*" "up from f"
-
-send_gdb "print C\n"
-gdb_expect {
- -re ".\[0-9\]* = 65 \'A\'.*$gdb_prompt $" {
- pass "print value of C"
- }
- -re ".*$gdb_prompt $" { fail "print value of C" }
- timeout { fail "(timeout) print value of C" }
- }
+gdb_test {print C} {.[0-9]* = 65 'A'} {print value of C}
-send_gdb "ptype C\n"
-gdb_expect {
- -re "type = char.*$gdb_prompt $" { pass "ptype C" }
- -re ".*$gdb_prompt $" { fail "ptype C" }
- timeout { fail "(timeout) ptype C" }
-}
+gdb_test_exact {ptype C} {type = char} {ptype C}
+gdb_test {print UC} {.[0-9]* = 21 '\\025'} {print value of UC}
-send_gdb "print UC\n"
-gdb_expect {
- -re ".\[0-9\]* = 21 '\.025'\.*$gdb_prompt $" {
- pass "print value of UC"
- }
- -re ".*$gdb_prompt $" { fail "print value of UC" }
- timeout { fail "(timeout) print value of UC" }
- }
+gdb_test_exact {ptype UC} {type = unsigned char} {ptype UC}
+gdb_test {print S} {.[0-9]* = -14} {print value of S}
-send_gdb "ptype UC\n"
-gdb_expect {
- -re "type = unsigned char.*$gdb_prompt $" { pass "ptype UC" }
- -re ".*$gdb_prompt $" { fail "ptype UC" }
- timeout { fail "(timeout) ptype UC" }
-}
+gdb_test {ptype S} {type = short (int)?} {ptype S}
+gdb_test {print US} {.[0-9]* = 7} {print value of US}
-send_gdb "print S\n"
-gdb_expect {
- -re ".\[0-9\]* = -14.*$gdb_prompt $" {
- pass "print value of S"
- }
- -re ".*$gdb_prompt $" { fail "print value of S" }
- timeout { fail "(timeout) print value of S" }
- }
+gdb_test {ptype US} {type = (unsigned short (int)?|short unsigned (int)?)} {ptype US}
+gdb_test {print I} {.[0-9]* = 102} {print value of I}
-send_gdb "ptype S\n"
-gdb_expect {
- -re "type = short.*$gdb_prompt $" { pass "ptype S" }
- -re ".*$gdb_prompt $" { fail "ptype S" }
- timeout { fail "(timeout) ptype S" }
-}
+gdb_test_exact {ptype I} {type = int} {ptype I}
+gdb_test {print UI} {.[0-9]* = 1002} {print value of UI}
-send_gdb "print US\n"
-gdb_expect {
- -re ".\[0-9\]* = 7.*$gdb_prompt $" {
- pass "print value of US"
- }
- -re ".*$gdb_prompt $" { fail "print value of US" }
- timeout { fail "(timeout) print value of US" }
- }
+gdb_test_exact {ptype UI} {type = unsigned int} {ptype UI}
+gdb_test {print L} {.[0-9]* = -234} {print value of L}
-send_gdb "ptype US\n"
-gdb_expect {
- -re "type = unsigned short.*$gdb_prompt $" { pass "ptype US" }
- -re "type = short unsigned.*$gdb_prompt $" { pass "ptype US" }
- -re ".*$gdb_prompt $" { fail "ptype US" }
- timeout { fail "(timeout) ptype US" }
-}
+gdb_test {ptype L} {type = long (int)?} {ptype L}
+gdb_test {print UL} {.[0-9]* = 234} {print value of UL}
-send_gdb "print I\n"
-gdb_expect {
- -re ".\[0-9\]* = 102.*$gdb_prompt $" {
- pass "print value of I"
- }
- -re ".*$gdb_prompt $" { fail "print value of I" }
- timeout { fail "(timeout) print value of I" }
- }
+gdb_test {ptype UL} {type = (unsigned long (int)?|long unsigned (int)?)} {ptype UL}
+gdb_test {print F} {.[0-9]* = 1.2[0-9]*e\+10} {print value of F}
-send_gdb "ptype I\n"
-gdb_expect {
- -re "type = int.*$gdb_prompt $" { pass "ptype I" }
- -re ".*$gdb_prompt $" { fail "ptype I" }
- timeout { fail "(timeout) ptype I" }
-}
+gdb_test_exact {ptype F} {type = float} {ptype F}
+gdb_test {print D} {.[0-9]* = -1.375e-123} {print value of D}
-send_gdb "print UI\n"
-gdb_expect {
- -re ".\[0-9\]* = 1002.*$gdb_prompt $" {
- pass "print value of UI"
- }
- -re ".*$gdb_prompt $" { fail "print value of UI" }
- timeout { fail "(timeout) print value of UI" }
- }
+gdb_test_exact {ptype D} {type = double} {ptype D}
-send_gdb "ptype UI\n"
-gdb_expect {
- -re "type = unsigned int.*$gdb_prompt $" { pass "ptype UI" }
- -re ".*$gdb_prompt $" { fail "ptype UI" }
- timeout { fail "(timeout) ptype UI" }
-}
-
-
-send_gdb "print L\n"
-gdb_expect {
- -re ".\[0-9\]* = -234.*$gdb_prompt $" {
- pass "print value of L"
- }
- -re ".*$gdb_prompt $" { fail "print value of L" }
- timeout { fail "(timeout) print value of L" }
- }
-
-
-send_gdb "ptype L\n"
-gdb_expect {
- -re "type = long.*$gdb_prompt $" { pass "ptype L" }
- -re ".*$gdb_prompt $" { fail "ptype L" }
- timeout { fail "(timeout) ptype L" }
-}
-
-
-send_gdb "print UL\n"
-gdb_expect {
- -re ".\[0-9\]* = 234.*$gdb_prompt $" {
- pass "print value of UL"
- }
- -re ".*$gdb_prompt $" { fail "print value of UL" }
- timeout { fail "(timeout) print value of UL" }
- }
-
-
-send_gdb "ptype UL\n"
-gdb_expect {
- -re "type = unsigned long.*$gdb_prompt $" { pass "ptype UL" }
- -re "type = long unsigned.*$gdb_prompt $" { pass "ptype UL" }
- -re ".*$gdb_prompt $" { fail "ptype UL" }
- timeout { fail "(timeout) ptype UL" }
-}
-
-
-send_gdb "print F\n"
-gdb_expect {
- -re ".\[0-9\]* = 1.2\[0-9\]*e\\+10.*$gdb_prompt $" {
- pass "print value of F"
- }
- -re ".*$gdb_prompt $" { fail "print value of F" }
- timeout { fail "(timeout) print value of F" }
- }
-
-
-
-send_gdb "ptype F\n"
-gdb_expect {
- -re "type = float.*$gdb_prompt $" { pass "ptype F" }
- -re ".*$gdb_prompt $" { fail "ptype F" }
- timeout { fail "(timeout) ptype F" }
-}
-
-
-send_gdb "print D\n"
-gdb_expect {
- -re ".\[0-9\]* = -1.375e-123.*$gdb_prompt $" {
- pass "print value of D"
- }
- -re ".*$gdb_prompt $" { fail "print value of D" }
- timeout { fail "(timeout) print value of D" }
- }
-
-
-send_gdb "ptype D\n"
-gdb_expect {
- -re "type = double.*$gdb_prompt $" { pass "ptype D" }
- -re ".*$gdb_prompt $" { fail "ptype D" }
- timeout { fail "(timeout) ptype D" }
-}
-
-
-
#
# test reference types
#
+gdb_test_exact {ptype rC} {type = char &} {ptype rC}
+gdb_test_exact {ptype rUC} {type = unsigned char &} {ptype rUC}
+gdb_test {ptype rS} {type = short (int)? &} {ptype rS}
+gdb_test {ptype rUS} {type = (unsigned short (int)?|short unsigned (int)?) &} \
+ {ptype rUS}
-send_gdb "ptype rC\n"
-gdb_expect {
- -re "type = char &.*$gdb_prompt $" { pass "ptype rC" }
- -re ".*$gdb_prompt $" { fail "ptype rC" }
- timeout { fail "(timeout) ptype rC" }
-}
+gdb_test_exact {ptype rI} {type = int &} {ptype rI}
+gdb_test_exact {ptype rUI} {type = unsigned int &} {ptype rUI}
+gdb_test {ptype rL} {type = long (int)? &} {ptype rL}
+gdb_test {ptype rUL} {type = (unsigned long (int)?)|(long unsigned (int)?) &} \
+ {ptype rUL}
-send_gdb "ptype rUC\n"
-gdb_expect {
- -re "type = unsigned char &.*$gdb_prompt $" { pass "ptype rUC" }
- -re ".*$gdb_prompt $" { fail "ptype rUC" }
- timeout { fail "(timeout) ptype rUC" }
-}
+gdb_test_exact {ptype rF} {type = float &} {ptype rF}
+gdb_test_exact {ptype rD} {type = double &} {ptype rD}
+set pattern {.[0-9]* = \(char &\) @}
+append pattern "$hex: 65 'A'"
+gdb_test {print rC} $pattern {print value of rC}
-send_gdb "ptype rS\n"
-gdb_expect {
- -re "type = short &.*$gdb_prompt $" { pass "ptype rS" }
- -re "type = short int &.*$gdb_prompt $" { pass "ptype rS" }
- -re ".*$gdb_prompt $" { fail "ptype rS" }
- timeout { fail "(timeout) ptype rS" }
-}
+set pattern {.[0-9]* = \(unsigned char &\) @}
+append pattern $hex {: 21 '\\025'}
+gdb_test {print rUC} $pattern {print value of rUC}
+set pattern {.[0-9]* = \(short (int)? &\) @}
+append pattern "$hex: -14"
+gdb_test {print rS} $pattern {print value of rS}
+set pattern {.[0-9]* = \((unsigned short (int)?|short unsigned (int)?) &\) @}
+append pattern "$hex: 7"
+gdb_test {print rUS} $pattern {print value of rUS}
-send_gdb "ptype rUS\n"
-gdb_expect {
- -re "type = unsigned short &.*$gdb_prompt $" { pass "ptype rUS" }
- -re "type = short unsigned int &.*$gdb_prompt $" { pass "ptype rUS" }
- -re ".*$gdb_prompt $" { fail "ptype rUS" }
- timeout { fail "(timeout) ptype rUS" }
-}
+set pattern {.[0-9]* = \(int &\) @}
+append pattern "$hex: 102"
+gdb_test {print rI} $pattern {print value of rI}
+set pattern {.[0-9]* = \(unsigned int &\) @}
+append pattern "$hex: 1002"
+gdb_test {print rUI} $pattern {print value of UI}
-send_gdb "ptype rI\n"
-gdb_expect {
- -re "type = int &.*$gdb_prompt $" { pass "ptype rI" }
- -re ".*$gdb_prompt $" { fail "ptype rI" }
- timeout { fail "(timeout) ptype rI" }
-}
-
-
-
-send_gdb "ptype rUI\n"
-gdb_expect {
- -re "type = unsigned int &.*$gdb_prompt $" { pass "ptype rUI" }
- -re ".*$gdb_prompt $" { fail "ptype rUI" }
- timeout { fail "(timeout) ptype rUI" }
-}
+set pattern {.[1-9]* = \(long (int)? &\) @}
+append pattern "$hex: -234"
+gdb_test {print rL} $pattern "print value of rL"
+set pattern {.[0-9]* = \((unsigned long|long unsigned int) &\) @}
+append pattern "$hex: 234"
+gdb_test {print rUL} $pattern {print value of rUL}
+set pattern {.[0-9]* = \(float &\) @}
+append pattern "$hex: 1.2" {[0-9]*e\+10}
+gdb_test {print rF} $pattern {print value of rF}
-send_gdb "ptype rL\n"
-gdb_expect {
- -re "type = long &.*$gdb_prompt $" { pass "ptype rL" }
- -re "type = long int &.*$gdb_prompt $" { pass "ptype rL" }
- -re ".*$gdb_prompt $" { fail "ptype rL" }
- timeout { fail "(timeout) ptype rL" }
-}
-
-
-send_gdb "ptype rUL\n"
-gdb_expect {
- -re "type = unsigned long &.*$gdb_prompt $" { pass "ptype rUL" }
- -re "type = long unsigned int &.*$gdb_prompt $" { pass "ptype rUL" }
- -re ".*$gdb_prompt $" { fail "ptype rUL" }
- timeout { fail "(timeout) ptype rUL" }
-}
-
-
-send_gdb "ptype rF\n"
-gdb_expect {
- -re "type = float &.*$gdb_prompt $" { pass "ptype rF" }
- -re ".*$gdb_prompt $" { fail "ptype rF" }
- timeout { fail "(timeout) ptype rF" }
-}
-
-
-send_gdb "ptype rD\n"
-gdb_expect {
- -re "type = double &.*$gdb_prompt $" { pass "ptype rD" }
- -re ".*$gdb_prompt $" { fail "ptype rD" }
- timeout { fail "(timeout) ptype rD" }
-}
-
-
-send_gdb "print rC\n"
-gdb_expect {
- -re ".\[0-9\]* = \\(char &\\) @$hex: 65 \'A\'.*$gdb_prompt $" {
- pass "print value of rC"
- }
- -re ".*$gdb_prompt $" { fail "print value of rC" }
- timeout { fail "(timeout) print value of rC" }
- }
-
-
-send_gdb "print rUC\n"
-gdb_expect {
- -re ".\[0-9\]* = \\(unsigned char &\\) @$hex: 21 \'.025\'.*$gdb_prompt $" {
- pass "print value of rUC"
- }
- -re ".*$gdb_prompt $" { fail "print value of rUC" }
- timeout { fail "(timeout) print value of rUC" }
- }
-
-
-send_gdb "print rS\n"
-gdb_expect {
- -re ".\[0-9\]* = \\(short &\\) @$hex: -14.*$gdb_prompt $" {
- pass "print value of rS"
- }
- -re ".\[0-9\]* = \\(short int &\\) @$hex: -14.*$gdb_prompt $" {
- pass "print value of rS"
- }
- -re ".*$gdb_prompt $" { fail "print value of rS" }
- timeout { fail "(timeout) print value of rS" }
- }
-
-
-send_gdb "print rUS\n"
-gdb_expect {
- -re ".\[0-9\]* = \\(unsigned short &\\) @$hex: 7.*$gdb_prompt $" {
- pass "print value of rUS"
- }
- -re ".\[0-9\]* = \\(short unsigned int &\\) @$hex: 7.*$gdb_prompt $" {
- pass "print value of rUS"
- }
- -re ".*$gdb_prompt $" { fail "print value of rUS" }
- timeout { fail "(timeout) print value of rUS" }
- }
-
-
-send_gdb "print rI\n"
-gdb_expect {
- -re ".\[0-9\]* = \\(int &\\) @$hex: 102.*$gdb_prompt $" {
- pass "print value of rI"
- }
- -re ".*$gdb_prompt $" { fail "print value of rI" }
- timeout { fail "(timeout) print value of rI" }
- }
-
-
-send_gdb "print rUI\n"
-gdb_expect {
- -re ".\[0-9\]* = \\(unsigned int &\\) @$hex: 1002.*$gdb_prompt $" {
- pass "print value of UI"
- }
- -re ".*$gdb_prompt $" { fail "print value of rUI" }
- timeout { fail "(timeout) print value of rUI" }
- }
-
-
-send_gdb "print rL\n"
-gdb_expect {
- -re ".\[0-9\]* = \\(long &\\) @$hex: -234.*$gdb_prompt $" {
- pass "print value of rL"
- }
- -re ".\[0-9\]* = \\(long int &\\) @$hex: -234.*$gdb_prompt $" {
- pass "print value of rL"
- }
- -re ".*$gdb_prompt $" { fail "print value of rL" }
- timeout { fail "(timeout) print value of rL" }
- }
-
-
-
-send_gdb "print rUL\n"
-gdb_expect {
- -re ".\[0-9\]* = \\(unsigned long &\\) @$hex: 234.*$gdb_prompt $" {
- pass "print value of rUL"
- }
- -re ".\[0-9\]* = \\(long unsigned int &\\) @$hex: 234.*$gdb_prompt $" {
- pass "print value of rUL"
- }
- -re ".*$gdb_prompt $" { fail "print value of rUL" }
- timeout { fail "(timeout) print value of rUL" }
- }
-
-
-send_gdb "print rF\n"
-gdb_expect {
- -re ".\[0-9\]* = \\(float &\\) @$hex: 1.2\[0-9\]*e\\+10.*$gdb_prompt $" {
- pass "print value of rF"
- }
- -re ".*$gdb_prompt $" { fail "print value of rF" }
- timeout { fail "(timeout) print value of rF" }
- }
-
-
-send_gdb "print rD\n"
-gdb_expect {
- -re ".\[0-9\]* = \\(double &\\) @$hex: -1.375e-123.*$gdb_prompt $" {
- pass "print value of rD"
- }
- -re ".*$gdb_prompt $" { fail "print value of rD" }
- timeout { fail "(timeout) print value of rD" }
- }
+set pattern {.[0-9]* = \(double &\) @}
+append pattern "$hex: -1.375e-123"
+gdb_test {print rD} $pattern {print value of rD}