@@ -60,7 +60,7 @@ gdb_test_multiple "print v_int+=57" "v_int+=57" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (2)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 2"
gdb_test_multiple "print v_int-=57" "v_int-=57" {
-re " = -51.*$gdb_prompt $" {
@@ -68,7 +68,7 @@ gdb_test_multiple "print v_int-=57" "v_int-=57" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (3)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 3"
gdb_test_multiple "print v_int*=5" "v_int*=5" {
-re " = 30.*$gdb_prompt $" {
@@ -76,7 +76,7 @@ gdb_test_multiple "print v_int*=5" "v_int*=5" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (4)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 4"
gdb_test_multiple "print v_int/=4" "v_int/=4" {
-re " = 1.*$gdb_prompt $" {
@@ -84,7 +84,7 @@ gdb_test_multiple "print v_int/=4" "v_int/=4" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (5)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 5"
gdb_test_multiple "print v_int%=4" "v_int%=4" {
-re " = 2.*$gdb_prompt $" {
@@ -92,7 +92,7 @@ gdb_test_multiple "print v_int%=4" "v_int%=4" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (6)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 6"
gdb_test_multiple "print v_int+=v_char" "v_int+=char" {
-re " = 71.*$gdb_prompt $" {
@@ -100,7 +100,7 @@ gdb_test_multiple "print v_int+=v_char" "v_int+=char" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (7)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 7"
gdb_test_multiple "print v_int+=v_signed_char" "v_int+=signed_char" {
-re " = 72.*$gdb_prompt $" {
@@ -108,7 +108,7 @@ gdb_test_multiple "print v_int+=v_signed_char" "v_int+=signed_char" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (8)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 8"
gdb_test_multiple "print v_int+=v_unsigned_char" "v_int+=unsigned_char" {
-re " = 73.*$gdb_prompt $" {
@@ -116,7 +116,7 @@ gdb_test_multiple "print v_int+=v_unsigned_char" "v_int+=unsigned_char" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (9)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 9"
gdb_test_multiple "print v_int+=v_short" "v_int+=short" {
-re " = 9.*$gdb_prompt $" {
@@ -124,7 +124,7 @@ gdb_test_multiple "print v_int+=v_short" "v_int+=short" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (10)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 10"
gdb_test_multiple "print v_int+=v_signed_short" "v_int+=signed_short" {
-re " = 10.*$gdb_prompt $" {
@@ -132,7 +132,7 @@ gdb_test_multiple "print v_int+=v_signed_short" "v_int+=signed_short" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (11)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 11"
gdb_test_multiple "print v_int+=v_unsigned_short" "v_int=+unsigned_short" {
-re " = 11.*$gdb_prompt $" {
@@ -140,7 +140,7 @@ gdb_test_multiple "print v_int+=v_unsigned_short" "v_int=+unsigned_short" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (12)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 12"
gdb_test_multiple "print v_int+=v_signed_int" "v_int+=signed_int" {
-re " = 13.*$gdb_prompt $" {
@@ -148,7 +148,7 @@ gdb_test_multiple "print v_int+=v_signed_int" "v_int+=signed_int" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (13)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 13"
gdb_test_multiple "print v_int+=v_unsigned_int" "v_int+=unsigned_int" {
-re " = 14.*$gdb_prompt $" {
@@ -156,7 +156,7 @@ gdb_test_multiple "print v_int+=v_unsigned_int" "v_int+=unsigned_int" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (14)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 14"
gdb_test_multiple "print v_int+=v_long" "v_int+=long" {
-re " = 15.*$gdb_prompt $" {
@@ -164,7 +164,7 @@ gdb_test_multiple "print v_int+=v_long" "v_int+=long" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (15)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 15"
gdb_test_multiple "print v_int+=v_signed_long" "v_int+=signed_long" {
-re " = 16.*$gdb_prompt $" {
@@ -172,7 +172,7 @@ gdb_test_multiple "print v_int+=v_signed_long" "v_int+=signed_long" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (16)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 16"
gdb_test_multiple "print v_int+=v_unsigned_long" "v_int+=unsigned_long" {
-re " = 17.*$gdb_prompt $" {
@@ -180,7 +180,7 @@ gdb_test_multiple "print v_int+=v_unsigned_long" "v_int+=unsigned_long" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (17)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 17"
gdb_test_multiple "print v_int+=v_float" "v_int+=v_float" {
-re " = 106.*$gdb_prompt $" {
@@ -188,7 +188,7 @@ gdb_test_multiple "print v_int+=v_float" "v_int+=v_float" {
}
}
-gdb_test_no_output "set variable v_int = 6" "set v_int to 6 (18)"
+gdb_test_no_output "set variable v_int = 6" "set v_int to 6, 18"
gdb_test_multiple "print v_int+=v_double" "v_int+=double" {
-re " = 206.*$gdb_prompt $" {
@@ -45,23 +45,23 @@ proc bitfield_uniqueness {} {
# treat it correctly as a signed 1bit field (values 0 or -1) while
# printing its value does not cause a spurious failure. We do the
# signedness preservation test later.
- gdb_test "print flags" ".*uc = 0 .*, s1 = (1|-1), u1 = 0, s2 = 0, u2 = 0, s3 = 0, u3 = 0, s9 = 0, u9 = 0, sc = 0.*" "bitfield uniqueness (s1)"
+ gdb_test "print flags" ".*uc = 0 .*, s1 = (1|-1), u1 = 0, s2 = 0, u2 = 0, s3 = 0, u3 = 0, s9 = 0, u9 = 0, sc = 0.*" "bitfield uniqueness, s1"
gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #2"
- gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 1, s2 = 0, u2 = 0, s3 = 0, u3 = 0, s9 = 0, u9 = 0, sc = 0.*" "bitfield uniqueness (u1)"
+ gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 1, s2 = 0, u2 = 0, s3 = 0, u3 = 0, s9 = 0, u9 = 0, sc = 0.*" "bitfield uniqueness, u1"
gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #3"
- gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 1, u2 = 0, s3 = 0, u3 = 0, s9 = 0, u9 = 0, sc = 0.*" "bitfield uniqueness (s2)"
+ gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 1, u2 = 0, s3 = 0, u3 = 0, s9 = 0, u9 = 0, sc = 0.*" "bitfield uniqueness, s2"
gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #4"
- gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 0, u2 = 1, s3 = 0, u3 = 0, s9 = 0, u9 = 0, sc = 0.*" "bitfield uniqueness (u2)"
+ gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 0, u2 = 1, s3 = 0, u3 = 0, s9 = 0, u9 = 0, sc = 0.*" "bitfield uniqueness, u2"
gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #5"
- gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 0, u2 = 0, s3 = 1, u3 = 0, s9 = 0, u9 = 0, sc = 0.*" "bitfield uniqueness (s3)"
+ gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 0, u2 = 0, s3 = 1, u3 = 0, s9 = 0, u9 = 0, sc = 0.*" "bitfield uniqueness, s3"
gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #6"
- gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 0, u2 = 0, s3 = 0, u3 = 1, s9 = 0, u9 = 0, sc = 0.*" "bitfield uniqueness (u3)"
+ gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 0, u2 = 0, s3 = 0, u3 = 1, s9 = 0, u9 = 0, sc = 0.*" "bitfield uniqueness, u3"
gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #7"
- gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 0, u2 = 0, s3 = 0, u3 = 0, s9 = 1, u9 = 0, sc = 0.*" "bitfield uniqueness (s9)"
+ gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 0, u2 = 0, s3 = 0, u3 = 0, s9 = 1, u9 = 0, sc = 0.*" "bitfield uniqueness, s9"
gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #8"
- gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 0, u2 = 0, s3 = 0, u3 = 0, s9 = 0, u9 = 1, sc = 0.*" "bitfield uniqueness (u9)"
+ gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 0, u2 = 0, s3 = 0, u3 = 0, s9 = 0, u9 = 1, sc = 0.*" "bitfield uniqueness, u9"
gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #9"
- gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 0, u2 = 0, s3 = 0, u3 = 0, s9 = 0, u9 = 0, sc = 1.*" "bitfield uniqueness (sc)"
+ gdb_test "print flags" ".*uc = 0 .*, s1 = 0, u1 = 0, s2 = 0, u2 = 0, s3 = 0, u3 = 0, s9 = 0, u9 = 0, sc = 1.*" "bitfield uniqueness, sc"
}
@@ -171,7 +171,7 @@ proc insert_catch_syscall_with_arg { syscall } {
global decimal
# Trying to set the catchpoint
- set thistest "catch syscall with arguments ($syscall)"
+ set thistest "catch syscall with arguments, $syscall"
gdb_test "catch syscall $syscall" "Catchpoint $decimal \\(syscall \'?${syscall}\'?( \[${decimal}\])?\\)" $thistest
check_info_bp_specific_syscall $syscall
@@ -543,10 +543,10 @@ gdb_test_multiple "" "$test" {
# Eat the prompt
gdb_expect {
-re "$gdb_prompt " {
- pass "$test (eat prompt)"
+ pass "$test, eat prompt"
}
timeout {
- fail "(timeout) $test (eat prompt)"
+ fail "$test, eat prompt (timeout)"
}
}
@@ -572,10 +572,10 @@ gdb_test_multiple "" "$test" {
# Eat the prompt
gdb_expect {
-re "$gdb_prompt " {
- pass "$test (eat prompt)"
+ pass "$test, eat prompt"
}
timeout {
- fail "(timeout) $test (eat prompt)"
+ fail "$test, eat prompt (timeout)"
}
}
@@ -47,22 +47,22 @@ if {![runto_main]} {
}
gdb_test "print (2 ? 3 : 4)" "\[0-9\]* = 3" \
- "print value of cond expr (const true)"
+ "print value of cond expr, const true"
gdb_test "print (0 ? 3 : 4)" "\[0-9\]* = 4" \
- "print value of cond expr (const false)"
+ "print value of cond expr, const false"
gdb_test_no_output "set variable x=14" "set variable x=14"
gdb_test_no_output "set variable y=2" "set variable y=2"
gdb_test_no_output "set variable z=3" "set variable z=3"
gdb_test "print (x ? y : z)" "\[0-9\]* = 2" \
- "print value of cond expr (var true)"
+ "print value of cond expr, var true"
gdb_test_no_output "set variable x=0" "set variable x=0"
gdb_test "print (x ? y : z)" "\[0-9\]* = 3" \
- "print value of cond expr (var false)"
+ "print value of cond expr, var false"
gdb_test "whatis (0 ? 3 : 4)" "type = int" \
"print whatis of cond expr"
@@ -195,7 +195,7 @@ gdb_test "x/wx buf3" "$hex:\[ \t\]+0x00000000" \
# test reinit_frame_cache
gdb_load ${binfile}
-gdb_test "up" "#\[0-9\]* *(\[0-9xa-fH'\]* in)? .* \\(.*\\).*" "up (reinit)"
+gdb_test "up" "#\[0-9\]* *(\[0-9xa-fH'\]* in)? .* \\(.*\\).*" "up, reinit"
gdb_test "core" "No core file now."
@@ -47,55 +47,55 @@ proc do_test {dir options} {
gdb_test "whatis (const char) v_char" \
"type = const char" \
- "(const char)"
+ "cast to const char"
gdb_test "whatis (const signed char) v_signed_char" \
"type = const signed char" \
- "(const signed char)"
+ "cast to const signed char"
gdb_test "whatis (const unsigned char) v_unsigned_char" \
"type = const (unsigned char|char)" \
- "(const unsigned char)"
+ "cast to const unsigned char"
gdb_test "whatis (const short) v_short" \
"type = const (short|short int)" \
- "(const short)"
+ "cast to const short"
gdb_test "whatis (const signed short) v_signed_short" \
"type = const (short|short int|signed short|signed short int)" \
- "(const signed short)"
+ "cast to const signed short"
gdb_test "whatis (const unsigned short) v_unsigned_short" \
"type = const (unsigned short|short unsigned int)" \
- "(const unsigned short)"
+ "cast to const unsigned short"
gdb_test "whatis (const int) v_int" \
"type = const int" \
- "(const int)"
+ "cast to const int"
gdb_test "whatis (const signed int) v_signed_int" \
"type = const (signed int|int)" \
- "(const signed int)"
+ "cast to const signed int"
gdb_test "whatis (const unsigned int) v_unsigned_int" \
"type = const unsigned int" \
- "(const unsigned int)"
+ "cast to const unsigned int"
gdb_test "whatis (const long) v_long" \
"type = const (long|long int)" \
- "(const long)"
+ "cast to const long"
gdb_test "whatis (const signed long) v_signed_long" \
"type = const (signed |)long( int|)" \
- "(const signed long)"
+ "cast to const signed long"
gdb_test "whatis (const unsigned long) v_unsigned_long" \
"type = const (unsigned long|long unsigned int)" \
- "(const unsigned long)"
+ "cast to const unsigned long"
gdb_test "whatis (const long long) v_long_long" \
"type = const long long( int|)" \
- "(const long long)"
+ "cast to const long long"
gdb_test "whatis (const signed long long) v_signed_long_long" \
"type = const (signed |)long long( int|)" \
- "(const signed long long)"
+ "cast to const signed long long"
gdb_test "whatis (const unsigned long long) v_unsigned_long_long" \
"type = const (unsigned long long|long long unsigned int)" \
- "(const unsigned long long)"
+ "cast to const unsigned long long"
gdb_test "whatis (const float) v_float" \
"type = const float" \
- "(const float)"
+ "cast to const float"
gdb_test "whatis (const double) v_double" \
"type = const double" \
- "(const double)"
+ "cast to const double"
#
# Test casting a scalar to volatile
@@ -103,55 +103,55 @@ proc do_test {dir options} {
gdb_test "whatis (volatile char) v_char" \
"type = volatile char" \
- "(volatile char)"
+ "cast to volatile char"
gdb_test "whatis (volatile signed char) v_signed_char" \
"type = volatile signed char" \
- "(volatile signed char)"
+ "cast to volatile signed char"
gdb_test "whatis (volatile unsigned char) v_unsigned_char" \
"type = volatile (unsigned char|char)" \
- "(volatile unsigned char)"
+ "cast to volatile unsigned char"
gdb_test "whatis (volatile short) v_short" \
"type = volatile (short|short int)" \
- "(volatile short)"
+ "cast to volatile short"
gdb_test "whatis (volatile signed short) v_signed_short" \
"type = volatile (short|short int|signed short|signed short int)" \
- "(volatile signed short)"
+ "cast to volatile signed short"
gdb_test "whatis (volatile unsigned short) v_unsigned_short" \
"type = volatile (unsigned short|short unsigned int)" \
- "(volatile unsigned short)"
+ "cast to volatile unsigned short"
gdb_test "whatis (volatile int) v_int" \
"type = volatile int" \
- "(volatile int)"
+ "cast to volatile int"
gdb_test "whatis (volatile signed int) v_signed_int" \
"type = volatile (signed int|int)" \
- "(volatile signed int)"
+ "cast to volatile signed int"
gdb_test "whatis (volatile unsigned int) v_unsigned_int" \
"type = volatile unsigned int" \
- "(volatile unsigned int)"
+ "cast to volatile unsigned int"
gdb_test "whatis (volatile long) v_long" \
"type = volatile (long|long int)" \
- "(volatile long)"
+ "cast to volatile long"
gdb_test "whatis (volatile signed long) v_signed_long" \
"type = volatile (signed |)long( int|)" \
- "(volatile signed long)"
+ "cast to volatile signed long"
gdb_test "whatis (volatile unsigned long) v_unsigned_long" \
"type = volatile (unsigned long|long unsigned int)" \
- "(volatile unsigned long)"
+ "cast to volatile unsigned long"
gdb_test "whatis (volatile long long) v_long_long" \
"type = volatile long long( int|)" \
- "(volatile long long)"
+ "cast to volatile long long"
gdb_test "whatis (volatile signed long long) v_signed_long_long" \
"type = volatile (signed |)long long( int|)" \
- "(volatile signed long long)"
+ "cast to volatile signed long long"
gdb_test "whatis (volatile unsigned long long) v_unsigned_long_long" \
"type = volatile (unsigned long long|long long unsigned int)" \
- "(volatile unsigned long long)"
+ "cast to volatile unsigned long long"
gdb_test "whatis (volatile float) v_float" \
"type = volatile float" \
- "(volatile float)"
+ "cast to volatile float"
gdb_test "whatis (volatile double) v_double" \
"type = volatile double" \
- "(volatile double)"
+ "cast to volatile double"
#
# Combine const and volatile
@@ -159,47 +159,47 @@ proc do_test {dir options} {
gdb_test "whatis (const volatile int) v_int" \
"type = const volatile int" \
- "(const volatile int)"
+ "cast to const volatile int"
gdb_test "whatis (volatile const int) v_int" \
"type = const volatile int" \
- "(volatile const int)"
+ "cast to volatile const int"
gdb_test "whatis (const int volatile) v_int" \
"type = const volatile int" \
- "(const int volatile)"
+ "cast to const int volatile"
gdb_test "whatis (volatile int const) v_int" \
"type = const volatile int" \
- "(volatile int const)"
+ "cast to volatile int const"
gdb_test "whatis (int const volatile) v_int" \
"type = const volatile int" \
- "(int const volatile)"
+ "cast to int const volatile"
gdb_test "whatis (int volatile const) v_int" \
"type = const volatile int" \
- "(int volatile const)"
+ "cast to int volatile const"
gdb_test "whatis (const volatile int *) v_int_pointer" \
"type = const volatile int${ws}\\*" \
- "(const volatile int *)"
+ "cast to const volatile int *"
gdb_test "whatis (volatile const int *) v_int_pointer" \
"type = const volatile int${ws}\\*" \
- "(volatile const int *)"
+ "cast to volatile const int *"
gdb_test "whatis (const int volatile *) v_int_pointer" \
"type = const volatile int${ws}\\*" \
- "(const int volatile *)"
+ "cast to const int volatile *"
gdb_test "whatis (volatile int const *) v_int_pointer" \
"type = const volatile int${ws}\\*" \
- "(volatile int const *)"
+ "cast to volatile int const *"
gdb_test "whatis (int const volatile *) v_int_pointer" \
"type = const volatile int${ws}\\*" \
- "(int const volatile *)"
+ "cast to int const volatile *"
gdb_test "whatis (int volatile const *) v_int_pointer" \
"type = const volatile int${ws}\\*" \
- "(int volatile const *)"
+ "cast to int volatile const *"
gdb_test "whatis (int * const volatile) v_int_pointer" \
"type = int${ws}\\*${ws}const volatile" \
- "(int * const volatile)"
+ "cast to int * const volatile"
gdb_test "whatis (int * volatile const) v_int_pointer" \
"type = int${ws}\\*${ws}const volatile" \
- "(int * volatile const)"
+ "cast to int * volatile const"
#
@@ -208,65 +208,65 @@ proc do_test {dir options} {
#gdb_test "whatis (signed const char) v_signed_char" \
# "type = const char" \
- # "(signed const char)"
+ # "cast to signed const char"
#gdb_test "whatis (unsigned const char) v_unsigned_char" \
# "type = const (unsigned char|char)" \
- # "(unsigned const char)"
+ # "cast to unsigned const char"
#gdb_test "whatis (signed const short) v_signed_short" \
# "type = const (short|short int|signed short|signed short int)" \
- # "(signed const short)"
+ # "cast to signed const short"
#gdb_test "whatis (unsigned const short) v_unsigned_short" \
# "type = const (unsigned short|short unsigned int)" \
- # "(unsigned const short)"
+ # "cast to unsigned const short"
#gdb_test "whatis (signed const int) v_signed_int" \
# "type = const (signed int|int)" \
- # "(signed const int)"
+ # "cast to signed const int"
#gdb_test "whatis (unsigned const int) v_unsigned_int" \
# "type = const unsigned int" \
- # "(unsigned const int)"
+ # "cast to unsigned const int"
#gdb_test "whatis (signed const long) v_signed_long" \
# "type = const (signed |)long( int|)" \
- # "(signed const long)"
+ # "cast to signed const long"
#gdb_test "whatis (unsigned const long) v_unsigned_long" \
# "type = const (unsigned long|long unsigned int)" \
- # "(unsigned const long)"
+ # "cast to unsigned const long"
#gdb_test "whatis (signed const long long) v_signed_long_long" \
# "type = const (signed |)long long( int|)" \
- # "(signed const long long)"
+ # "cast to signed const long long"
#gdb_test "whatis (unsigned const long long) v_unsigned_long_long" \
# "type = const (unsigned long long|long long unsigned int)" \
- # "(const unsigned long long)"
+ # "cast to const unsigned long long"
#gdb_test "whatis (signed volatile char) v_signed_char" \
# "type = volatile char" \
- # "(signed volatile char)"
+ # "cast to signed volatile char"
#gdb_test "whatis (unsigned volatile char) v_unsigned_char" \
# "type = volatile (unsigned char|char)" \
- # "(unsigned volatile char)"
+ # "cast to unsigned volatile char"
#gdb_test "whatis (signed volatile short) v_signed_short" \
# "type = volatile (short|short int|signed short|signed short int)" \
- # "(signed volatile short)"
+ # "cast to signed volatile short"
#gdb_test "whatis (unsigned volatile short) v_unsigned_short" \
# "type = volatile (unsigned short|short unsigned int)" \
- # "(unsigned volatile short)"
+ # "cast to unsigned volatile short"
#gdb_test "whatis (signed volatile int) v_signed_int" \
# "type = volatile (signed int|int)" \
- # "(signed volatile int)"
+ # "cast to signed volatile int"
#gdb_test "whatis (unsigned volatile int) v_unsigned_int" \
# "type = volatile unsigned int" \
- # "(unsigned volatile int)"
+ # "cast to unsigned volatile int"
#gdb_test "whatis (signed volatile long) v_signed_long" \
# "type = volatile (signed |)long( int|)" \
- # "(signed volatile long)"
+ # "cast to signed volatile long"
#gdb_test "whatis (unsigned volatile long) v_unsigned_long" \
# "type = volatile (unsigned long|long unsigned int)" \
- # "(unsigned volatile long)"
+ # "cast to unsigned volatile long"
#gdb_test "whatis (signed volatile long long) v_signed_long_long" \
# "type = volatile (signed |)long long( int|)" \
- # "(signed volatile long long)"
+ # "cast to signed volatile long long"
#gdb_test "whatis (unsigned volatile long long) v_unsigned_long_long" \
# "type = volatile (unsigned long long|long long unsigned int)" \
- # "(unsigned volatile long long)"
+ # "cast to unsigned volatile long long"
#
# Now put the 'const' and 'volatile' keywords after the base type.
@@ -274,107 +274,107 @@ proc do_test {dir options} {
gdb_test "whatis (char const) v_char" \
"type = const char" \
- "(char const)"
+ "cast to char const"
gdb_test "whatis (signed char const) v_signed_char" \
"type = const signed char" \
- "(signed char const)"
+ "cast to signed char const"
gdb_test "whatis (unsigned char const) v_unsigned_char" \
"type = const (unsigned char|char)" \
- "(unsigned char const)"
+ "cast to unsigned char const"
gdb_test "whatis (short const) v_short" \
"type = const (short|short int)" \
- "(short const)"
+ "cast to short const"
gdb_test "whatis (signed short const) v_signed_short" \
"type = const (short|short int|signed short|signed short int)" \
- "(signed short const)"
+ "cast to signed short const"
gdb_test "whatis (unsigned short const) v_unsigned_short" \
"type = const (unsigned short|short unsigned int)" \
- "(unsigned short const)"
+ "cast to unsigned short const"
gdb_test "whatis (int const) v_int" \
"type = const int" \
- "(int const)"
+ "cast to int const"
gdb_test "whatis (signed int const) v_signed_int" \
"type = const (signed int|int)" \
- "(signed int const)"
+ "cast to signed int const"
gdb_test "whatis (unsigned int const) v_unsigned_int" \
"type = const unsigned int" \
- "(unsigned int const)"
+ "cast to unsigned int const"
gdb_test "whatis (long const) v_long" \
"type = const (long|long int)" \
- "(long const)"
+ "cast to long const"
gdb_test "whatis (signed long const) v_signed_long" \
"type = const (signed |)long( int|)" \
- "(signed long const)"
+ "cast to signed long const"
gdb_test "whatis (unsigned long const) v_unsigned_long" \
"type = const (unsigned long|long unsigned int)" \
- "(unsigned long const)"
+ "cast to unsigned long const"
gdb_test "whatis (long long const) v_long_long" \
"type = const long long( int|)" \
- "(long long const)"
+ "cast to long long const"
gdb_test "whatis (signed long long const) v_signed_long_long" \
"type = const (signed |)long long( int|)" \
- "(signed long long const)"
+ "cast to signed long long const"
gdb_test "whatis (unsigned long long const) v_unsigned_long_long" \
"type = const (unsigned long long|long long unsigned int)" \
- "(unsigned long long const)"
+ "cast to unsigned long long const"
gdb_test "whatis (float const) v_float" \
"type = const float" \
- "(float const)"
+ "cast to float const"
gdb_test "whatis (double const) v_double" \
"type = const double" \
- "(double const)"
+ "cast to double const"
gdb_test "whatis (char volatile) v_char" \
"type = volatile char" \
- "(char volatile)"
+ "cast to char volatile"
gdb_test "whatis (signed char volatile) v_signed_char" \
"type = volatile signed char" \
- "(signed char volatile)"
+ "cast to signed char volatile"
gdb_test "whatis (unsigned char volatile) v_unsigned_char" \
"type = volatile (unsigned char|char)" \
- "(unsigned char volatile)"
+ "cast to unsigned char volatile"
gdb_test "whatis (short volatile) v_short" \
"type = volatile (short|short int)" \
- "(short volatile)"
+ "cast to short volatile"
gdb_test "whatis (signed short volatile) v_signed_short" \
"type = volatile (short|short int|signed short|signed short int)" \
- "(signed short volatile)"
+ "cast to signed short volatile"
gdb_test "whatis (unsigned short volatile) v_unsigned_short" \
"type = volatile (unsigned short|short unsigned int)" \
- "(unsigned short volatile)"
+ "cast to unsigned short volatile"
gdb_test "whatis (int volatile) v_int" \
"type = volatile int" \
- "(int volatile)"
+ "cast to int volatile"
gdb_test "whatis (signed int volatile) v_signed_int" \
"type = volatile (signed int|int)" \
- "(signed int volatile)"
+ "cast to signed int volatile"
gdb_test "whatis (unsigned int volatile) v_unsigned_int" \
"type = volatile unsigned int" \
- "(unsigned int volatile)"
+ "cast to unsigned int volatile"
gdb_test "whatis (long volatile) v_long" \
"type = volatile (long|long int)" \
- "(long volatile)"
+ "cast to long volatile"
gdb_test "whatis (signed long volatile) v_signed_long" \
"type = volatile (signed |)long( int|)" \
- "(signed long volatile)"
+ "cast to signed long volatile"
gdb_test "whatis (unsigned long volatile) v_unsigned_long" \
"type = volatile (unsigned long|long unsigned int)" \
- "(unsigned long volatile)"
+ "cast to unsigned long volatile"
gdb_test "whatis (long long volatile) v_long_long" \
"type = volatile long long( int|)" \
- "(long long volatile)"
+ "cast to long long volatile"
gdb_test "whatis (signed long long volatile) v_signed_long_long" \
"type = volatile (signed |)long long( int|)" \
- "(signed long long volatile)"
+ "cast to signed long long volatile"
gdb_test "whatis (unsigned long long volatile) v_unsigned_long_long" \
"type = volatile (unsigned long long|long long unsigned int)" \
- "(unsigned long long volatile)"
+ "cast to unsigned long long volatile"
gdb_test "whatis (float volatile) v_float" \
"type = volatile float" \
- "(float volatile)"
+ "cast to float volatile"
gdb_test "whatis (double volatile) v_double" \
"type = volatile double" \
- "(double volatile)"
+ "cast to double volatile"
#
# enums
@@ -382,16 +382,16 @@ proc do_test {dir options} {
gdb_test "whatis (const enum misordered) v_misordered" \
"type = const enum misordered" \
- "(const enum misordered)"
+ "cast to const enum misordered"
gdb_test "whatis (enum misordered const) v_misordered" \
"type = const enum misordered" \
- "(enum misordered const)"
+ "cast to enum misordered const"
gdb_test "whatis (volatile enum misordered) v_misordered" \
"type = volatile enum misordered" \
- "(volatile enum misordered)"
+ "cast to volatile enum misordered"
gdb_test "whatis (enum misordered volatile) v_misordered" \
"type = volatile enum misordered" \
- "(enum misordered volatile)"
+ "cast to enum misordered volatile"
#
# Pointers
@@ -399,41 +399,41 @@ proc do_test {dir options} {
gdb_test "whatis (const int *) v_int_pointer" \
"type = const int${ws}\\*" \
- "(const int *)"
+ "cast to const int *"
gdb_test "whatis (int const *) v_int_pointer" \
"type = const int${ws}\\*" \
- "(int const *)"
+ "cast to int const *"
gdb_test "whatis (int * const) v_int_pointer" \
"type = int \\*${ws}const" \
- "(int * const)"
+ "cast to int * const"
gdb_test "whatis (const int * const) v_int_pointer" \
"type = const int${ws}\\*${ws}const" \
- "(const int * const)"
+ "cast to const int * const"
gdb_test "whatis (int const * const) v_int_pointer" \
"type = const int${ws}\\*${ws}const" \
- "(int const * const)"
+ "cast to int const * const"
gdb_test "whatis (const int **) v_int_pointer_pointer" \
"type = const int${ws}\\*${ws}\\*" \
- "(const int **)"
+ "cast to const int **"
gdb_test "whatis (int const **) v_int_pointer_pointer" \
"type = const int${ws}\\*${ws}\\*" \
- "(int const **)"
+ "cast to int const **"
gdb_test "whatis (int ** const) v_int_pointer_pointer" \
"type = int \\*${ws}\\*${ws}const" \
- "(int ** const)"
+ "cast to int ** const"
gdb_test "whatis (const int * const *) v_int_pointer_pointer" \
"type = const int${ws}\\*${ws}const${ws}\\*" \
- "(const int * const *)"
+ "cast to const int * const *"
gdb_test "whatis (int const * const *) v_int_pointer_pointer" \
"type = const int${ws}\\*${ws}const${ws}\\*" \
- "(int const * const *)"
+ "cast to int const * const *"
gdb_test "whatis (const int * const * const) v_int_pointer_pointer" \
"type = const int${ws}\\*${ws}const${ws}\\*${ws}const" \
- "(const int * const * const)"
+ "cast to const int * const * const"
gdb_test "whatis (int const * const * const) v_int_pointer_pointer" \
"type = const int${ws}\\*${ws}const${ws}\\*${ws}const" \
- "(int const * const * const)"
+ "cast to int const * const * const"
#
# Arrays TODO
@@ -449,46 +449,46 @@ proc do_test {dir options} {
gdb_test "whatis (const struct t_struct) v_struct1" \
"type = const struct t_struct" \
- "(const struct t_struct)"
+ "cast to const struct t_struct"
gdb_test "whatis (const union t_union) v_union" \
"type = const union t_union" \
- "(const union t_union)"
+ "cast to const union t_union"
gdb_test "whatis (struct t_struct const) v_struct1" \
"type = const struct t_struct" \
- "(struct t_struct const)"
+ "cast to struct t_struct const"
gdb_test "whatis (union t_union const) v_union" \
"type = const union t_union" \
- "(union t_union const)"
+ "cast to union t_union const"
gdb_test "whatis (const struct t_struct *) &v_struct1" \
"type = const struct t_struct${ws}\\*" \
- "(const struct t_struct *)"
+ "cast to const struct t_struct *"
gdb_test "whatis (const union t_union *) &v_union" \
"type = const union t_union${ws}\\*" \
- "(const union t_union *)"
+ "cast to const union t_union *"
gdb_test "whatis (struct t_struct const *) &v_struct1" \
"type = const struct t_struct${ws}\\*" \
- "(struct t_struct const *)"
+ "cast to struct t_struct const *"
gdb_test "whatis (union t_union const *) &v_union" \
"type = const union t_union${ws}\\*" \
- "(union t_union const *)"
+ "cast to union t_union const *"
gdb_test "whatis (struct t_struct * const) &v_struct1" \
"type = struct t_struct${ws}\\*${ws}const" \
- "(struct t_struct * const)"
+ "cast to struct t_struct * const"
gdb_test "whatis (union t_union * const) &v_union" \
"type = union t_union${ws}\\*${ws}const" \
- "(union t_union * const)"
+ "cast to union t_union * const"
gdb_test "whatis (const struct t_struct * const) &v_struct1" \
"type = const struct t_struct${ws}\\*${ws}const" \
- "(const struct t_struct * const)"
+ "cast to const struct t_struct * const"
gdb_test "whatis (const union t_union * const) &v_union" \
"type = const union t_union${ws}\\*${ws}const" \
- "(const union t_union * const)"
+ "cast to const union t_union * const"
gdb_test "whatis (struct t_struct const * const) &v_struct1" \
"type = const struct t_struct${ws}\\*${ws}const" \
- "(struct t_struct const * const)"
+ "cast to struct t_struct const * const"
gdb_test "whatis (union t_union const * const) &v_union" \
"type = const union t_union${ws}\\*${ws}const" \
- "(union t_union const * const)"
+ "cast to union t_union const * const"
#
# Function pointers TODO
@@ -54,86 +54,63 @@ gdb_test_no_output "set variable y=2" "set variable y=2"
gdb_test_no_output "set variable z=2" "set variable z=2"
gdb_test_no_output "set variable w=3" "set variable w=3"
-gdb_test "print (0 && (x+y))" ".$decimal = $false" \
- "print value of (0 && (x+y))"
+proc test { val re } {
+ gdb_test "print $val" $re "print value of $val value"
+}
+
+test "(0 && (x+y))" ".$decimal = $false"
-gdb_test "print (0 && (x-y))" ".$decimal = $false" \
- "print value of (0 && (x-y))"
+test "(0 && (x-y))" ".$decimal = $false"
-gdb_test "print (0 && (x*y))" ".$decimal = $false" \
- "print value of (0 && (x*y))"
+test "(0 && (x*y))" ".$decimal = $false"
-gdb_test "print (0 && (x/y))" ".$decimal = $false" \
- "print value of (0 && (x/y))"
+test "(0 && (x/y))" ".$decimal = $false"
-gdb_test "print (0 && (x%y))" ".$decimal = $false" \
- "print value of (0 && (x%y))"
+test "(0 && (x%y))" ".$decimal = $false"
-gdb_test "print (0 && (x&&y))" ".$decimal = $false" \
- "print value of (0 && (x&&y))"
+test "(0 && (x&&y))" ".$decimal = $false"
-gdb_test "print (0 && (x||y))" ".$decimal = $false" \
- "print value of (0 && (x||y))"
+test "(0 && (x||y))" ".$decimal = $false"
-gdb_test "print (0 && (x&y))" ".$decimal = $false" \
- "print value of (0 && (x&y))"
+test "(0 && (x&y))" ".$decimal = $false"
-gdb_test "print (0 && (x|y))" ".$decimal = $false" \
- "print value of (0 && (x|y))"
+test "(0 && (x|y))" ".$decimal = $false"
-gdb_test "print (0 && (x^y))" ".$decimal = $false" \
- "print value of (0 && (x^y))"
+test "(0 && (x^y))" ".$decimal = $false"
-gdb_test "print (0 && (x < y))" ".$decimal = $false" \
- "print value of (0 && (x < y))"
+test "(0 && (x < y))" ".$decimal = $false"
-gdb_test "print (0 && (x <= y))" ".$decimal = $false" \
- "print value of (0 && (x <= y))"
+test "(0 && (x <= y))" ".$decimal = $false"
-gdb_test "print (0 && (x>y))" ".$decimal = $false" \
- "print value of (0 && (x>y))"
+test "(0 && (x>y))" ".$decimal = $false"
-gdb_test "print (0 && (x>=y))" ".$decimal = $false" \
- "print value of (0 && (x>=y))"
+test "(0 && (x>=y))" ".$decimal = $false"
-gdb_test "print (0 && (x==y))" ".$decimal = $false" \
- "print value of (0 && (x==y))"
+test "(0 && (x==y))" ".$decimal = $false"
-gdb_test "print (0 && (x!=y))" ".$decimal = $false" \
- "print value of (0 && (x!=y))"
+test "(0 && (x!=y))" ".$decimal = $false"
-gdb_test "print (0 && (x<<31))" ".$decimal = $false" \
- "print value of (0 && (x<<31))"
+test "(0 && (x<<31))" ".$decimal = $false"
-gdb_test "print (0 && (x>>31))" ".$decimal = $false" \
- "print value of (0 && (x>>31))"
+test "(0 && (x>>31))" ".$decimal = $false"
-gdb_test "print (0 && (!x))" ".$decimal = $false" \
- "print value of (0 && (!x))"
+test "(0 && (!x))" ".$decimal = $false"
-gdb_test "print (0 && (~x))" ".$decimal = $false" \
- "print value of (0 && (~x))"
+test "(0 && (~x))" ".$decimal = $false"
-gdb_test "print (0 && (-x))" ".$decimal = $false" \
- "print value of (0 && (-x))"
+test "(0 && (-x))" ".$decimal = $false"
-gdb_test "print (0 && (x++))" ".$decimal = $false" \
- "print value of (0 && (x++))"
+test "(0 && (x++))" ".$decimal = $false"
-gdb_test "print (0 && (++x))" ".$decimal = $false" \
- "print value of (0 && (++x))"
+test "(0 && (++x))" ".$decimal = $false"
-gdb_test "print (0 && (x--))" ".$decimal = $false" \
- "print value of (0 && (x--))"
+test "(0 && (x--))" ".$decimal = $false"
-gdb_test "print (0 && (--x))" ".$decimal = $false" \
- "print value of (0 && (--x))"
+test "(0 && (--x))" ".$decimal = $false"
-gdb_test "print (0 && (x+=7))" ".$decimal = $false" \
- "print value of (0 && (x+=7))"
+test "(0 && (x+=7))" ".$decimal = $false"
-gdb_test "print (0 && (x=y))" ".$decimal = $false" \
- "print value of (0 && (x=y))"
+test "(0 && (x=y))" ".$decimal = $false"
gdb_exit
@@ -172,17 +172,17 @@ with_test_prefix "char-width=1, print-max=20" {
}
gdb_test "x/-xb" "0x39" "take 1 char backward again"
gdb_test "x/-s" "\"01234567890123456789\"\.\.\." \
- "take 1 string backward (1/6)"
+ "take 1 string backward, 1/6"
gdb_test "x/-s" "\".+\"" \
- "take 1 string backward (2/6)"
+ "take 1 string backward, 2/6"
gdb_test "x/-s" "\"\"" \
- "take 1 string backward (3/6)"
+ "take 1 string backward, 3/6"
gdb_test "x/-s" "\"\"" \
- "take 1 string backward (4/6)"
+ "take 1 string backward, 4/6"
gdb_test "x/-s" "\"GHIJKLMNOPQRSTUVWXYZ\"" \
- "take 1 string backward (5/6)"
+ "take 1 string backward, 5/6"
gdb_test "x/-s" "\"ABCDEFGHIJKLMNOPQRST\"\.\.\." \
- "take 1 string backward (6/6)"
+ "take 1 string backward, 6/6"
}
with_test_prefix "char-width=2, print-max=20" {
@@ -214,17 +214,17 @@ with_test_prefix "char-width=2, print-max=20" {
}
gdb_test "x/-xh" "0x0039" "take 1 char backward again"
gdb_test "x/-sh" "u\"01234567890123456789\"\.\.\." \
- "take 1 string backward (1/6)"
+ "take 1 string backward, 1/6"
gdb_test "x/-sh" "u\".+\"" \
- "take 1 string backward (2/6)"
+ "take 1 string backward, 2/6"
gdb_test "x/-sh" "u\"\"" \
- "take 1 string backward (3/6)"
+ "take 1 string backward, 3/6"
gdb_test "x/-sh" "u\"\"" \
- "take 1 string backward (4/6)"
+ "take 1 string backward, 4/6"
gdb_test "x/-sh" "u\"GHIJKLMNOPQRSTUVWXYZ\"" \
- "take 1 string backward (5/6)"
+ "take 1 string backward, 5/6"
gdb_test "x/-sh" "u\"ABCDEFGHIJKLMNOPQRST\"\.\.\." \
- "take 1 string backward (6/6)"
+ "take 1 string backward, 6/6"
}
with_test_prefix "char-width=4, print-max=20" {
@@ -256,17 +256,17 @@ with_test_prefix "char-width=4, print-max=20" {
}
gdb_test "x/-xw" "0x00000039" "take 1 char backward again"
gdb_test "x/-sw" "U\"01234567890123456789\"\.\.\." \
- "take 1 string backward (1/6)"
+ "take 1 string backward, 1/6"
gdb_test "x/-sw" "U\".+\"" \
- "take 1 string backward (2/6)"
+ "take 1 string backward, 2/6"
gdb_test "x/-sw" "U\"\"" \
- "take 1 string backward (3/6)"
+ "take 1 string backward, 3/6"
gdb_test "x/-sw" "U\"\"" \
- "take 1 string backward (4/6)"
+ "take 1 string backward, 4/6"
gdb_test "x/-sw" "U\"GHIJKLMNOPQRSTUVWXYZ\"" \
- "take 1 string backward (5/6)"
+ "take 1 string backward, 5/6"
gdb_test "x/-sw" "U\"ABCDEFGHIJKLMNOPQRST\"\.\.\." \
- "take 1 string backward (6/6)"
+ "take 1 string backward, 6/6"
}
with_test_prefix "char-width=2, print-max=0" {
@@ -299,17 +299,17 @@ with_test_prefix "char-width=2, print-max=0" {
}
gdb_test "x/-xh" "0x0000" "take 1 char backward"
gdb_test "x/-sh" "u\"!!!!!!\"" \
- "take 1 string backward (1/6)"
+ "take 1 string backward, 1/6"
gdb_test "x/-sh" "u\"012345678901234567890123456789\"" \
- "take 1 string backward (2/6)"
+ "take 1 string backward, 2/6"
gdb_test "x/-sh" "u\".+\"" \
- "take 1 string backward (3/6)"
+ "take 1 string backward, 3/6"
gdb_test "x/-sh" "u\"\"" \
- "take 1 string backward (4/6)"
+ "take 1 string backward, 4/6"
gdb_test "x/-sh" "u\"\"" \
- "take 1 string backward (5/6)"
+ "take 1 string backward, 5/6"
gdb_test "x/-sh" "u\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"" \
- "take 1 string backward (6/6)"
+ "take 1 string backward, 6/6"
}
with_test_prefix "char-width=1, print-max=4" {
@@ -326,13 +326,13 @@ with_test_prefix "char-width=1, print-max=4" {
"\"\""
}
gdb_test "x/-xb" "0x00" "take 1 byte backward"
- gdb_test_sequence "x/-4s" "take 4 strings backward (1/2)" {
+ gdb_test_sequence "x/-4s" "take 4 strings backward, 1/2" {
"\"TUVW\"\.\.\."
"\"XYZ\""
"\"\""
"\"\""
}
- gdb_test_sequence "x/-4s" "take 4 strings backward (2/2)" {
+ gdb_test_sequence "x/-4s" "take 4 strings backward, 2/2" {
"\"CDEF\"\.\.\."
"\"GHIJ\"\.\.\."
"\"KLMN\"\.\.\."
@@ -348,9 +348,9 @@ with_test_prefix "backward disassemble general" {
set main_re "main(\\(\\))?"
gdb_test "x/i main" "0x\[0-9a-fA-F\]+ <$main_re>:\t.*" \
- "move the current position to main (x/i)"
+ "move the current position to main, x/i"
gdb_test "x/-i" "0x\[0-9a-fA-F\]+ <$main_re>:\t.*" \
- "move the current position to main (x/-i)"
+ "move the current position to main, x/-i"
for {set i 0} {$i < [llength $length_to_examine]} {incr i} {
set len [lindex $length_to_examine $i]
set instructions [capture_command_output "x/${len}i" ""]
@@ -46,9 +46,9 @@ proc test_expr { args } {
}
set last_ent [expr [llength $args] - 1]
set testname [lindex $args $last_ent]
- gdb_test [lindex $args 0] ".*" "$testname (setup)"
+ gdb_test [lindex $args 0] ".*" "$testname, setup"
for {set x 1} {$x < $last_ent} {set x [expr $x + 2]} {
- gdb_test [lindex $args $x] [lindex $args [expr $x + 1]] "$testname ([lindex $args $x])"
+ gdb_test [lindex $args $x] [lindex $args [expr $x + 1]] "$testname, [lindex $args $x]"
}
}
#
@@ -149,23 +149,23 @@ gdb_test continue \
gdb_test continue \
"Continuing\\..*isatty 1:.*OK$stop_msg" \
-"Isatty (stdin)"
+"Isatty, stdin"
gdb_test continue \
"Continuing\\..*isatty 2:.*OK$stop_msg" \
-"Isatty (stdout)"
+"Isatty, stdout"
gdb_test continue \
"Continuing\\..*isatty 3:.*OK$stop_msg" \
-"Isatty (stderr)"
+"Isatty, stderr"
gdb_test continue \
"Continuing\\..*isatty 4:.*OK$stop_msg" \
-"Isatty (invalid fd)"
+"Isatty, invalid fd"
gdb_test continue \
"Continuing\\..*isatty 5:.*OK$stop_msg" \
-"Isatty (open file)"
+"Isatty, open file"
gdb_test_no_output "set debug remote 1"
set msg "System says shell is not available"
@@ -139,23 +139,23 @@ proc do_exec_tests {} {
send_gdb "print global_i\n"
gdb_expect {
-re ".* = 0.*$gdb_prompt $"\
- {pass "print execd-program/global_i (after execlp)"}
- -re "$gdb_prompt $" {fail "print execd-program/global_i (after execlp)"}
- timeout {fail "(timeout) print execd-program/global_i (after execlp)"}
+ {pass "print execd-program/global_i, after execlp"}
+ -re "$gdb_prompt $" {fail "print execd-program/global_i, after execlp"}
+ timeout {fail "(timeout) print execd-program/global_i, after execlp"}
}
send_gdb "print local_j\n"
gdb_expect {
-re ".* = 2.*$gdb_prompt $"\
- {pass "print execd-program/local_j (after execlp)"}
- -re "$gdb_prompt $" {fail "print execd-program/local_j (after execlp)"}
- timeout {fail "(timeout) print execd-program/local_j (after execlp)"}
+ {pass "print execd-program/local_j, after execlp"}
+ -re "$gdb_prompt $" {fail "print execd-program/local_j, after execlp"}
+ timeout {fail "(timeout) print execd-program/local_j, after execlp"}
}
send_gdb "print local_k\n"
gdb_expect {
-re "No symbol \"local_k\" in current context.*$gdb_prompt $"\
- {pass "print follow-exec/local_k (after execlp)"}
- -re "$gdb_prompt $" {fail "print follow-exec/local_k (after execlp)"}
- timeout {fail "(timeout) print follow-exec/local_k (after execlp)"}
+ {pass "print follow-exec/local_k, after execlp"}
+ -re "$gdb_prompt $" {fail "print follow-exec/local_k, after execlp"}
+ timeout {fail "(timeout) print follow-exec/local_k, after execlp"}
}
# Explicitly kill this program, or a subsequent rerun actually runs
@@ -288,9 +288,9 @@ proc do_exec_tests {} {
send_gdb "print local_j\n"
gdb_expect {
-re ".* = 3.*$gdb_prompt $"\
- {pass "print execd-program/local_j (after execl)"}
- -re "$gdb_prompt $" {fail "print execd-program/local_j (after execl)"}
- timeout {fail "(timeout) print execd-program/local_j (after execl)"}
+ {pass "print execd-program/local_j, after execl"}
+ -re "$gdb_prompt $" {fail "print execd-program/local_j, after execl"}
+ timeout {fail "(timeout) print execd-program/local_j, after execl"}
}
# Explicitly kill this program, or a subsequent rerun actually runs
@@ -349,9 +349,9 @@ proc do_exec_tests {} {
send_gdb "print local_j\n"
gdb_expect {
-re ".* = 2.*$gdb_prompt $"\
- {pass "print execd-program/local_j (after execv)"}
- -re "$gdb_prompt $" {fail "print execd-program/local_j (after execv)"}
- timeout {fail "(timeout) print execd-program/local_j (after execv)"}
+ {pass "print execd-program/local_j, after execv"}
+ -re "$gdb_prompt $" {fail "print execd-program/local_j, after execv"}
+ timeout {fail "(timeout) print execd-program/local_j, after execv"}
}
# Explicitly kill this program, or a subsequent rerun actually runs
@@ -150,7 +150,7 @@ delete_breakpoints
#
gdb_test "hbreak -q main" \
"Hardware assisted breakpoint.*at.* file .*$srcfile, line.*" \
- "hardware breakpoint function (2)"
+ "hardware breakpoint function, 2"
gdb_run_cmd
gdb_test "" \
"Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.* \{.*" \
@@ -162,7 +162,7 @@ delete_breakpoints
#
gdb_test "hbreak $bp_location1" \
"Hardware assisted breakpoint.*at.* file .*$srcfile, line $bp_location1\\." \
- "hardware breakpoint line number (2)"
+ "hardware breakpoint line number, 2"
gdb_test "continue" \
"Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location1.*$bp_location1\[\t \]+printf.*factorial.*" \
"run until breakpoint set at a line number"
@@ -173,7 +173,7 @@ delete_breakpoints
#
gdb_test "hbreak $srcfile:factorial" \
"Hardware assisted breakpoint.*at.* file .*$srcfile, line.*" \
- "hardware breakpoint function in file (2)"
+ "hardware breakpoint function in file, 2"
for {set i 6} {$i >= 1} {incr i -1} {
gdb_test "continue" \
"Continuing\\..*Breakpoint \[0-9\]+, factorial \\(value=$i\\) at .*$srcfile:$bp_location7.*$bp_location7\[\t \]+.*if .value > 1. \{.*" \
@@ -186,7 +186,7 @@ delete_breakpoints
#
gdb_test "hbreak \"marker2\"" \
"Hardware assisted breakpoint.*at.* file .*$srcfile1, line.*" \
- "hardware breakpoint quoted function (2)"
+ "hardware breakpoint quoted function, 2"
gdb_test "continue" \
"Continuing\\..*Breakpoint \[0-9\]+, (0x\[0-9a-f\]+ in )?marker2 \\(a=43\\) at .*$srcfile1:$bp_location8.*" \
"run until quoted breakpoint"
@@ -196,7 +196,7 @@ delete_breakpoints
#
gdb_test "hbreak $srcfile:$bp_location2" \
"Hardware assisted breakpoint.*at.* file .*$srcfile, line $bp_location2\\." \
- "hardware breakpoint line number in file (2)"
+ "hardware breakpoint line number in file, 2"
gdb_test "continue" \
"Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location2.*$bp_location2\[\t \]+argc = \\(argc == 12345\\);.*" \
"run until file:linenum breakpoint"
@@ -46,7 +46,7 @@ proc run_print_on_each_thing { things } {
set index 0
foreach thing $things {
- gdb_test "print $thing" "" "printing $thing (item #$index)"
+ gdb_test "print $thing" "" "printing $thing, item #$index"
incr index
}
}
@@ -90,8 +90,8 @@ with_test_prefix "remove-duplicates=1" {
check_prev_history_entry "print 1"
check_prev_history_entry "print 2"
check_prev_history_entry "print 0"
- check_prev_history_entry "print 1" "(again)"
- check_prev_history_entry "print 0" "(again)"
+ check_prev_history_entry "print 1" ", again"
+ check_prev_history_entry "print 0" ", again"
}
@@ -104,9 +104,9 @@ with_test_prefix "remove-duplicates=0" {
run_print_on_each_thing { 0 0 1 1 }
check_prev_history_entry "print 1"
- check_prev_history_entry "print 1" "(again)"
+ check_prev_history_entry "print 1" ", again"
check_prev_history_entry "print 0"
- check_prev_history_entry "print 0" "(again)"
+ check_prev_history_entry "print 0" ", again"
}
@@ -38,7 +38,7 @@ gdb_test "source $script" "$script_output" \
gdb_test "print 3" "= 3" "sanity check with interactive-mode auto"
gdb_test "show interactive-mode" \
"Debugger's interactive mode is auto \\(currently .*\\)\\." \
- "show interactive-mode (auto)"
+ "show interactive-mode, auto"
# Test sourcing of the script with interactive mode `on'.
# Verify that evaluating the script does not cause an unexpected
@@ -49,7 +49,7 @@ gdb_test "source $script" "$script_output" \
gdb_test "print 4" "= 4" "sanity check with interactive-mode on"
gdb_test "show interactive-mode" \
"Debugger's interactive mode is on\\." \
- "show interactive-mode (on)"
+ "show interactive-mode, on"
# Test sourcing of the script with interactive mode `off'.
# Verify that evaluating the script does not cause an unexpected
@@ -60,5 +60,5 @@ gdb_test "source $script" "$script_output" \
gdb_test "print 5" "= 5" "sanity check with interactive-mode off"
gdb_test "show interactive-mode" \
"Debugger's interactive mode is off\\." \
- "show interactive-mode (off)"
+ "show interactive-mode, off"
@@ -66,7 +66,7 @@ if {[istarget "rs6000-*-aix*"] && !$gcc_compiled} {
setup_xfail_on_opaque_pointer
gdb_test "whatis foop" \
"type = struct foo \[*\]+" \
- "whatis on opaque struct pointer (statically)"
+ "whatis on opaque struct pointer, statically"
# Ensure that we know the form of the structure that foop points to.
@@ -122,7 +122,7 @@ if ![runto_main] {
setup_xfail_on_opaque_pointer
gdb_test "whatis foop" \
"type = struct foo \[*\]+" \
- "whatis on opaque struct pointer (dynamically)"
+ "whatis on opaque struct pointer, dynamically"
# Ensure that we know the form of the thing foop points to.
@@ -131,18 +131,18 @@ setup_xfail_on_opaque_pointer
if {!$gcc_compiled} { setup_xfail "rs6000-*-*" }
gdb_test "ptype foop" \
"type = struct foo \{\[\r\n\]+ int a;\[\r\n\]+ int b;\[\r\n\]+\} \[*\]+" \
- "ptype on opaque struct pointer (dynamically) 1"
+ "ptype on opaque struct pointer, dynamically 1"
gdb_test "whatis afoo" \
"type = struct foo" \
- "whatis on opaque struct instance (dynamically) 1"
+ "whatis on opaque struct instance, dynamically 1"
# Ensure that we know the form of afoo, an instance of a struct foo.
gdb_test "ptype afoo" \
"type = struct foo \{\[\r\n\]+ int a;\[\r\n\]+ int b;\[\r\n\]+\}" \
- "ptype on opaque struct instance (dynamically) 1"
+ "ptype on opaque struct instance, dynamically 1"
# Ensure that we know the form of an explicit struct foo.
@@ -150,7 +150,7 @@ gdb_test "ptype afoo" \
if {!$gcc_compiled} { setup_xfail "rs6000-*-*" }
gdb_test "ptype struct foo" \
"type = struct foo \{\[\r\n\]+ int a;\[\r\n\]+ int b;\[\r\n\]+\}" \
- "ptype on opaque struct tagname (dynamically) 1"
+ "ptype on opaque struct tagname, dynamically 1"
# Now reload the symbols again so we forget about anything we might
@@ -170,7 +170,7 @@ if ![runto getfoo] {
setup_xfail_on_opaque_pointer
gdb_test "whatis foop" \
"type = struct foo \[*\]+" \
- "whatis on opaque struct pointer (dynamically) 1"
+ "whatis on opaque struct pointer, dynamically 1"
# Ensure that we know the form of the thing foop points to.
@@ -178,22 +178,22 @@ gdb_test "whatis foop" \
setup_xfail_on_opaque_pointer
gdb_test "ptype foop" \
"type = struct foo \{\[\r\n\]+ int a;\[\r\n\]+ int b;\[\r\n\]+\} \[*\]+" \
- "ptype on opaque struct pointer (dynamically) 2"
+ "ptype on opaque struct pointer, dynamically 2"
gdb_test "whatis afoo" \
"type = struct foo" \
- "whatis on opaque struct instance (dynamically) 2"
+ "whatis on opaque struct instance, dynamically 2"
# Ensure that we know the form of afoo, an instance of a struct foo.
gdb_test "ptype afoo" \
"type = struct foo \{\[\r\n\]+ int a;\[\r\n\]+ int b;\[\r\n\]+\}" \
- "ptype on opaque struct instance (dynamically) 2"
+ "ptype on opaque struct instance, dynamically 2"
# Ensure that we know the form of an explicit struct foo.
gdb_test "ptype struct foo" \
"type = struct foo \{\[\r\n\]+ int a;\[\r\n\]+ int b;\[\r\n\]+\}" \
- "ptype on opaque struct tagname (dynamically) 2"
+ "ptype on opaque struct tagname, dynamically 2"
@@ -39,7 +39,7 @@ clean_restart
gdb_test_multiple "break pendfunc1" "set pending breakpoint" {
-re ".*Make breakpoint pending.*y or \\\[n\\\]. $" {
- gdb_test "y" "Breakpoint.*pendfunc1.*pending." "set pending breakpoint (without symbols)"
+ gdb_test "y" "Breakpoint.*pendfunc1.*pending." "set pending breakpoint, without symbols"
}
}
@@ -49,7 +49,7 @@ gdb_test "complete condition " "condition 1"
gdb_test "info break" \
"Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+breakpoint keep y.*PENDING.*pendfunc1.*" \
-"single pending breakpoint info (without symbols)"
+"single pending breakpoint info, without symbols"
with_test_prefix "first load" {
gdb_load ${binfile}
@@ -1186,7 +1186,7 @@ gdb_test_no_output "complete p -source"
gdb_file_cmd ${binfile}
-gdb_test "print \$pc" "No registers\\." "print \$pc (with file)"
+gdb_test {print $pc} [string_to_regexp "No registers."] {print $pc, with file}
gdb_test_no_output "set print sevenbit-strings"
gdb_test_no_output "set print address off"
@@ -52,15 +52,15 @@ proc recurse_tests {} {
# Continue inward for a few iterations
gdb_test "continue" "Breakpoint.* recurse \\(a=9\\).*" \
- "continue to recurse (a = 9)"
+ "continue to recurse, a = 9"
gdb_test "continue" "Breakpoint.* recurse \\(a=8\\).*" \
- "continue to recurse (a = 8)"
+ "continue to recurse, a = 8"
gdb_test "continue" "Breakpoint.* recurse \\(a=7\\).*" \
- "continue to recurse (a = 7)"
+ "continue to recurse, a = 7"
gdb_test "continue" "Breakpoint.* recurse \\(a=6\\).*" \
- "continue to recurse (a = 6)"
+ "continue to recurse, a = 6"
gdb_test "continue" "Breakpoint.* recurse \\(a=5\\).*" \
- "continue to recurse (a = 5)"
+ "continue to recurse, a = 5"
# Put a watchpoint on another instance of b
# First we need to step over the assignment of b, so it has a known
@@ -76,13 +76,13 @@ proc recurse_tests {} {
# Continue inward for a few iterations
gdb_test "continue" "Breakpoint.* recurse \\(a=4\\).*" \
- "continue to recurse (a = 4)"
+ "continue to recurse, a = 4"
gdb_test "continue" "Breakpoint.* recurse \\(a=3\\).*" \
- "continue to recurse (a = 3)"
+ "continue to recurse, a = 3"
gdb_test "continue" "Breakpoint.* recurse \\(a=2\\).*" \
- "continue to recurse (a = 2)"
+ "continue to recurse, a = 2"
gdb_test "continue" "Breakpoint.* recurse \\(a=1\\).*" \
- "continue to recurse (a = 1)"
+ "continue to recurse, a = 1"
# Continue until second set of b (second instance).
gdb_test "continue" \
@@ -67,12 +67,12 @@ proc_with_prefix test_setshow_annotate {} {
#test set annotate 1
gdb_test "set annotate 1" ".*post-prompt.*"
- gdb_test "show annotate" "Annotation_level is 1..*" "show annotate (1)"
+ gdb_test "show annotate" "Annotation_level is 1..*" "show annotate, 1"
#test annotation_level 1
gdb_test "info line 1" "Line 1 of .* is at address .* but contains no code.*:1:0:beg:0x.*" "annotation_level 1"
#test set annotate 0
gdb_test_no_output "set annotate 0" "set annotate 0"
- gdb_test "show annotate" "Annotation_level is 0..*" "show annotate (0)"
+ gdb_test "show annotate" "Annotation_level is 0..*" "show annotate, 0"
#test annotation_level 0
gdb_test "info line 1" "Line 1 of .* is at address .* but contains no code.*" "annotation_level 0"
}
@@ -121,13 +121,13 @@ proc_with_prefix test_setshow_check {} {
"_gdb_setting check range on"
#test show check range on
- gdb_test "show check range" "Range checking is \"on\"\..*" "show check range (on)"
+ gdb_test "show check range" "Range checking is \"on\"\..*" "show check range, on"
#test set check range off with trailing space
gdb_test_no_output "set check range off " "set check range off"
#test show check range off
- gdb_test "show check range" "Range checking is \"off\"\..*" "show check range (off)"
+ gdb_test "show check range" "Range checking is \"off\"\..*" "show check range, off"
gdb_test "p \$_gdb_setting(\"check range\")" " = \"off\"" \
"_gdb_setting check range off"
@@ -144,7 +144,7 @@ proc_with_prefix test_setshow_check {} {
# Test show check type on
gdb_test "show check type" "Strict type checking is on\..*" \
- "show check type (on)"
+ "show check type, on"
gdb_test "p \$_gdb_setting_str(\"check type\")" " = \"on\"" \
"_gdb_setting_str check type on"
gdb_test "p \$_gdb_setting(\"check type\")" " = 1" \
@@ -159,7 +159,7 @@ proc_with_prefix test_setshow_check {} {
# Test show check type off
gdb_test "show check type" "Strict type checking is off\..*" \
- "show check type (off)"
+ "show check type, off"
}
proc_with_prefix test_setshow_breakpoint_pending {} {
@@ -200,11 +200,11 @@ proc_with_prefix test_setshow_complaints {} {
#test set complaints 100
gdb_test_no_output "set complaints 100" "set complaints 100"
#test show complaints 100
- gdb_test "show complaints" "Max number of complaints about incorrect symbols is 100..*" "show complaints (100)"
+ gdb_test "show complaints" "Max number of complaints about incorrect symbols is 100..*" "show complaints, 100"
#test set complaints 0
gdb_test_no_output "set complaints 0" "set complaints 0"
#test show complaints 0
- gdb_test "show complaints" "Max number of complaints about incorrect symbols is 0..*" "show complaints (0)"
+ gdb_test "show complaints" "Max number of complaints about incorrect symbols is 0..*" "show complaints, 0"
}
proc_with_prefix test_setshow_confirm {} {
@@ -213,11 +213,11 @@ proc_with_prefix test_setshow_confirm {} {
#test set confirm off
gdb_test_no_output "set confirm off" "set confirm off"
#test show confirm off
- gdb_test "show confirm" "Whether to confirm potentially dangerous operations is off..*" "show confirm (off)"
+ gdb_test "show confirm" "Whether to confirm potentially dangerous operations is off..*" "show confirm, off"
#test set confirm on
gdb_test_no_output "set confirm on" "set confirm on"
#test show confirm on
- gdb_test "show confirm" "Whether to confirm potentially dangerous operations is on..*" "show confirm (on)"
+ gdb_test "show confirm" "Whether to confirm potentially dangerous operations is on..*" "show confirm, on"
}
proc_with_prefix test_setshow_editing {} {
@@ -331,7 +331,7 @@ proc_with_prefix test_setshow_history {} {
#test show history filename foobar.baz
gdb_test "show history filename" \
"The filename in which to record the command history is \"[string_to_regexp $PWD]/foobar.baz\"..*" \
- "show history filename (current_directory/foobar.baz)"
+ "show history filename, current_directory/foobar.baz"
#test set history save on
gdb_test_no_output "set history save on" "set history save on"
@@ -356,13 +356,13 @@ proc_with_prefix test_setshow_language {} {
gdb_test_no_output "set language asm"
#test show language asm
- gdb_test "show language" "The current source language is \"asm\"..*" "show language (asm)"
+ gdb_test "show language" "The current source language is \"asm\"..*" "show language, asm"
#test set language rust, with a trailing space
gdb_test_no_output "set language rust " "set language rust"
#test show language rust
- gdb_test "show language" "The current source language is \"rust\"..*" "show language (rust)"
+ gdb_test "show language" "The current source language is \"rust\"..*" "show language, rust"
#test completion for set language.
gdb_test "complete set language min" "set language minimal" \
@@ -372,7 +372,7 @@ proc_with_prefix test_setshow_language {} {
gdb_test_no_output "set language auto" "set language auto"
#test show language
- gdb_test "show language" "The current source language is \"auto.*\"..*" "show language (auto)"
+ gdb_test "show language" "The current source language is \"auto.*\"..*" "show language, auto"
}
proc_with_prefix test_setshow_listsize {} {
@@ -447,13 +447,13 @@ proc_with_prefix test_setshow_radix {} {
gdb_test "set radix 16" "Input and output radices now set to decimal 16, hex 10, octal 20..*"
#test show radix 16
- gdb_test "show radix" "Input and output radices set to decimal 16, hex 10, octal 20..*" "show radix (16)"
+ gdb_test "show radix" "Input and output radices set to decimal 16, hex 10, octal 20..*" "show radix, 16"
#test set radix 10
gdb_test "set radix" "Input and output radices now set to decimal 10, hex a, octal 12..*" "set radix 10"
#test show radix 10
- gdb_test "show radix" "Input and output radices set to decimal 10, hex a, octal 12..*" "show radix (10)"
+ gdb_test "show radix" "Input and output radices set to decimal 10, hex a, octal 12..*" "show radix, 10"
}
proc_with_prefix test_setshow_width {} {
@@ -492,13 +492,13 @@ proc_with_prefix test_setshow_verbose {} {
gdb_test_no_output "set verbose on" "set verbose on"
#test show verbose on
- gdb_test "show verbose" "Verbose printing of informational messages is on..*" "show verbose (on)"
+ gdb_test "show verbose" "Verbose printing of informational messages is on..*" "show verbose, on"
#test set verbose off
gdb_test_no_output "set verbose off" "set verbose off"
#test show verbose off
- gdb_test "show verbose" "Verbosity is off..*" "show verbose (off)"
+ gdb_test "show verbose" "Verbosity is off..*" "show verbose, off"
}
proc_with_prefix test_argument_preceded_by_space {} {
@@ -390,13 +390,13 @@ set timeout $prev_timeout
if {[is_c_compiler_gcc]} {
gdb_test "print sef.field=sm1" ".*.\[0-9\]* = sm1"
- gdb_test "print sef.field" ".*.\[0-9\]* = sm1" "print sef.field (sm1)"
+ gdb_test "print sef.field" ".*.\[0-9\]* = sm1" "print sef.field, sm1"
gdb_test "print sef.field=s1" ".*.\[0-9\]* = s1"
- gdb_test "print sef.field" ".*.\[0-9\]* = s1" "print sef.field (s1)"
+ gdb_test "print sef.field" ".*.\[0-9\]* = s1" "print sef.field, s1"
gdb_test "print uef.field=u2" ".*.\[0-9\]* = u2"
- gdb_test "print uef.field" ".*.\[0-9\]* = u2" "print uef.field (u2)"
+ gdb_test "print uef.field" ".*.\[0-9\]* = u2" "print uef.field, u2"
gdb_test "print uef.field=u1" ".*.\[0-9\]* = u1"
- gdb_test "print uef.field" ".*.\[0-9\]* = u1" "print uef.field (u1)"
+ gdb_test "print uef.field" ".*.\[0-9\]* = u1" "print uef.field, u1"
# Test for truncation when assigning invalid values to bitfields.
gdb_test "print sef.field=7" \
@@ -31,9 +31,9 @@ set srcfile1 skip1.c
# Right after we start gdb, there's no default file or function to skip.
-gdb_test "skip file" "No default file now." "skip file (no default file)"
+gdb_test "skip file" "No default file now." "skip file, no default file"
gdb_test "skip function" "No default function now."
-gdb_test "skip" "No default function now." "skip (no default function)"
+gdb_test "skip" "No default function now." "skip, no default function"
# Test elided args.
@@ -59,8 +59,8 @@ gdb_test "info skip" "Not skipping any files or functions\." "info skip empty"
# Create a skiplist entry for the current file and function.
-gdb_test "skip file" "File .*$srcfile will be skipped when stepping\." "skip file ($srcfile)"
-gdb_test "skip" "Function main will be skipped when stepping\." "skip (main)"
+gdb_test "skip file" "File .*$srcfile will be skipped when stepping\." "skip file, $srcfile"
+gdb_test "skip" "Function main will be skipped when stepping\." "skip, main"
# Create a skiplist entry for a specified file and function.
@@ -126,7 +126,7 @@ foreach libsepdebug {NO IN SEP} { with_test_prefix "$libsepdebug" {
"1: \\(int\\) a_global = 41" \
"warning: .*b_global.*" \
"3: \\(int\\) c_global = 43" \
- ] "after rerun (2)"
+ ] "after rerun, 2"
# Now verify that displays which are not in the shared library
# are not cleared permaturely.
@@ -108,9 +108,9 @@ proc test_backtrace { expect_fail } {
set total_expected 5
if { $expect_fail } {
- set testname "backtrace (with wrong libs)"
+ set testname "backtrace, with wrong libs"
} else {
- set testname "backtrace (with right libs)"
+ set testname "backtrace, with right libs"
}
# N.B. The order of the tests here is important.
# We need to count each function in the backtrace, and expect matches
@@ -137,7 +137,7 @@ proc test_backtrace { expect_fail } {
exp_continue
}
-re "\[\r\n\]$gdb_prompt $" {
- pass "$testname (data collection)"
+ pass "$testname, data collection"
}
}
@@ -34,9 +34,9 @@ gdb_test "break $bp_location" \
gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, main \\(\\) at .*$srcfile:$bp_location.*set breakpoint here.*" \
"run until breakpoint set at a line number"
-gdb_test "next 2" ".*place2.*" "next 2 (1)"
-gdb_test "next 2" ".*place3.*" "next 2 (2)"
-gdb_test "next 2" ".*place2.*" "next 2 (3)"
-gdb_test "next 2" ".*place3.*" "next 2 (4)"
-gdb_test "next 2" ".*place2.*" "next 2 (5)"
-gdb_test "next 2" ".*place3.*" "next 2 (6)"
+gdb_test "next 2" ".*place2.*" "next 2, 1"
+gdb_test "next 2" ".*place3.*" "next 2, 2"
+gdb_test "next 2" ".*place2.*" "next 2, 3"
+gdb_test "next 2" ".*place3.*" "next 2, 4"
+gdb_test "next 2" ".*place2.*" "next 2, 5"
+gdb_test "next 2" ".*place3.*" "next 2, 6"
@@ -99,13 +99,13 @@ proc setup { syscall } {
gdb_test "break \*$syscall" "Breakpoint \[0-9\]* at .*"
gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, (.* in )?(__libc_)?$syscall \\(\\).*" \
- "continue to $syscall (1st time)"
+ "continue to $syscall, 1st time"
# Hit the breakpoint on $syscall for the first time. In this time,
# we will let PLT resolution done, and the number single steps we will
# do later will be reduced.
gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, (.* in )?(__libc_)?$syscall \\(\\).*" \
- "continue to $syscall (2nd time)"
+ "continue to $syscall, 2nd time"
# Hit the breakpoint on $syscall for the second time. In this time,
# the address of syscall insn and next insn of syscall are recorded.
@@ -236,7 +236,7 @@ proc step_over_syscall { syscall } {
}
gdb_test "continue" "Continuing\\..*Breakpoint \[0-9\]+, (.* in )?(__libc_)?$syscall \\(\\).*" \
- "continue to $syscall (3rd time)"
+ "continue to $syscall, 3rd time"
# Hit the breakpoint on $syscall for the third time. In this time, we'll set
# breakpoint on the syscall insn we recorded previously, and single step over it.
@@ -57,15 +57,15 @@ proc vla_optimized_out {exe_suffix options} {
# that case to reply with 'no such vector element'.
gdb_test "p a\[0\]" \
"(= <optimized out>|no such vector element)" \
- "print out of range element of vla (0)"
+ "print out of range element of vla, 0"
gdb_test "p a\[6\]" \
"no such vector element" \
- "print out of range element of vla (6)"
+ "print out of range element of vla, 6"
gdb_test "p a\[0xffffffff\]" \
"no such vector element" \
- "print out of range element of vla (0xffffffff)"
+ "print out of range element of vla, 0xffffffff"
}
set o1_sizeof_result "6"
@@ -29,13 +29,13 @@ set sizeof_int [get_sizeof "int" 4]
# Check that VLA passed to function (pointer) points to the first element.
gdb_breakpoint [gdb_get_line_number "foo_bp"]
gdb_continue_to_breakpoint "foo_bp"
-gdb_test "print vla_ptr" "\\\(int \\\*\\\) $hex" "print vla_ptr (foo)"
-gdb_test "print *vla_ptr" " = 2" "print *vla_ptr (foo)"
+gdb_test "print vla_ptr" "\\\(int \\\*\\\) $hex" "print vla_ptr, foo"
+gdb_test "print *vla_ptr" " = 2" "print *vla_ptr, foo"
gdb_breakpoint [gdb_get_line_number "bar_bp"]
gdb_continue_to_breakpoint "bar_bp"
-gdb_test "print vla_ptr" "\\\(int \\\*\\\) $hex" "print vla_ptr (bar)"
-gdb_test "print *vla_ptr" " = 2" "print *vla_ptr (bar)"
+gdb_test "print vla_ptr" "\\\(int \\\*\\\) $hex" "print vla_ptr, bar"
+gdb_test "print *vla_ptr" " = 2" "print *vla_ptr, bar"
gdb_breakpoint [gdb_get_line_number "vla_func_bp"]
gdb_continue_to_breakpoint "vla_func_bp"
@@ -52,30 +52,30 @@ gdb_test "print vla1\[0\]" " = 10" \
gdb_test "print sizeof (vla2\[i++\])" " = ${sizeof_vla}"
gdb_test "print i" " = 1" \
- "print i - sizeof with side effects (1)"
+ "print i - sizeof with side effects, 1"
gdb_test "print sizeof (vla2\[i++ + sizeof(j++)\])" " = ${sizeof_vla}"
gdb_test "print i" " = 2" \
- "print i - sizeof with side effects (2)"
+ "print i - sizeof with side effects, 2"
gdb_test "print j" " = 0" \
"print j - sizeof with no side effects"
gdb_test "ptype vla2\[i++\]" "type = int \\\[10\\\]"
gdb_test "print i" " = 2" \
- "print i - ptype with side effects (1)"
+ "print i - ptype with side effects, 1"
gdb_test "ptype vla2\[i++ + sizeof(j++)\]" "type = int \\\[10\\\]"
gdb_test "print i" " = 2" \
- "print i - ptype with side effects (2)"
+ "print i - ptype with side effects, 2"
gdb_test "print j" " = 0" \
"print j - ptype with no side effects"
gdb_test "whatis vla2\[i++\]" "type = int \\\[10\\\]"
gdb_test "print i" " = 2" \
- "print i - whatis with side effects (1)"
+ "print i - whatis with side effects, 1"
gdb_test "whatis vla2\[i++ + sizeof(j++)\]" "type = int \\\[10\\\]"
gdb_test "print i" " = 2" \
- "print i - whatis with side effects (2)"
+ "print i - whatis with side effects, 2"
gdb_test "print j" " = 0" \
"print j - whatis with no side effects"
@@ -37,11 +37,11 @@ proc test_watchpoint_across_vfork { hw teststr } {
gdb_test "watch global" \
"atchpoint .*: global" \
- "Watchpoint on global variable ($teststr)"
+ "Watchpoint on global variable, $teststr"
gdb_test "continue" \
"atchpoint .*: global.*" \
- "Watchpoint triggers after vfork ($teststr)"
+ "Watchpoint triggers after vfork, $teststr"
}
if { [allow_hw_watchpoint_tests] } {
@@ -60,15 +60,15 @@ gdb_test "print repeat_p" \
gdb_test_no_output "set print null on"
gdb_test "print repeat" "= L\"A\", '$cent' <repeats 21 times>, \"B\"" \
- "print repeat (print null on)"
+ "print repeat, print null on"
gdb_test_no_output "set print elements 3"
gdb_test "print repeat" "= L\"A$cent$cent\"\.\.\." \
- "print repeat (print elements 3)"
+ "print repeat, print elements 3"
gdb_test "print repeat_p" "= $hex L\"A$cent$cent\"\.\.\." \
- "print repeat_p (print elements 3)"
+ "print repeat_p, print elements 3"
# From PR cli/14977, but here because it requires wchar_t.
gdb_test "printf \"%ls\\n\", 0" "\\(null\\)"
@@ -271,8 +271,11 @@ proc run_tests {lang} {
if {([string match "v_*" $to]
|| (![string match "v_*" $from] && ![string match "*method" $from])
|| [string match "*method" $to])} {
- gdb_test "whatis ($to) $from" "syntax error.*" "whatis ($to) $from (syntax)"
- gdb_test "ptype ($to) $from" "syntax error.*" "ptype ($to) $from (syntax)"
+ set cmd "whatis ($to) $from"
+ gdb_test $cmd "syntax error.*" "$cmd, syntax"
+
+ set cmd "ptype ($to) $from"
+ gdb_test $cmd "syntax error.*" "$cmd, syntax"
} elseif {([string match "*float*" $from] && [string match "*array*" $to])
|| (!$float_ptr_same_size
&& ([string match "float*" $to] && [string match "*array*" $from]
@@ -289,8 +292,11 @@ proc run_tests {lang} {
|| ([string match "*ftype2" $to] && [string match "*method" $from])
|| ([string match "*method_ptr*" $to] && [string match "*method" $from])
|| ([string match "*method_ptr*" $to] && [string match "*array*" $from])} {
- gdb_test "whatis ($to) $from" "Invalid cast." "whatis ($to) $from (invalid)"
- gdb_test "ptype ($to) $from" "Invalid cast." "ptype ($to) $from (invalid)"
+ set cmd "whatis ($to) $from"
+ gdb_test $cmd "Invalid cast." "$cmd, invalid"
+
+ set cmd "ptype ($to) $from"
+ gdb_test $cmd "Invalid cast." "$cmd, invalid"
} else {
gdb_test "whatis ($to) $from" "type = [string_to_regexp $to]"
gdb_test "ptype ($to) $from" "type = $ptype"
@@ -55,12 +55,10 @@ foreach test $methods {
gdb_test "list $test" $result
gdb_test "list '$test'" $result
- if {[gdb_breakpoint $test]} {
- pass "break $test"
- }
- if {[gdb_breakpoint '$test']} {
- pass "break '$test'"
- }
+ gdb_assert { [gdb_breakpoint $test no-message] } \
+ "break $test, unquoted"
+ gdb_assert { [gdb_breakpoint '$test' no-message] } \
+ "break $test, single-quoted"
}
# PR c++/17976
@@ -502,7 +502,7 @@ proc test_enums {} {
gdb_test "print obj_with_enum" \
"\\$\[0-9\]+ = \{priv_enum = (ClassWithEnum::)?green, x = 0\}" \
- "print obj_with_enum (2)"
+ "print obj_with_enum, 2"
# print the enum member
@@ -86,7 +86,7 @@ if { !$ok } {
return
}
-set name "info breakpoints (after inferior run)"
+set name "info breakpoints, after inferior run"
gdb_test_multiple "info breakpoints" $name {
-re "$re_head${ws}$re_2_bp${ws}$re_3_bp${ws}$re_4_bp\r\n$gdb_prompt $" {
pass $name
@@ -168,12 +168,12 @@ if {[test_compiler_info {gcc-[0-3]-*}]
# and DW_AT_MIPS_linkage_name = _ZN9gnu_obj_47nowhereE .
setup_xfail *-*-*
}
-gdb_test "print test4.nowhere" "<optimized out>" "static const int initialized nowhere (print field)"
+gdb_test "print test4.nowhere" "<optimized out>" "static const int initialized nowhere, print field"
gdb_test "ptype test4.nowhere" "type = const int"
gdb_test "print test4.nowhere.nowhere" "Attempt to extract a component of a value that is not a structure."
# Same, but print the whole struct.
-gdb_test "print test4" "static nowhere = <optimized out>.*" "static const int initialized nowhere (whole struct)"
+gdb_test "print test4" "static nowhere = <optimized out>.*" "static const int initialized nowhere, whole struct"
# static const initialized in the class definition, PR gdb/11702.
if { $non_dwarf } { setup_xfail *-*-* }
@@ -43,7 +43,7 @@ gdb_continue_to_breakpoint "continue to pmi = NULL"
# ptype on pointer to data member
-set name "ptype pmi (A::j)"
+set name "ptype pmi, A::j"
gdb_test_multiple "ptype pmi" $name {
-re "type = int A::\\*\r\n$gdb_prompt $" {
pass $name
@@ -52,7 +52,7 @@ gdb_test_multiple "ptype pmi" $name {
# print pointer to data member
-set name "print pmi (A::j) "
+set name "print pmi, A::j"
gdb_test_multiple "print pmi" $name {
-re "$vhn = &A::j\r\n$gdb_prompt $" {
pass $name
@@ -77,7 +77,7 @@ gdb_test_multiple "print pmi" $name {
# print dereferenced pointer to data member
-set name "print a.*pmi (A::j)"
+set name "print a.*pmi, A::j"
gdb_test_multiple "print a.*pmi" $name {
-re "$vhn = 121\r\n$gdb_prompt $" {
pass $name
@@ -97,7 +97,7 @@ gdb_test_multiple "print a.*pmi" $name {
# print dereferenced pointer to data member
# this time, dereferenced through a pointer
-set name "print a_p->*pmi (A::j)"
+set name "print a_p->*pmi, A::j"
gdb_test_multiple "print a_p->*pmi" $name {
-re "$vhn = 121\r\n$gdb_prompt $" {
pass $name
@@ -133,7 +133,7 @@ gdb_test_multiple "set var pmi = &A::jj" $name {
# print the pointer again
-set name "print pmi (A::jj)"
+set name "print pmi, A::jj"
gdb_test_multiple "print pmi" $name {
-re "$vhn = &A::jj\r\n$gdb_prompt $" {
pass $name
@@ -150,7 +150,7 @@ gdb_test_multiple "print pmi" $name {
# print dereferenced pointer to data member again
-set name "print a.*pmi (A::jj)"
+set name "print a.*pmi, A::jj"
gdb_test_multiple "print a.*pmi" $name {
-re "$vhn = 1331\r\n$gdb_prompt $" {
pass $name
@@ -181,7 +181,7 @@ gdb_test_multiple "set var pmi = &A::j" $name {
# print dereferenced pointer to data member yet again (extra check, why not)
-set name "print a.*pmi (A::j) (again)"
+set name "print a.*pmi, A::j, again"
gdb_test_multiple "print a.*pmi" $name {
-re "$vhn = 121\r\n$gdb_prompt $" {
pass $name
@@ -209,7 +209,7 @@ gdb_test_multiple "print a.*pmi = 33" $name {
# Now check that the data really was changed
-set name "print a.*pmi (A::j) (33)"
+set name "print a.*pmi, A::j, 33"
gdb_test_multiple "print a.*pmi" $name {
-re "$vhn = 33\r\n$gdb_prompt $" {
pass $name
@@ -223,7 +223,7 @@ gdb_test_multiple "print a.*pmi" $name {
# Double-check by printing a.
-set name "print a (j = 33)"
+set name "print a, j = 33"
gdb_test_multiple "print a" $name {
-re "$vhn = \{c = 120 'x', j = 33, jj = 1331, (static|static int) s = 10, (_vptr.A|_vptr\\$) = ($hex|$hex <A virtual table>)\}\r\n$gdb_prompt $" {
pass $name
@@ -257,7 +257,7 @@ gdb_test_multiple "print a_p->*pmi = 44" $name {
# Check that the data really was changed
-set name "print a_p->*pmi (44)"
+set name "print a_p->*pmi, 44"
gdb_test_multiple "print a_p->*pmi" $name {
-re "$vhn = 44\r\n$gdb_prompt $" {
pass $name
@@ -271,7 +271,7 @@ gdb_test_multiple "print a_p->*pmi" $name {
# Double-check by printing a.
-set name "print a (j = 44)"
+set name "print a, j = 44"
gdb_test_multiple "print a" $name {
-re "$vhn = \{c = 120 'x', j = 44, jj = 1331, (static|static int) s = 10, (_vptr.A|_vptr\\$) = ($hex|$hex <A virtual table>)\}\r\n$gdb_prompt $" {
pass $name
@@ -152,12 +152,10 @@ foreach test $methods {
gdb_test "list -qualified $func" $result
gdb_test "list -qualified '$func'" $result
- if {[gdb_breakpoint "-qualified $func"]} {
- pass "break -qualified $func"
- }
- if {[gdb_breakpoint "-qualified '$func'"]} {
- pass "break -qualified '$func'"
- }
+ gdb_assert { [gdb_breakpoint "-qualified $func" no-message] } \
+ "break -qualified $func, unquoted"
+ gdb_assert { [gdb_breakpoint "-qualified '$func'" no-message] } \
+ "break -qualified $func, single-quoted"
}
# The tests above use -qualified to explicitly pick the one "test"
@@ -50,11 +50,11 @@ proc test_break { lang } {
incr idx
}
set expect [join $menu_items {.*[\r\n]*}]
- gdb_test_multiple "break A::method" "breaking in method ($lang)" {
+ gdb_test_multiple "break A::method" "breaking in method, $lang" {
-re $expect {
gdb_test "0" \
"canceled" \
- "breaking in method ($lang)"
+ $gdb_test_name
}
}
}
@@ -51,10 +51,10 @@ proc test_expr { args } {
}
set last_ent [expr [llength $args] - 1]
set testname [lindex $args $last_ent]
- gdb_test_no_output [lindex $args 0] "$testname (setup)"
+ gdb_test_no_output [lindex $args 0] "$testname, setup"
for {set x 1} {$x < $last_ent} {set x [expr $x + 2]} {
- gdb_test [lindex $args $x] [lindex $args [expr $x + 1]] "$testname ([lindex $args $x])"
+ gdb_test [lindex $args $x] [lindex $args [expr $x + 1]] "$testname, [lindex $args $x]"
}
}
@@ -269,7 +269,7 @@ proc test_nested_limit {limit log} {
}
gdb_test "show print type nested-type-limit" \
"Will print $lstr nested types defined in a class" \
- "show print type nested-type-limit ($limit)"
+ "show print type nested-type-limit, $limit"
} else {
send_log "Tree to $limit levels:\n"
}
@@ -283,7 +283,7 @@ proc test_nested_limit {limit log} {
# the outermost node.
set result [lindex $result 0]
lassign $result type access key name children
- cp_test_ptype_class $name "ptype $name (limit = $limit)" $key \
+ cp_test_ptype_class $name "ptype $name, limit = $limit" $key \
$name $children
}
}
@@ -248,7 +248,7 @@ foreach ovld $overloads {
append bptable [format "\r\n\[0-9\]+\[\t \]+breakpoint\[\t \]+keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(%s\\) at.*$srcfile:%d" $ovld \
$line($type_map("$ovld"))]
}
-gdb_test "info break" $bptable "breakpoint info (after setting one-by-one)"
+gdb_test "info break" $bptable "breakpoint info, after setting one-by-one"
# Test choice "cancel".
# This is copy-and-paste from set_bp_overloaded.
@@ -288,7 +288,7 @@ gdb_expect {
}
}
-gdb_test "info break" $bptable "breakpoint info (after cancel)"
+gdb_test "info break" $bptable "breakpoint info, after cancel"
# Test that if the user selects multiple entries from the option list,
# GDB creates one breakpoint per entry.
@@ -325,7 +325,7 @@ gdb_expect {
}
}
-gdb_test "info breakpoints" "No breakpoints, watchpoints, tracepoints, or catchpoints." "breakpoint info (after delete)"
+gdb_test "info breakpoints" "No breakpoints, watchpoints, tracepoints, or catchpoints." "breakpoint info, after delete"
@@ -375,7 +375,7 @@ foreach ovld {void char signed_char unsigned_char short_int \
$types($ovld) $line($ovld)]
}
-gdb_test "info break" $bptable "breakpoint info (after setting on all)"
+gdb_test "info break" $bptable "breakpoint info, after setting on all"
# Run through each breakpoint.
proc continue_to_bp_overloaded {bpnumber might_fail line argtype argument} {
@@ -72,22 +72,22 @@ gdb_test "print cbvDtorDel (*dtorDel)" \
# Test that GDB calls the correct copy ctor
gdb_test "print cbvFourCCtor (fourCctor_c0v0)" "13" \
- "call cbvFourCCtor (c0v0)"
+ "call cbvFourCCtor, c0v0"
gdb_test "print fourCctor_c0v0.x" "2" \
"cbv argument 'twoCctor_c0v0' should not change"
gdb_test "print cbvFourCCtor (fourCctor_c1v0)" "14" \
- "call cbvFourCCtor (c1v0)"
+ "call cbvFourCCtor, c1v0"
gdb_test "print fourCctor_c1v0.x" "2" \
"cbv argument 'twoCctor_c1v0' should not change"
gdb_test "print cbvFourCCtor (fourCctor_c0v1)" "15" \
- "call cbvFourCCtor (c0v1)"
+ "call cbvFourCCtor, c0v1"
gdb_test "print fourCctor_c0v1.x" "2" \
"cbv argument 'twoCctor_c0v1' should not change"
gdb_test "print cbvFourCCtor (fourCctor_c1v1)" "16" \
- "call cbvFourCCtor (c1v1)"
+ "call cbvFourCCtor, c1v1"
gdb_test "print fourCctor_c1v1.x" "2" \
"cbv argument 'twoCctor_c1v1' should not change"
@@ -396,12 +396,12 @@ proc test_for_class { prefix states cbvfun data_field length} {
gdb_test "print ${cbvfun}<$name> (${name}_var)" " = $expected" \
"call '$cbvfun'"
gdb_test "print ${name}_var.${data_field}\[0\]" " = $ORIGINAL" \
- "cbv argument should not change (item 0)"
+ "cbv argument should not change, item 0"
if {$length > 1} {
set last_index [expr $length - 1]
gdb_test "print ${name}_var.${data_field}\[$last_index\]" \
" = $ORIGINAL" \
- "cbv argument should not change (item $last_index)"
+ "cbv argument should not change, item $last_index"
}
if {$dtor == "explicit"} {
if {$cctor == "defaultedIn"
@@ -641,7 +641,8 @@ foreach t [list "int" "char" "Empty<int>"] {
gdb_test "break Foozle::fogey<$t>" "Breakpoint.*at.* \\(3 locations\\)"
foreach u [list "int" "char" "Empty<int>"] {
gdb_breakpoint "Foozle<$t>::fogey<$u>" message
- gdb_breakpoint "Foozle<$t>::fogey<$u> ($u)" message
+ gdb_assert { [gdb_breakpoint "Foozle<$t>::fogey<$u> ($u)" no-message] } \
+ "break Foozle<$t>::fogey<$u> ($u), success"
}
}
@@ -667,10 +668,14 @@ foreach t [list "Empty" "Foozle"] {
# Try a specific instance, both with and without whitespace
# after the template-template parameter.
- gdb_breakpoint "operator< <$tt> ($tt&, $tt&)" message
- gdb_breakpoint "operator< <$tt > ($tt&, $tt&)" message
- gdb_breakpoint "operator<< <$tt> ($tt&, $tt&)" message
- gdb_breakpoint "operator<< <$tt > ($tt&, $tt&)" message
+ set loc "operator< <$tt> ($tt&, $tt&)"
+ gdb_assert { [gdb_breakpoint $loc no-message] } "break $loc, success"
+ set loc "operator< <$tt > ($tt&, $tt&)"
+ gdb_assert { [gdb_breakpoint $loc no-message] } "break $loc, success"
+ set loc "operator<< <$tt> ($tt&, $tt&)"
+ gdb_assert { [gdb_breakpoint $loc no-message] } "break $loc, success"
+ set loc "operator<< <$tt > ($tt&, $tt&)"
+ gdb_assert { [gdb_breakpoint $loc no-message] } "break $loc, success"
}
# Test that "-qualified" finds no matching locations.
@@ -122,9 +122,9 @@ proc test_1 { _cv _cdw64 _lv _ldw64 {_string_form ""}} {
gdb_breakpoint "bar_label"
gdb_continue_to_breakpoint "foo \\(1\\)"
- gdb_test "next" "foo \\(2\\).*" "next to foo (2)"
- gdb_test "next" "foo \\(3\\).*" "next to foo (3)"
- gdb_test "next" "foo \\(4\\).*" "next to foo (4)"
+ gdb_test "next" "foo \\(2\\).*" "next to foo(2)"
+ gdb_test "next" "foo \\(3\\).*" "next to foo(3)"
+ gdb_test "next" "foo \\(4\\).*" "next to foo(4)"
}
@@ -41,19 +41,19 @@ gdb_test "print foo(2,3,4)" \
gdb_test "print foo(0,0,0)" \
"no such vector element" \
- "print an invalid array index (0,0,0)"
+ "print an invalid array index @ 0,0,0"
gdb_test "print foo(2,3,5)" \
"no such vector element" \
- "print an invalid array index (2,3,5)"
+ "print an invalid array index @ 2,3,5"
gdb_test "print foo(2,4,4)" \
"no such vector element" \
- "print an invalid array index (2,4,4)"
+ "print an invalid array index @ 2,4,4"
gdb_test "print foo(3,3,4)" \
"no such vector element" \
- "print an invalid array index (3,3,4)"
+ "print an invalid array index @ 3,3,4"
gdb_test "print foo" \
{ = \(\(\(10, 10\) \(10, 10\) \(10, 10\)\) \(\(10, 10\) \(10, 10\) \(10, 10\)\) \(\(10, 10\) \(10, 10\) \(10, 10\)\) \(\(10, 10\) \(10, 10\) \(10, 20\)\)\)} \
@@ -95,7 +95,7 @@ gdb_assert {$found_dealloc_breakpoint} "ran all compiled in tests"
foreach var {array_1d_p array_2d_p allocatable_array_1d \
allocatable_array_2d} {
- gdb_test_multiple "p size ($var, 3)" "p size ($var, 3)" {
+ gdb_test_multiple "p size ($var, 3)" "" {
-re -wrap "DIM argument to SIZE must be between 1 and \[1-2\]" {
pass $gdb_test_name
}
@@ -129,7 +129,7 @@ gdb_continue_to_breakpoint "Final Breakpoint"
foreach var {array_1d_p array_2d_p allocatable_array_1d \
allocatable_array_2d} {
- gdb_test_multiple "p size ($var)" "p size ($var)" {
+ gdb_test_multiple "p size ($var)" "" {
-re -wrap "SIZE can only be used on allocated/associated arrays" {
pass $gdb_test_name
}
@@ -32,32 +32,32 @@ if ![fortran_runto_main] {
gdb_breakpoint [gdb_get_line_number "vla1-allocated"]
gdb_continue_to_breakpoint "vla1-allocated"
gdb_test "print l" " = \\.TRUE\\." \
- "print vla1 allocation status (allocated)"
+ "print vla1 allocation status, allocated"
gdb_breakpoint [gdb_get_line_number "vla2-allocated"]
gdb_continue_to_breakpoint "vla2-allocated"
gdb_test "print l" " = \\.TRUE\\." \
- "print vla2 allocation status (allocated)"
+ "print vla2 allocation status, allocated"
gdb_breakpoint [gdb_get_line_number "pvla-associated"]
gdb_continue_to_breakpoint "pvla-associated"
gdb_test "print l" " = \\.TRUE\\." \
- "print pvla associated status (associated)"
+ "print pvla associated status, associated"
gdb_breakpoint [gdb_get_line_number "pvla-re-associated"]
gdb_continue_to_breakpoint "pvla-re-associated"
gdb_test "print l" " = \\.TRUE\\." \
- "print pvla associated status (re-associated)"
+ "print pvla associated status, re-associated"
gdb_breakpoint [gdb_get_line_number "pvla-deassociated"]
gdb_continue_to_breakpoint "pvla-deassociated"
gdb_test "print l" " = \\.FALSE\\." \
- "print pvla allocation status (deassociated)"
+ "print pvla allocation status, deassociated"
gdb_breakpoint [gdb_get_line_number "vla1-deallocated"]
gdb_continue_to_breakpoint "vla1-deallocated"
gdb_test "print l" " = \\.FALSE\\." \
- "print vla1 allocation status (deallocated)"
+ "print vla1 allocation status, deallocated"
gdb_test "print vla1" " = <not allocated>" \
"print deallocated vla1"
@@ -74,12 +74,12 @@ gdb_test "print charactervla(5,5,5)" " = 'K'" \
gdb_breakpoint [gdb_get_line_number "vlas-modified"]
gdb_continue_to_breakpoint "vlas-modified"
-gdb_test "print intvla(5,5,5)" " = 42" "print intvla(5,5,5) (2nd)"
+gdb_test "print intvla(5,5,5)" " = 42" "print intvla(5,5,5), 2nd"
gdb_test "print realvla(5,5,5)" " = 4.13\\d+" \
- "print realvla(5,5,5) (2nd)"
+ "print realvla(5,5,5), 2nd"
gdb_test "print complexvla(5,5,5)" " = \\\(-3,2\\\)" \
- "print complexvla(5,5,5) (2nd)"
+ "print complexvla(5,5,5), 2nd"
gdb_test "print logicalvla(5,5,5)" " = \\.FALSE\\." \
- "print logicalvla(5,5,5) (2nd)"
+ "print logicalvla(5,5,5), 2nd"
gdb_test "print charactervla(5,5,5)" " = 'X'" \
- "print charactervla(5,5,5) (2nd)"
+ "print charactervla(5,5,5), 2nd"
@@ -33,7 +33,7 @@ set real [fortran_real4]
# Pass fixed array to function and handle them as vla in function.
gdb_breakpoint [gdb_get_line_number "not-filled"]
-gdb_continue_to_breakpoint "not-filled (1st)"
+gdb_continue_to_breakpoint "not-filled, 1st"
gdb_test "ptype array1" "type = $int \\\(42,42\\\)" \
"ptype array1 (passed fixed)"
gdb_test "ptype array2" "type = $real \\\(42,42,42\\\)" \
@@ -44,15 +44,15 @@ gdb_test "ptype array2(13, 11, 5)" "type = $real" \
"ptype array2(13, 11, 5) (passed fixed)"
# Pass sub arrays to function and handle them as vla in function.
-gdb_continue_to_breakpoint "not-filled (2nd)"
+gdb_continue_to_breakpoint "not-filled, 2nd"
gdb_test "ptype array1" "type = $int \\\(6,6\\\)" \
- "ptype array1 (passed sub-array)"
+ "ptype array1, passed sub-array"
gdb_test "ptype array2" "type = $real \\\(6,6,6\\\)" \
- "ptype array2 (passed sub-array)"
+ "ptype array2, passed sub-array"
gdb_test "ptype array1(3, 3)" "type = $int" \
- "ptype array1(3, 3) (passed sub-array)"
+ "ptype array1(3, 3), passed sub-array"
gdb_test "ptype array2(4, 4, 4)" "type = $real" \
- "ptype array2(4, 4, 4) (passed sub-array)"
+ "ptype array2(4, 4, 4), passed sub-array"
# Check ptype outside of bounds. This should not crash GDB.
gdb_test "ptype array1(100, 100)" "no such vector element" \
@@ -61,15 +61,15 @@ gdb_test "ptype array2(100, 100, 100)" "no such vector element" \
"ptype array2(100, 100, 100) subarray do not crash (passed sub-array)"
# Pass vla to function.
-gdb_continue_to_breakpoint "not-filled (3rd)"
+gdb_continue_to_breakpoint "not-filled, 3rd"
gdb_test "ptype array1" "type = $int \\\(20,20\\\)" \
- "ptype array1 (passed vla)"
+ "ptype array1, passed vla"
gdb_test "ptype array2" "type = $real \\\(10,10,10\\\)" \
- "ptype array2 (passed vla)"
+ "ptype array2, passed vla"
gdb_test "ptype array1(3, 3)" "type = $int" \
- "ptype array1(3, 3) (passed vla)"
+ "ptype array1(3, 3), passed vla"
gdb_test "ptype array2(4, 4, 4)" "type = $real" \
- "ptype array2(4, 4, 4) (passed vla)"
+ "ptype array2(4, 4, 4), passed vla"
# Check ptype outside of bounds. This should not crash GDB.
gdb_test "ptype array1(100, 100)" "no such vector element" \
@@ -83,11 +83,11 @@ gdb_breakpoint [gdb_get_line_number "end-of-bar"]
gdb_continue_to_breakpoint "end-of-bar"
gdb_test "ptype array1" \
"type = (PTR TO -> \\( )?$int \\(\\*\\)\\)?" \
- "ptype array1 (arbitrary length)"
+ "ptype array1, arbitrary length"
gdb_test "ptype array2" \
"type = (PTR TO -> \\( )?$int \\(4:9,10:\\*\\)\\)?" \
- "ptype array2 (arbitrary length)"
+ "ptype array2, arbitrary length"
gdb_test "ptype array1(100)" "type = $int" \
- "ptype array1(100) (arbitrary length)"
+ "ptype array1(100), arbitrary length"
gdb_test "ptype array2(4,100)" "type = $int" \
- "ptype array2(4,100) (arbitrary length)"
+ "ptype array2(4,100), arbitrary length"
@@ -45,7 +45,7 @@ gdb_test "print array1(1, 1)" " = 30" \
"print array1(1, 1) after filled in foo (passed fixed array)"
gdb_breakpoint [gdb_get_line_number "array2-almost-filled"]
-gdb_continue_to_breakpoint "array2-almost-filled (1st)"
+gdb_continue_to_breakpoint "array2-almost-filled, 1st"
# array2 size is 296352 bytes.
gdb_test_no_output "set max-value-size 1024*1024"
gdb_test "print array2" " = \\( *\\( *\\( *30, *3, *3,\[()3, .\]*\\)" \
@@ -57,40 +57,40 @@ gdb_test "print array2" " = \\( *\\( *\\( *30, *20, *3,\[()3, .\]*\\)" \
# Try to access values from a fixed sub-array handled as VLA in subroutine.
-gdb_continue_to_breakpoint "not-filled (2nd)"
+gdb_continue_to_breakpoint "not-filled, 2nd"
gdb_test "print array1" " = \\(\[()5, .\]*\\)" \
- "print passed array1 in foo (passed sub-array)"
+ "print passed array1 in foo, passed sub-array"
-gdb_continue_to_breakpoint "array1-filled (2nd)"
+gdb_continue_to_breakpoint "array1-filled, 2nd"
gdb_test "print array1(5, 5)" " = 5" \
- "print array1(5, 5) after filled in foo (passed sub-array)"
+ "print array1(5, 5) after filled in foo, passed sub-array"
gdb_test "print array1(1, 1)" " = 30" \
- "print array1(1, 1) after filled in foo (passed sub-array)"
+ "print array1(1, 1) after filled in foo, passed sub-array"
-gdb_continue_to_breakpoint "array2-almost-filled (2nd)"
+gdb_continue_to_breakpoint "array2-almost-filled, 2nd"
gdb_test "print array2" " = \\( *\\( *\\( *30, *3, *3,\[()3, .\]*\\)" \
- "print array2 in foo after it was filled (passed sub-array)"
+ "print array2 in foo after it was filled, passed sub-array"
gdb_test "print array2(2,1,1)=20" " = 20" \
- "set array(2,2,2) to 20 in subroutine (passed sub-array)"
+ "set array(2,2,2) to 20 in subroutine, passed sub-array"
gdb_test "print array2" " = \\( *\\( *\\( *30, *20, *3,\[()3, .\]*\\)" \
- "print array2 in foo after it was mofified in debugger (passed sub-array)"
+ "print array2 in foo after it was mofified in debugger, passed sub-array"
# Try to access values from a VLA passed to subroutine.
-gdb_continue_to_breakpoint "not-filled (3rd)"
+gdb_continue_to_breakpoint "not-filled, 3rd"
gdb_test "print array1" " = \\(\[()42, .\]*\\)" \
- "print passed array1 in foo (passed vla)"
+ "print passed array1 in foo, passed vla"
-gdb_continue_to_breakpoint "array1-filled (3rd)"
+gdb_continue_to_breakpoint "array1-filled, 3rd"
gdb_test "print array1(5, 5)" " = 5" \
- "print array1(5, 5) after filled in foo (passed vla)"
+ "print array1(5, 5) after filled in foo, passed vla"
gdb_test "print array1(1, 1)" " = 30" \
- "print array1(1, 1) after filled in foo (passed vla)"
+ "print array1(1, 1) after filled in foo, passed vla"
-gdb_continue_to_breakpoint "array2-almost-filled (3rd)"
+gdb_continue_to_breakpoint "array2-almost-filled, 3rd"
gdb_test "print array2" " = \\( *\\( *\\( *30, *3, *3,\[()3, .\]*\\)" \
- "print array2 in foo after it was filled (passed vla)"
+ "print array2 in foo after it was filled, passed vla"
gdb_test "print array2(2,1,1)=20" " = 20" \
- "set array(2,2,2) to 20 in subroutine (passed vla)"
+ "set array(2,2,2) to 20 in subroutine, passed vla"
gdb_test "print array2" " = \\( *\\( *\\( *30, *20, *3,\[()3, .\]*\\)" \
- "print array2 in foo after it was mofified in debugger (passed vla)"
+ "print array2 in foo after it was mofified in debugger, passed vla"
@@ -39,10 +39,10 @@ gdb_test "print &vla1" \
" = \\\(PTR TO -> \\\( $real, allocatable \\\(:,:,:\\\) \\\)\\\) $hex" \
"print non-allocated &vla1"
gdb_test "print vla1(1,1,1)" "no such vector element \\\(vector not allocated\\\)" \
- "print member in non-allocated vla1 (1)"
+ "print member in non-allocated vla1, 1"
gdb_test "print vla1(101,202,303)" \
"no such vector element \\\(vector not allocated\\\)" \
- "print member in non-allocated vla1 (2)"
+ "print member in non-allocated vla1, 2"
gdb_test "print vla1(5,2,18)=1" "no such vector element \\\(vector not allocated\\\)" \
"set member in non-allocated vla1"
@@ -68,11 +68,11 @@ gdb_test "print vla1(9, 9, 9) = 999" " = 999" \
gdb_breakpoint [gdb_get_line_number "vla1-filled"]
gdb_continue_to_breakpoint "vla1-filled"
gdb_test "print vla1(3, 6, 9)" " = 42" \
- "print allocated vla1(3,6,9) after specific assignment (filled)"
+ "print allocated vla1(3,6,9) after specific assignment, filled"
gdb_test "print vla1(1, 3, 8)" " = 1001" \
- "print allocated vla1(1,3,8) after specific assignment (filled)"
+ "print allocated vla1(1,3,8) after specific assignment, filled"
gdb_test "print vla1(9, 9, 9)" " = 999" \
- "print allocated vla1(9,9,9) after assignment in debugger (filled)"
+ "print allocated vla1(9,9,9) after assignment in debugger, filled"
# Try to access values in undefined pointer to VLA (dangling)
gdb_test "print pvla" " = <not associated>" "print undefined pvla"
@@ -120,11 +120,11 @@ gdb_test "print pvla" " = <not associated>" \
gdb_breakpoint [gdb_get_line_number "vla1-deallocated"]
gdb_continue_to_breakpoint "vla1-deallocated"
gdb_test "print vla1(3, 6, 9)" "no such vector element \\\(vector not allocated\\\)" \
- "print allocated vla1(3,6,9) after specific assignment (deallocated)"
+ "print allocated vla1(3,6,9) after specific assignment, deallocated"
gdb_test "print vla1(1, 3, 8)" "no such vector element \\\(vector not allocated\\\)" \
- "print allocated vla1(1,3,8) after specific assignment (deallocated)"
+ "print allocated vla1(1,3,8) after specific assignment, deallocated"
gdb_test "print vla1(9, 9, 9)" "no such vector element \\\(vector not allocated\\\)" \
- "print allocated vla1(9,9,9) after assignment in debugger (deallocated)"
+ "print allocated vla1(9,9,9) after assignment in debugger, deallocated"
# Try to assign VLA to user variable
@@ -147,7 +147,7 @@ gdb_test "print \$myvar" \
" = \\( *\\( *\\( *1311, *1311, *1311,\[()1311, .\]*\\)" \
"print \$myvar set to vla1"
-gdb_test "next" "\\d+.*vla1\\(1, 3, 8\\) = 1001" "next (2)"
+gdb_test "next" "\\d+.*vla1\\(1, 3, 8\\) = 1001" "next, 2"
gdb_test "print \$myvar(3,6,9)" " = 1311"
gdb_breakpoint [gdb_get_line_number "pvla-associated"]
@@ -91,9 +91,9 @@ gdb_test "guile (print (eq? bframe (newest-frame)))" \
#t "newest frame -vs- newest frame"
gdb_test "guile (print (eq? f0 f1))" \
- "#f" "test equality comparison (false)"
+ "#f" "test equality comparison, false"
gdb_test "guile (print (eq? f0 f0))" \
- "#t" "test equality comparison (true)"
+ "#t" "test equality comparison, true"
gdb_test "guile (print (frame-valid? f0))" \
"#t" "test frame-valid?"
gdb_test "guile (print (frame-name f0))" \
@@ -62,11 +62,11 @@ gdb_test_multiline "Simple gdb boolean parameter" \
"end"
with_test_prefix "test-param" {
- gdb_test "guile (print (parameter-value test-param))" "= #t" "parameter value (true)"
+ gdb_test "guile (print (parameter-value test-param))" "= #t" "parameter value, true"
gdb_test "show print test-param" "The state of the Test Parameter is on." "show parameter on"
gdb_test_no_output "set print test-param off"
gdb_test "show print test-param" "The state of the Test Parameter is off." "show parameter off"
- gdb_test "guile (print (parameter-value test-param))" "= #f" "parameter value (false)"
+ gdb_test "guile (print (parameter-value test-param))" "= #f" "parameter value, false"
gdb_test "help show print test-param" "Show the state of the boolean test-param.*" "show help"
gdb_test "help set print test-param" "Set the state of the boolean test-param.*" "set help"
gdb_test "help set print" "set print test-param -- Set the state of the boolean test-param.*" "general help"
@@ -94,11 +94,11 @@ gdb_test_multiline "enum gdb parameter" \
"end"
with_test_prefix "test-enum-param" {
- gdb_test "guile (print (parameter-value test-enum-param))" "one" "enum parameter value (one)"
+ gdb_test "guile (print (parameter-value test-enum-param))" "one" "enum parameter value, one"
gdb_test "show print test-enum-param" "The state of the enum is one." "show initial value"
gdb_test_no_output "set print test-enum-param two"
gdb_test "show print test-enum-param" "The state of the enum is two." "show new value"
- gdb_test "guile (print (parameter-value test-enum-param))" "two" "enum parameter value (two)"
+ gdb_test "guile (print (parameter-value test-enum-param))" "two" "enum parameter value, two"
gdb_test "set print test-enum-param three" "Undefined item: \"three\".*" "set invalid enum parameter"
}
@@ -241,14 +241,14 @@ foreach_with_prefix kind {
with_test_prefix "test-$kind-param" {
gdb_test "guile (print (parameter-value test-$kind-param))" \
- 3 "$kind parameter value (3)"
+ 3 "$kind parameter value, 3"
gdb_test "show print test-$kind-param" \
"The state of $kind is 3." "show initial value"
gdb_test_no_output "set print test-$kind-param 2"
gdb_test "show print test-$kind-param" \
"The state of $kind is 2." "show new value"
gdb_test "guile (print (parameter-value test-$kind-param))" \
- 2 "$kind parameter value (2)"
+ 2 "$kind parameter value, 2"
scm_param_test_maybe_no_output \
"guile (set-parameter-value! test-$kind-param #:unlimited)" \
$param_set_unlimited
@@ -257,18 +257,18 @@ foreach_with_prefix kind {
"show unlimited value"
gdb_test_no_output "guile (set-parameter-value! test-$kind-param 1)"
gdb_test "guile (print (parameter-value test-$kind-param))" \
- 1 "$kind parameter value (1)"
+ 1 "$kind parameter value, 1"
gdb_test_no_output "guile (set-parameter-value! test-$kind-param 0)"
gdb_test "guile (print (parameter-value test-$kind-param))" \
- $param_get_zero "$kind parameter value (0)"
+ $param_get_zero "$kind parameter value, 0"
scm_param_test_maybe_no_output "set print test-$kind-param -1" \
$param_set_minus_one
gdb_test "guile (print (parameter-value test-$kind-param))" \
- $param_get_minus_one "$kind parameter value (-1)"
+ $param_get_minus_one "$kind parameter value, -1"
scm_param_test_maybe_no_output "set print test-$kind-param -2" \
$param_set_minus_two
gdb_test "guile (print (parameter-value test-$kind-param))" \
- $param_get_minus_two "$kind parameter value (-2)"
+ $param_get_minus_two "$kind parameter value, -2"
}
}
@@ -378,11 +378,11 @@ gdb_test_multiline "previously ambiguously named boolean parameter" \
gdb_test_no_output "guile (register-parameter! prev-ambig)"
with_test_prefix "previously-ambiguous" {
- gdb_test "guile (print (parameter-value prev-ambig))" "= #f" "parameter value (false)"
+ gdb_test "guile (print (parameter-value prev-ambig))" "= #f" "parameter value, false"
gdb_test "show print s" "Command is not documented is off." "show parameter off"
gdb_test_no_output "set print s on"
gdb_test "show print s" "Command is not documented is on." "show parameter on"
- gdb_test "guile (print (parameter-value prev-ambig))" "= #t" "parameter value (true)"
+ gdb_test "guile (print (parameter-value prev-ambig))" "= #t" "parameter value, true"
gdb_test "help show print s" "This command is not documented." "show help"
gdb_test "help set print s" "This command is not documented." "set help"
gdb_test "help set print" "set print s -- This command is not documented.*" "general help"
@@ -37,9 +37,9 @@ gdb_install_guile_module
gdb_scm_test_silent_cmd "guile (define main-func (lookup-global-symbol \"main\"))" \
"lookup main"
gdb_test "guile (print (symbol-function? main-func))" \
- "= #t" "test (symbol-function? main)"
+ "= #t" "test, symbol-function? main"
gdb_test "guile (print (lookup-global-symbol \"junk\"))" \
- "= #f" "test (lookup-global-symbol junk)"
+ "= #f" "test, lookup-global-symbol junk"
gdb_test "guile (print (symbol-value main-func))" \
"= {int \\(int, char \[*\]\[*\]\\)} $hex \\<main\\>" "print value of main"
@@ -70,7 +70,7 @@ proc test_fields {lang} {
if {$lang == "c++"} {
# Test usage with a class.
- gdb_scm_test_silent_cmd "print c" "print value (c)"
+ gdb_scm_test_silent_cmd "print c" "print value, c"
gdb_scm_test_silent_cmd "guile (define c (history-ref 0))" \
"get value (c) from history"
gdb_scm_test_silent_cmd "guile (define fields (type-fields (value-type c)))" \
@@ -84,7 +84,7 @@ proc test_fields {lang} {
}
# Test normal fields usage in structs.
- gdb_scm_test_silent_cmd "print st" "print value (st)"
+ gdb_scm_test_silent_cmd "print st" "print value, st"
gdb_scm_test_silent_cmd "guile (define st (history-ref 0))" \
"get value (st) from history"
gdb_scm_test_silent_cmd "guile (define st-type (value-type st))" \
@@ -120,7 +120,7 @@ proc test_fields {lang} {
"check field iterator on bad type"
# Test type-array.
- gdb_scm_test_silent_cmd "print ar" "print value (ar)"
+ gdb_scm_test_silent_cmd "print ar" "print value, ar"
gdb_scm_test_silent_cmd "guile (define ar (history-ref 0))" \
"get value (ar) from history"
gdb_scm_test_silent_cmd "guile (define ar0 (value-subscript ar 0))" \
@@ -133,11 +133,11 @@ proc test_fields {lang} {
# Test type-vector.
# Note: vectors cast differently than arrays. Here ar[0] is replicated
# for the size of the vector.
- gdb_scm_test_silent_cmd "print vec_data_1" "print value (vec_data_1)"
+ gdb_scm_test_silent_cmd "print vec_data_1" "print value, vec_data_1"
gdb_scm_test_silent_cmd "guile (define vec_data_1 (history-ref 0))" \
"get value (vec_data_1) from history"
- gdb_scm_test_silent_cmd "print vec_data_2" "print value (vec_data_2)"
+ gdb_scm_test_silent_cmd "print vec_data_2" "print value, vec_data_2"
gdb_scm_test_silent_cmd "guile (define vec_data_2 (history-ref 0))" \
"get value (vec_data_2) from history"
@@ -192,7 +192,7 @@ proc test_equality {lang} {
proc test_enums {} {
with_test_prefix "test_enum" {
- gdb_scm_test_silent_cmd "print e" "print value (e)"
+ gdb_scm_test_silent_cmd "print e" "print value, e"
gdb_scm_test_silent_cmd "guile (define e (history-ref 0))" \
"get value (e) from history"
gdb_scm_test_silent_cmd "guile (define fields (type-fields (value-type e)))" \
@@ -208,9 +208,9 @@ proc test_enums {} {
gdb_test "guile (print (type-num-fields (value-type e)))" \
"= 3" "check the number of enum values"
gdb_test "guile (print (field-name (type-field (value-type e) \"v1\")))" \
- "= v1" "check enum field lookup by name (v1)"
+ "= v1" "check enum field lookup by name, v1"
gdb_test "guile (print (field-name (type-field (value-type e) \"v3\")))" \
- "= v3" "check enum field lookup by name (v3)"
+ "= v3" "check enum field lookup by name, v3"
gdb_test "guile (print (iterator-map field-enumval (make-field-iterator (value-type e))))" \
"\\(0 1 2\\)" "check enum fields iteration"
}
@@ -218,7 +218,7 @@ proc test_enums {} {
proc test_base_class {} {
with_test_prefix "test_base_class" {
- gdb_scm_test_silent_cmd "print d" "print value (d)"
+ gdb_scm_test_silent_cmd "print d" "print value, d"
gdb_scm_test_silent_cmd "guile (define d (history-ref 0))" \
"get value (d) from history"
gdb_scm_test_silent_cmd "guile (define fields (type-fields (value-type d)))" \
@@ -226,9 +226,9 @@ proc test_base_class {} {
gdb_test "guile (print (length fields))" \
"= 3" "check the number of fields"
gdb_test "guile (print (field-baseclass? (car fields)))" \
- "= #t" "check base class (fields\[0\])"
+ "= #t" {check base class, fields[0]}
gdb_test "guile (print (field-baseclass? (cadr fields)))" \
- "= #f" "check base class (fields\[1\])"
+ "= #f" {check base class, fields[1]}
}
}
@@ -236,7 +236,7 @@ proc test_range {} {
with_test_prefix "test_range" {
with_test_prefix "on ranged value" {
# Test a valid range request.
- gdb_scm_test_silent_cmd "print ar" "print value (ar)"
+ gdb_scm_test_silent_cmd "print ar" "print value, ar"
gdb_scm_test_silent_cmd "guile (define ar (history-ref 0))" \
"get value (ar) from history"
gdb_test "guile (print (length (type-range (value-type ar))))" \
@@ -247,7 +247,7 @@ proc test_range {} {
with_test_prefix "on unranged value" {
# Test where a range does not exist.
- gdb_scm_test_silent_cmd "print st" "print value (st)"
+ gdb_scm_test_silent_cmd "print st" "print value, st"
gdb_scm_test_silent_cmd "guile (define st (history-ref 0))" \
"get value (st) from history"
gdb_test "guile (print (type-range (value-type st)))" \
@@ -256,7 +256,7 @@ proc test_range {} {
}
with_test_prefix "on flexible array member" {
- gdb_scm_test_silent_cmd "print f" "print value (f)"
+ gdb_scm_test_silent_cmd "print f" "print value, f"
gdb_scm_test_silent_cmd "guile (define f (history-ref 0))" \
"get value (f) from history"
gdb_test "guile (print (type-range (field-type (type-field (value-type (value-dereference f)) \"items\"))))" \
@@ -41,25 +41,25 @@ proc test_stepi_nexti {} {
set line [mi_execute_to "exec-step-instruction" "end-stepping-range" "main" "" \
".*basics.c" "\[0-9\]+" "" "step-instruction at main"]
if { $line >= $line_main_body && $line <= $line_main_hello } {
- pass "step-instruction at main (line check)"
+ pass "step-instruction at main, line check"
} else {
- fail "step-instruction at main (line check)"
+ fail "step-instruction at main, line check"
}
set line [mi_execute_to "exec-next-instruction" "end-stepping-range" "main" "" \
".*basics.c" "\[0-9\]+" "" "next-instruction at main"]
if { $line >= $line_main_body && $line <= $line_main_hello } {
- pass "next-instruction at main (line check)"
+ pass "next-instruction at main, line check"
} else {
- fail "next-instruction at main (line check)"
+ fail "next-instruction at main, line check"
}
set line [mi_execute_to "exec-next-instruction" "end-stepping-range" "main" "" \
".*basics.c" "\[0-9\]+" "" "next-instruction at main 2"]
if { $line >= $line_main_body && $line <= $line_main_hello } {
- pass "next-instruction at main 2 (line check)"
+ pass "next-instruction at main 2, line check"
} else {
- fail "next-instruction at main 2 (line check)"
+ fail "next-instruction at main 2, line check"
}
}
@@ -150,7 +150,7 @@ mi_gdb_test "-var-update *" \
"update all vars: linteger changed"
# Step over "lpinteger = &linteger;"
-mi_step_to "do_locals_tests" "" "var-cmd.c" [expr $line_dlt_linteger + 1] "step at do_locals_tests (2)"
+mi_step_to "do_locals_tests" "" "var-cmd.c" [expr $line_dlt_linteger + 1] "step at do_locals_tests, 2"
# Test: c_variable-2.3
# Desc: check whether only lpinteger changed
@@ -159,7 +159,7 @@ mi_gdb_test "-var-update *" \
"update all vars: lpinteger changed"
# Step over "lcharacter = 'a';"
-mi_step_to "do_locals_tests" "" "var-cmd.c" [expr $line_dlt_linteger + 2] "step at do_locals_tests (3)"
+mi_step_to "do_locals_tests" "" "var-cmd.c" [expr $line_dlt_linteger + 2] "step at do_locals_tests, 3"
# Test: c_variable-2.4
# Desc: check whether only lcharacter changed
@@ -168,7 +168,7 @@ mi_gdb_test "-var-update *" \
"update all vars: lcharacter changed"
# Step over "lpcharacter = &lcharacter;"
-mi_step_to "do_locals_tests" "" "var-cmd.c" [expr $line_dlt_linteger + 3] "step at do_locals_tests (4)"
+mi_step_to "do_locals_tests" "" "var-cmd.c" [expr $line_dlt_linteger + 3] "step at do_locals_tests, 4"
# Test: c_variable-2.5
# Desc: check whether only lpcharacter changed
@@ -189,7 +189,7 @@ mi_gdb_test "-var-update *" \
# lsimple.character = 'a';
mi_execute_to "exec-step 9" "end-stepping-range" "do_locals_tests" "" \
- "var-cmd.c" [expr $line_dlt_linteger + 12] "" "step at do_locals_tests (5)"
+ "var-cmd.c" [expr $line_dlt_linteger + 12] "" "step at do_locals_tests, 5"
# Test: c_variable-2.6
# Desc: check whether llong, lplong, lfloat, lpfloat, ldouble, lpdouble, lsimple.integer,
@@ -207,7 +207,7 @@ mi_gdb_test "-var-update *" \
set line_dlt_4321 [gdb_get_line_number "linteger = 4321;"]
mi_execute_to "exec-step 4" "end-stepping-range" "do_locals_tests" "" \
- "var-cmd.c" $line_dlt_4321 "" "step at do_locals_tests (6)"
+ "var-cmd.c" $line_dlt_4321 "" "step at do_locals_tests, 6"
# Test: c_variable-2.7
# Desc: check whether (lsimple.signed_character, lsimple.char_ptr) lpsimple, func changed
@@ -226,7 +226,7 @@ mi_gdb_test "-var-update *" \
# lsimple.character = 'b';
mi_execute_to "exec-step 8" "end-stepping-range" "do_locals_tests" "" \
- "var-cmd.c" [expr $line_dlt_4321 + 8] "" "step at do_locals_tests (7)"
+ "var-cmd.c" [expr $line_dlt_4321 + 8] "" "step at do_locals_tests, 7"
# Test: c_variable-2.8
# Desc: check whether linteger, lcharacter, llong, lfoat, ldouble, lsimple.integer,
@@ -374,7 +374,7 @@ mi_gdb_test "-var-assign func do_block_tests" \
mi_gdb_test "-var-update *" \
"\\^done,changelist=\\\[\\\]" \
- "assign same value to func (update)"
+ "assign same value to func, update"
mi_gdb_test "-var-create array_ptr * array_ptr" \
"\\^done,name=\"array_ptr\",numchild=\"1\",value=\"$hex <array>\",type=\"int \\*\",has_more=\"0\"" \
@@ -386,7 +386,7 @@ mi_gdb_test "-var-assign array_ptr array2" \
mi_gdb_test "-var-update *" \
"\\^done,changelist=\\\[\{name=\"array_ptr\",in_scope=\"true\",type_changed=\"false\",has_more=\"0\"\}\\\]" \
- "assign array to pointer (update)"
+ "assign array to pointer, update"
mi_gdb_test "-var-assign array_ptr array2" \
"\\^done,value=\"$hex <array2>\"" \
@@ -394,7 +394,7 @@ mi_gdb_test "-var-assign array_ptr array2" \
mi_gdb_test "-var-update *" \
"\\^done,changelist=\\\[\\\]" \
- "assign same array to pointer (update)"
+ "assign same array to pointer, update"
######
@@ -434,7 +434,7 @@ mi_gdb_test "-var-update *" \
clear_xfail *-*-*
mi_step_to "subroutine1" "\{name=\"i\",value=\".*\"\},\{name=\"l\",value=\".*\"\}" \
- "var-cmd.c" [expr $line_subroutine1_body + 2] "step at subroutine1 (2)"
+ "var-cmd.c" [expr $line_subroutine1_body + 2] "step at subroutine1, 2"
# Test: c_variable-2.13
# Desc: change subroutine1 local i
@@ -443,7 +443,7 @@ mi_gdb_test "-var-update *" \
"update all vars: i changed"
mi_step_to "subroutine1" "\{name=\"i\",value=\".*\"\},\{name=\"l\",value=\".*\"\}" \
- "var-cmd.c" [expr $line_subroutine1_body + 3] "step at subroutine1 (3)"
+ "var-cmd.c" [expr $line_subroutine1_body + 3] "step at subroutine1, 3"
# Test: c_variable-2.14
# Desc: change do_locals_tests local llong
@@ -19,15 +19,15 @@ void reference_update_tests ()
int x = 167;
/*: mi_create_varobj "RX" "rx" "create varobj for rx" :*/
int& rx = x;
- /*: mi_varobj_update RX {RX} "update RX (1)"
+ /*: mi_varobj_update RX {RX} "update RX, 1"
mi_check_varobj_value RX 167 "check RX: expect 167"
:*/
x = 567;
- /*: mi_varobj_update RX {RX} "update RX (2)"
+ /*: mi_varobj_update RX {RX} "update RX, 2"
mi_check_varobj_value RX 567 "check RX: expect 567"
:*/
x = 567;
- /*: mi_varobj_update RX {} "update RX (3)"
+ /*: mi_varobj_update RX {} "update RX, 3"
mi_delete_varobj RX "delete RX"
:*/
/* Dummy assignment to keep 'x' in scope. */
@@ -237,11 +237,11 @@ mi_list_varobj_children weird {
# Desc: change format of weird.func_ptr and weird.func_ptr_ptr
mi_gdb_test "-var-set-format weird.func_ptr hexadecimal" \
"\\^done,format=\"hexadecimal\",value=\"$hex\"" \
- "set format variable weird.func_ptr in hex (1)"
+ "set format variable weird.func_ptr in hex, 1"
mi_gdb_test "-var-show-format weird.func_ptr" \
"\\^done,format=\"hexadecimal\"" \
- "show format variable weird.func_ptr (hex)"
+ "show format variable weird.func_ptr, hex"
mi_gdb_test "-var-set-format weird.func_ptr_ptr hexadecimal" \
"\\^done,format=\"hexadecimal\",value=\"$hex\"" \
@@ -249,7 +249,7 @@ mi_gdb_test "-var-set-format weird.func_ptr_ptr hexadecimal" \
mi_gdb_test "-var-show-format weird.func_ptr_ptr" \
"\\^done,format=\"hexadecimal\"" \
- "show format variable weird.func_ptr_ptr (hex)"
+ "show format variable weird.func_ptr_ptr, hex"
mi_gdb_test "-var-set-format weird.func_ptr zero-hexadecimal" \
"\\^done,format=\"zero-hexadecimal\",value=\"$hex\"" \
@@ -257,7 +257,7 @@ mi_gdb_test "-var-set-format weird.func_ptr zero-hexadecimal" \
mi_gdb_test "-var-show-format weird.func_ptr" \
"\\^done,format=\"zero-hexadecimal\"" \
- "show format variable weird.func_ptr (zhex)"
+ "show format variable weird.func_ptr, zhex"
mi_gdb_test "-var-set-format weird.func_ptr_ptr zero-hexadecimal" \
"\\^done,format=\"zero-hexadecimal\",value=\"$hex\"" \
@@ -265,7 +265,7 @@ mi_gdb_test "-var-set-format weird.func_ptr_ptr zero-hexadecimal" \
mi_gdb_test "-var-show-format weird.func_ptr_ptr" \
"\\^done,format=\"zero-hexadecimal\"" \
- "show format variable weird.func_ptr_ptr (zhex)"
+ "show format variable weird.func_ptr_ptr, zhex"
# Test: c_variable-6.24
# Desc: format of weird and children
@@ -299,7 +299,7 @@ mi_gdb_test "-var-set-format weird.long_array natural" \
mi_gdb_test "-var-set-format weird.func_ptr hexadecimal" \
"\\^done,format=\"hexadecimal\",value=\"$hex\"" \
- "set format variable weird.func_ptr in hex (2)"
+ "set format variable weird.func_ptr in hex, 2"
mi_gdb_test "-var-set-format weird.func_ptr_struct hexadecimal" \
"\\^done,format=\"hexadecimal\",value=\"$hex\"" \
@@ -80,7 +80,7 @@ mi_gdb_test "-var-update linteger" \
mi_gdb_test "-var-info-type linteger" \
"\\^done,type=\"\"" \
- "no type for invalid variable linteger (1)"
+ "no type for invalid variable linteger, 1"
# Check global variable is still correct.
mi_gdb_test "-var-update global_simple" \
@@ -105,7 +105,7 @@ mi_gdb_test "-var-update linteger" \
mi_gdb_test "-var-info-type linteger" \
"\\^done,type=\"\"" \
- "no type for invalid variable linteger (2)"
+ "no type for invalid variable linteger, 2"
# Check global variable are still correct.
mi_gdb_test "-var-update global_simple" \
@@ -485,15 +485,15 @@ void do_at_tests ()
:*/
i++;
/*:
- mi_varobj_update F {F} "update F (1)"
- mi_check_varobj_value F 11 "check F (1)"
+ mi_varobj_update F {F} "update F, 1"
+ mi_check_varobj_value F 11 "check F, 1"
:*/
i++;
{
double i = 15;
/*:
- mi_varobj_update_with_type_change F "double" "0" "update F (2)"
- mi_check_varobj_value F 15 "check F (2)"
+ mi_varobj_update_with_type_change F "double" "0" "update F, 2"
+ mi_check_varobj_value F 15 "check F, 2"
:*/
i += 2.0;
}
@@ -506,8 +506,8 @@ void do_at_tests ()
}
i++;
/*:
- mi_varobj_update_with_type_change F "int" "0" "update F (3)"
- mi_check_varobj_value F 13 "check F (3)"
+ mi_varobj_update_with_type_change F "int" "0" "update F, 3"
+ mi_check_varobj_value F 13 "check F, 3"
:*/
i++;
do_at_tests_callee ();
@@ -139,14 +139,14 @@ gdb_test "list commonfun" "from hello.*" "list commonfun in hello"
gdb_test "print hglob" "1"
-gdb_test "print glob" "92" "print glob (${exec1})"
+gdb_test "print glob" "92" "print glob, ${exec1}"
gdb_test "inferior 3" ".*" "switch to inferior 3 to print globals"
gdb_test "print gglob" "2"
-gdb_test "print glob" "45" "print glob (${exec3})"
+gdb_test "print glob" "45" "print glob, ${exec3}"
gdb_test "list commonfun" "from goodbye.*" "list commonfun in goodbye"
@@ -62,12 +62,12 @@ proc test { inf1 inf2 } {
with_test_prefix "inf $inf1 first" {
gdb_test "inferior 2" "witching to inferior 2 .*" \
- "switch to inferior 2 (1)"
+ "switch to inferior 2, 1"
check_bt 2 "before infcall"
gdb_test "p commonfun()" "Breakpoint .*The program being debugged stopped while in a function called from GDB.*" "infcall in inferior 2"
gdb_test "inferior 1" "witching to inferior 1 .*" \
- "switch to inferior 1 (1)"
+ "switch to inferior 1, 1"
check_bt 1 "before infcall"
gdb_test "p commonfun()" "Breakpoint .*The program being debugged stopped while in a function called from GDB.*" "infcall in inferior 1"
@@ -75,13 +75,13 @@ proc test { inf1 inf2 } {
"two dummy frames"
gdb_test "inferior $inf1" "witching to inferior $inf1 .*" \
- "switch to inferior $inf1 (2)"
+ "switch to inferior $inf1, 2"
gdb_test "finish" "Run till exit from #0 commonfun .*" \
"finish in inferior $inf1"
check_bt $inf1 "after infcall"
gdb_test "inferior $inf2" "witching to inferior $inf2 .*" \
- "switch to inferior $inf2 (2)"
+ "switch to inferior $inf2, 2"
gdb_test "finish" "Run till exit from #0 commonfun .*" \
"finish in inferior $inf2"
check_bt $inf2 "after infcall"
@@ -32,23 +32,23 @@ if { [skip_inline_frame_tests] } {
set line1 [gdb_get_line_number "set breakpoint 1 here" ${srcfile2}]
gdb_breakpoint $srcfile2:$line1
-gdb_test "continue" ".*set breakpoint 1 here.*" "continue to bar (1)"
-gdb_test "backtrace" "#0 bar.*#1 .*main.*" "backtrace from bar (1)"
+gdb_test "continue" ".*set breakpoint 1 here.*" "continue to bar, 1"
+gdb_test "backtrace" "#0 bar.*#1 .*main.*" "backtrace from bar, 1"
gdb_test "info frame" ".*called by frame.*" "bar not inlined"
-gdb_test "continue" ".*set breakpoint 1 here.*" "continue to bar (2)"
+gdb_test "continue" ".*set breakpoint 1 here.*" "continue to bar, 2"
gdb_test "backtrace" "#0 bar.*#1 .*func1.*#2 .*main.*" \
- "backtrace from bar (2)"
-gdb_test "up" "#1 .*func1.*" "up from bar (2)"
-gdb_test "info frame" ".*inlined into frame.*" "func1 inlined (2)"
+ "backtrace from bar, 2"
+gdb_test "up" "#1 .*func1.*" "up from bar, 2"
+gdb_test "info frame" ".*inlined into frame.*" "func1 inlined, 2"
-gdb_test "continue" ".*set breakpoint 1 here.*" "continue to bar (3)"
+gdb_test "continue" ".*set breakpoint 1 here.*" "continue to bar, 3"
gdb_test "backtrace" "#0 bar.*#1 .*func1.*#2 .*func2.*#3 .*main.*" \
- "backtrace from bar (3)"
-gdb_test "up" "#1 .*func1.*" "up from bar (3)"
-gdb_test "info frame" ".*inlined into frame.*" "func1 inlined (3)"
-gdb_test "up" "#2 .*func2.*" "up from func1 (3)"
-gdb_test "info frame" ".*inlined into frame.*" "func2 inlined (3)"
+ "backtrace from bar, 3"
+gdb_test "up" "#1 .*func1.*" "up from bar, 3"
+gdb_test "info frame" ".*inlined into frame.*" "func1 inlined, 3"
+gdb_test "up" "#2 .*func2.*" "up from func1, 3"
+gdb_test "info frame" ".*inlined into frame.*" "func2 inlined, 3"
# A regression test for having a backtrace limit that forces unwinding
# to stop after an inline frame. GDB needs to compute the frame_id of
@@ -61,7 +61,7 @@ gdb_test "info frame" ".*inlined into frame.*" "func2 inlined (3)"
gdb_test_no_output "set backtrace limit 2"
# Force flushing the frame cache.
gdb_test "maint flush register-cache" "Register cache flushed."
-gdb_test "up" "#1 .*func1.*" "up from bar (4)"
+gdb_test "up" "#1 .*func1.*" "up from bar, 4"
gdb_test "info frame" ".*in func1.*" "info frame still works"
# Verify the user visible limit works as expected.
gdb_test "up" "Initial frame selected; you cannot go up." "up hits limit"
@@ -40,19 +40,19 @@ gdb_breakpoint $srcfile2:$line1
set line2 [gdb_get_line_number "set breakpoint 2 here" ${srcfile2}]
gdb_breakpoint $srcfile2:$line2
-gdb_test "continue" ".*set breakpoint 1 here.*" "continue to bar (1)"
+gdb_test "continue" ".*set breakpoint 1 here.*" "continue to bar, 1"
gdb_test "backtrace" "#0 bar.*#1 .*func1.*#2 .*main.*" \
- "backtrace from bar (1)"
-gdb_test "up" "#1 .*func1.*" "up from bar (1)"
-gdb_test "info frame" ".*inlined into frame.*" "func1 inlined (1)"
+ "backtrace from bar, 1"
+gdb_test "up" "#1 .*func1.*" "up from bar, 1"
+gdb_test "info frame" ".*inlined into frame.*" "func1 inlined, 1"
-gdb_test "continue" ".*set breakpoint 1 here.*" "continue to bar (2)"
+gdb_test "continue" ".*set breakpoint 1 here.*" "continue to bar, 2"
gdb_test "backtrace" "#0 bar.*#1 .*func1.*#2 .*func2.*#3 .*main.*" \
"backtrace from bar (2)"
-gdb_test "up" "#1 .*func1.*" "up from bar (2)"
-gdb_test "info frame" ".*inlined into frame.*" "func1 inlined (2)"
-gdb_test "up" "#2 .*func2.*" "up from func1 (2)"
-gdb_test "info frame" ".*inlined into frame.*" "func2 inlined (2)"
+gdb_test "up" "#1 .*func1.*" "up from bar, 2"
+gdb_test "info frame" ".*inlined into frame.*" "func1 inlined, 2"
+gdb_test "up" "#2 .*func2.*" "up from func1, 2"
+gdb_test "info frame" ".*inlined into frame.*" "func2 inlined, 2"
gdb_test "continue" ".*set breakpoint 2 here.*" "continue to marker"
gdb_test "backtrace" "#0 marker.*#1 .*main.*" "backtrace from marker"
@@ -128,19 +128,19 @@ gdb_test "test_error_cmd ugh" "you lose!" "call error command"
gdb_test "python print (gdb.string_to_argv (\"1 2 3\"))" \
{\['1', '2', '3'\]} \
- "string_to_argv (\"1 2 3\")"
+ "string_to_argv (\"1 2 3\"), case 1"
gdb_test "python print (gdb.string_to_argv (\"'1 2' 3\"))" \
{\['1 2', '3'\]} \
- "string_to_argv (\"'1 2' 3\")"
+ "string_to_argv (\"'1 2' 3\"), case 2"
gdb_test "python print (gdb.string_to_argv ('\"1 2\" 3'))" \
{\['1 2', '3'\]} \
- "string_to_argv ('\"1 2\" 3')"
+ "string_to_argv ('\"1 2\" 3'), case 3"
gdb_test "python print (gdb.string_to_argv ('1\\ 2 3'))" \
{\['1 2', '3'\]} \
- "string_to_argv ('1\\ 2 3')"
+ "string_to_argv ('1\\ 2 3'), case 4"
# Test user-defined python commands.
gdb_test_multiline "input simple user-defined command" \
@@ -127,10 +127,10 @@ gdb_test "python print (f1 == gdb.newest_frame())" False \
gdb_test "python print (bframe == gdb.newest_frame())" True \
"newest frame -vs- newest frame"
-gdb_test "python print ('result = %s' % (f0 == f1))" " = False" "test equality comparison (false)"
-gdb_test "python print ('result = %s' % (f0 == f0))" " = True" "test equality comparison (true)"
-gdb_test "python print ('result = %s' % (f0 != f1))" " = True" "test inequality comparison (true)"
-gdb_test "python print ('result = %s' % (f0 != f0))" " = False" "test inequality comparison (false)"
+gdb_test "python print ('result = %s' % (f0 == f1))" " = False" "test equality comparison, false"
+gdb_test "python print ('result = %s' % (f0 == f0))" " = True" "test equality comparison, true"
+gdb_test "python print ('result = %s' % (f0 != f1))" " = True" "test inequality comparison, true"
+gdb_test "python print ('result = %s' % (f0 != f0))" " = False" "test inequality comparison, false"
gdb_test "python print ('result = %s' % f0.is_valid ())" " = True" "test Frame.is_valid"
gdb_test "python print ('result = %s' % f0.name ())" " = f2" "test Frame.name"
gdb_test "python print ('result = %s' % (f0.type () == gdb.NORMAL_FRAME))" " = True" "test Frame.type"
@@ -42,7 +42,7 @@ gdb_py_test_silent_cmd "python progspace = gdb.current_progspace()" \
"Get current progspace" 1
gdb_test "python print (progspace.filename)" "py-progspace" \
- "current progspace filename (py-progspace)"
+ "current progspace filename, py-progspace"
gdb_test "python print (gdb.current_progspace().symbol_file)" \
"<gdb.Objfile filename=.*/py-progspace>" \
@@ -57,10 +57,10 @@ proc test_fields {lang} {
if {$lang == "c++"} {
# Test usage with a class
- gdb_py_test_silent_cmd "print (c)" "print value (c)" 1
+ gdb_py_test_silent_cmd "print (c)" "print value(c)" 1
gdb_py_test_silent_cmd "python c = gdb.history (0)" "get value (c) from history" 1
gdb_py_test_silent_cmd "python fields = c.type.fields()" "get fields from c.type" 1
- gdb_test "python print (len(fields))" "2" "check number of fields (c)"
+ gdb_test "python print (len(fields))" "2" "check number of fields, c"
gdb_test "python print (fields\[0\].name)" "c" "check class field c name"
gdb_test "python print (fields\[1\].name)" "d" "check class field d name"
@@ -94,12 +94,12 @@ proc test_fields {lang} {
}
# Test normal fields usage in structs.
- gdb_py_test_silent_cmd "print (st)" "print value (st)" 1
+ gdb_py_test_silent_cmd "print (st)" "print value(st)" 1
gdb_py_test_silent_cmd "python st = gdb.history (0)" "get value (st) from history" 1
gdb_py_test_silent_cmd "python fields = st.type.fields()" "get fields from st.type" 1
gdb_test "python print (st.type.objfile.filename == gdb.current_progspace ().filename)" "True" \
"check type.objfile"
- gdb_test "python print (len(fields))" "2" "check number of fields (st)"
+ gdb_test "python print (len(fields))" "2" "check number of fields, st"
gdb_test "python print (fields\[0\].name)" "a" "check structure field a name"
gdb_test "python print (fields\[1\].name)" "b" "check structure field b name"
@@ -118,7 +118,7 @@ proc test_fields {lang} {
"Check that dir includes name"
# Test Python mapping behavior of gdb.Type for structs/classes
- gdb_test "python print (len(st.type))" "2" "check number of fields (st.type)"
+ gdb_test "python print (len(st.type))" "2" "check number of fields, st.type"
gdb_test "python print (st.type\['a'\].name)" "a" "check fields lookup by name"
gdb_test "python print (\[v.bitpos for v in st.type.itervalues()\])" {\[0L?, 32L?\]} "Check fields iteration over values"
gdb_test "python print (\[(n, v.bitpos) for (n, v) in st.type.items()\])" {\[\('a', 0L?\), \('b', 32L?\)\]} "Check fields items list"
@@ -136,7 +136,7 @@ proc test_fields {lang} {
gdb_test "python print (not not st.type\['a'\].type)" "True"
# Test regression PR python/10805
- gdb_py_test_silent_cmd "print (ar)" "print value (ar)" 1
+ gdb_py_test_silent_cmd "print (ar)" "print value(ar)" 1
gdb_py_test_silent_cmd "python ar = gdb.history (0)" "get value (ar) from history" 1
gdb_test "python fields = ar.type.fields()"
gdb_test "python print (len(fields))" "1" "check the number of fields"
@@ -153,10 +153,10 @@ proc test_fields {lang} {
# Test gdb.Type.vector.
# Note: vectors cast differently than arrays. Here ar[0] is replicated
# for the size of the vector.
- gdb_py_test_silent_cmd "print (vec_data_1)" "print value (vec_data_1)" 1
+ gdb_py_test_silent_cmd "print (vec_data_1)" "print value(vec_data_1)" 1
gdb_py_test_silent_cmd "python vec_data_1 = gdb.history (0)" "get value (vec_data_1) from history" 1
- gdb_py_test_silent_cmd "print (vec_data_2)" "print value (vec_data_2)" 1
+ gdb_py_test_silent_cmd "print (vec_data_2)" "print value(vec_data_2)" 1
gdb_py_test_silent_cmd "python vec_data_2 = gdb.history (0)" "get value (vec_data_2) from history" 1
gdb_py_test_silent_cmd "python vec1 = vec_data_1.cast(ar\[0\].type.vector(1))" "set vec1" 1
@@ -179,7 +179,7 @@ proc test_fields {lang} {
proc test_enums {} {
with_test_prefix "test_enum" {
- gdb_py_test_silent_cmd "print (e)" "print value (e)" 1
+ gdb_py_test_silent_cmd "print (e)" "print value(e)" 1
gdb_py_test_silent_cmd "python (e) = gdb.history (0)" "get value (e) from history" 1
gdb_py_test_silent_cmd "python fields = e.type.fields()" "extract type fields from e" 1
gdb_test "python print (len(fields))" "3" "check the number of enum fields"
@@ -188,8 +188,8 @@ proc test_enums {} {
# Ditto but by mapping operations
gdb_test "python print (len(e.type))" "3" "check the number of type fields"
- gdb_test "python print (e.type\['v1'\].name)" "v1" "check enum field lookup by name (v1)"
- gdb_test "python print (e.type\['v3'\].name)" "v3" "check enum field lookup by name (v3)"
+ gdb_test "python print (e.type\['v1'\].name)" "v1" "check enum field lookup by name, v1"
+ gdb_test "python print (e.type\['v3'\].name)" "v3" "check enum field lookup by name, v3"
gdb_test "python print (\[v.enumval for v in e.type.itervalues()\])" {\[0L?, 1L?, 2L?\]} "Check num fields iteration over values"
gdb_test "python print (\[(n, v.enumval) for (n, v) in e.type.items()\])" {\[\('v1', 0L?\), \('v2', 1L?\), \('v3', 2L?\)\]} "Check enum fields items list"
}
@@ -197,12 +197,12 @@ proc test_enums {} {
proc test_base_class {} {
with_test_prefix "test_base_class" {
- gdb_py_test_silent_cmd "print (d)" "print value (d)" 1
+ gdb_py_test_silent_cmd "print (d)" "print value(d)" 1
gdb_py_test_silent_cmd "python d = gdb.history (0)" "get value (d) from history" 1
gdb_py_test_silent_cmd "python fields = d.type.fields()" "extract type fields from d" 1
gdb_test "python print (len(fields))" "3" "check the number of fields"
- gdb_test "python print (fields\[0\].is_base_class)" "True" "check base class (fields\[0\])"
- gdb_test "python print (fields\[1\].is_base_class)" "False" "check base class (fields\[1\])"
+ gdb_test "python print (fields\[0\].is_base_class)" "True" {check base class, fields[0]}
+ gdb_test "python print (fields\[1\].is_base_class)" "False" {check base class, fields[1]}
}
}
@@ -210,7 +210,7 @@ proc test_range {} {
with_test_prefix "test_range" {
with_test_prefix "on ranged value" {
# Test a valid range request.
- gdb_py_test_silent_cmd "print (ar)" "print value (ar)" 1
+ gdb_py_test_silent_cmd "print (ar)" "print value(ar)" 1
gdb_py_test_silent_cmd "python ar = gdb.history (0)" "get value (ar) from history" 1
gdb_test "python print (len(ar.type.range()))" "2" "check correct tuple length"
gdb_test "python print (ar.type.range()\[0\])" "0" "check range low bound"
@@ -219,7 +219,7 @@ proc test_range {} {
with_test_prefix "on ranged type" {
# Test a range request on a ranged type.
- gdb_py_test_silent_cmd "print (ar)" "print value (ar)" 1
+ gdb_py_test_silent_cmd "print (ar)" "print value(ar)" 1
gdb_py_test_silent_cmd "python ar = gdb.history (0)" "get value (ar) from history" 1
gdb_py_test_silent_cmd "python fields = ar.type.fields()" "get fields" 1
gdb_test "python print (fields\[0\].type.range()\[0\])" "0" "check range low bound"
@@ -228,7 +228,7 @@ proc test_range {} {
with_test_prefix "on unranged value" {
# Test where a range does not exist.
- gdb_py_test_silent_cmd "print (st)" "print value (st)" 1
+ gdb_py_test_silent_cmd "print (st)" "print value(st)" 1
gdb_py_test_silent_cmd "python st = gdb.history (0)" "get value (st) from history" 1
gdb_test "python print (st.type.range())" "RuntimeError.*: This type does not have a range.*" "check range for non ranged type."
}
@@ -179,8 +179,8 @@ gdb_test_no_output "python gdb.set_parameter('max-value-size', 16)"
gdb_test "p a1.getarray()" \
"From Python <A_getarray>.*value requires $decimal bytes,\
which is more than max-value-size" \
- "after: a1.getarray (max-value-size)"
+ "after: a1.getarray, max-value-size"
gdb_test "p b1.getarray()" \
"From Python <B_getarray>.*value requires $decimal bytes,\
which is more than max-value-size" \
- "after: b1.getarray (max-value-size)"
+ "after: b1.getarray, max-value-size"
@@ -93,7 +93,7 @@ gdb_test_no_output "set var slow = 0"
test_all_threads "fast" 0
runto_main
-gdb_test "break thread_function" "Breakpoint \[0-9\]+ at 0x\[0-9a-f\]+: file .*print-threads.c, line \[0-9\]*\\." "break thread_function (2)"
+gdb_test "break thread_function" "Breakpoint \[0-9\]+ at 0x\[0-9a-f\]+: file .*print-threads.c, line \[0-9\]*\\." "break thread_function, 2"
gdb_test_no_output "set var slow = 1"
# Extend the timeout for slower tests.
set timeout [expr $oldtimeout + 120]
@@ -101,8 +101,8 @@ test_all_threads "slow" 0
set timeout $oldtimeout
runto_main
-gdb_test "break thread_function" "Breakpoint \[0-9\]+ at 0x\[0-9a-f\]+: file .*print-threads.c, line \[0-9\]*\\." "break thread_function (3)"
-gdb_test_no_output "set var slow = 1" "set var slow = 1 (2)"
+gdb_test "break thread_function" "Breakpoint \[0-9\]+ at 0x\[0-9a-f\]+: file .*print-threads.c, line \[0-9\]*\\." "break thread_function, 3"
+gdb_test_no_output "set var slow = 1" "set var slow = 1, 2"
gdb_breakpoint "kill"
# Extend the timeout for slower tests.
set timeout [expr $oldtimeout + 120]
@@ -45,7 +45,7 @@ proc get_args { description } {
append pattern ", (\[0-9\]+)"
}
- set test "listed args ($description)"
+ set test "listed args, $description"
gdb_test_multiple "print args" $test {
-re "\\\$\[0-9\]+ = {$pattern}.*$gdb_prompt $" {
pass $test
@@ -80,7 +80,7 @@ proc stop_process { description } {
proc get_current_thread { description } {
global gdb_prompt
- set test "find current thread ($description)"
+ set test "find current thread, $description"
gdb_test_multiple "bt" $test {
-re "thread_function \\(arg=0x(\[0-9\])\\).*$gdb_prompt $" {
@@ -124,7 +124,7 @@ proc step_ten_loops { cmd } {
for {set i 0} {[expr $i < 10]} {set i [expr $i + 1]} {
set other_step 0
- set test "$cmd to increment ($i)"
+ set test "$cmd to increment, $i"
gdb_test_multiple $cmd $test {
-re ".*myp\\) \\+\\+;\[\r\n\]+$gdb_prompt $" {
pass $test
@@ -171,7 +171,7 @@ gdb_continue_to_breakpoint "foo"
gdb_test_no_output "set print entry-values both"
-gdb_test_sequence "bt" "bt (1)" {
+gdb_test_sequence "bt" "bt, 1" {
"\[\r\n\]#0 .* foo \\(i=[-]?[0-9]+, i@entry=2, j=[-]?[0-9]+, j@entry=3\\)"
"\[\r\n\]#1 .* bar \\(i=<optimized out>, i@entry=<optimized out>\\)"
"\[\r\n\]#2 .* \.?main \\(\\)"
@@ -183,7 +183,7 @@ gdb_test_sequence "bt" "bt (1)" {
gdb_test_no_output "set var *(int *) &global1=10"
gdb_test_no_output "set var *(int *) &global2=11"
-gdb_test_sequence "bt" "bt (2)" {
+gdb_test_sequence "bt" "bt, 2" {
"\[\r\n\]#0 .* foo \\(i=[-]?[0-9]+, i@entry=10, j=[-]?[0-9]+, j@entry=11\\)"
"\[\r\n\]#1 .* bar \\(i=<optimized out>, i@entry=<optimized out>\\)"
"\[\r\n\]#2 .* \.?main \\(\\)"
@@ -73,7 +73,7 @@ proc set_arch { arch which trans_mode } {
# Anchor the test output, so that error messages are detected.
set cmd "set tdesc filename $filename"
- set msg "set tdesc filename tdesc-arch.xml ($which architecture)"
+ set msg "set tdesc filename tdesc-arch.xml, $which architecture"
set cmd_regex [string_to_regexp $cmd]
gdb_test_multiple $cmd $msg {
-re "^$cmd_regex\r\n$gdb_prompt $" {
@@ -87,7 +87,7 @@ proc set_arch { arch which trans_mode } {
set cmd "show architecture"
gdb_test $cmd \
"The target architecture is set to \"auto\" \\(currently \"$arch\"\\)\\." \
- "$cmd ($which architecture)"
+ "$cmd, $which architecture"
remote_file host delete $filename
}
@@ -115,11 +115,11 @@ if {[is_remote host]} {
set cmd "set tdesc filename $filename"
gdb_test $cmd \
"warning:.*Target description specified unknown architecture.*" \
- "set tdesc filename tdesc-arch.xml (invalid architecture)"
+ "set tdesc filename tdesc-arch.xml, invalid architecture"
set cmd "show architecture"
gdb_test $cmd \
"The target architecture is set to \"auto\" \\(currently \"$default_arch\"\\)\\." \
- "$cmd (invalid architecture)"
+ "$cmd, invalid architecture"
remote_file host delete $filename
@@ -1989,14 +1989,13 @@ proc get_mi_thread_list {name} {
return $thread_list
}
-# Check that MI and the console know of the same threads.
-# Appends NAME to all test names.
-proc check_mi_and_console_threads {name} {
+# Helper function for check_mi_and_console_threads.
+proc check_mi_and_console_threads_1 { name } {
global expect_out
mi_gdb_test "-thread-list-ids" \
{.*\^done,thread-ids={(thread-id="[0-9]+"(,)*)+},current-thread-id="[0-9]+",number-of-threads="[0-9]+"} \
- "-thread-list-ids ($name)"
+ "-thread-list-ids"
set mi_output {}
if {[info exists expect_out(buffer)]} {
set mi_output $expect_out(buffer)
@@ -2013,7 +2012,7 @@ proc check_mi_and_console_threads {name} {
# FIXME: kseitz/2002-09-05: Don't use the hack-cli method.
mi_gdb_test "info threads" \
{.*(~".*"[\r\n]*)+.*} \
- "info threads ($name)"
+ "info threads"
set console_output {}
if {[info exists expect_out(buffer)]} {
set console_output $expect_out(buffer)
@@ -2039,29 +2038,29 @@ proc check_mi_and_console_threads {name} {
}
}
if {$mi_result == ""} {
- fail "finding MI result string ($name)"
+ fail "finding MI result string"
} else {
- pass "finding MI result string ($name)"
+ pass "finding MI result string"
}
# Finally, extract the thread ids and compare them to the console
set num_mi_threads_str ""
if {![regexp {number-of-threads="[0-9]+"} $mi_result num_mi_threads_str]} {
- fail "finding number of threads in MI output ($name)"
+ fail "finding number of threads in MI output"
} else {
- pass "finding number of threads in MI output ($name)"
+ pass "finding number of threads in MI output"
# Extract the number of threads from the MI result
if {![scan $num_mi_threads_str {number-of-threads="%d"} num_mi_threads]} {
- fail "got number of threads from MI ($name)"
+ fail "got number of threads from MI"
} else {
- pass "got number of threads from MI ($name)"
+ pass "got number of threads from MI"
# Check if MI and console have same number of threads
if {$num_mi_threads != [llength $console_thread_list]} {
- fail "console and MI have same number of threads ($name)"
+ fail "console and MI have same number of threads"
} else {
- pass "console and MI have same number of threads ($name)"
+ pass "console and MI have same number of threads"
# Get MI thread list
set mi_thread_list [get_mi_thread_list $name]
@@ -2074,19 +2073,27 @@ proc check_mi_and_console_threads {name} {
}
}
if {$fails > 0} {
- fail "MI and console have same threads ($name)"
+ fail "MI and console have same threads"
# Send a list of failures to the log
send_log "Console has thread ids: $console_thread_list\n"
send_log "MI has thread ids: $mi_thread_list\n"
} else {
- pass "MI and console have same threads ($name)"
+ pass "MI and console have same threads"
}
}
}
}
}
+# Check that MI and the console know of the same threads.
+# Appends NAME to all test names.
+proc check_mi_and_console_threads { name } {
+ with_test_prefix $name {
+ check_mi_and_console_threads_1 $name
+ }
+}
+
# Set solib-search-path to allow gdb to locate shlib FILE.
proc mi_locate_shlib { file } {
global mi_spawn_id