This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

[RFC/A] testsuite/gdb.c++/ref-types.exp "cleanup"


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}




Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]