gdb/testsuite: Reduce test name duplication in gdb.base tests
[deliverable/binutils-gdb.git] / gdb / testsuite / gdb.base / charset.exp
index f423203b906adc8f63f796beac75dda4ee1ce228..16e986c51906d4261a703abaef7064c862acf57b 100644 (file)
@@ -1,6 +1,6 @@
 # This testcase is part of GDB, the GNU debugger.
 
-# Copyright 2001, 2004, 2007, 2008 Free Software Foundation, Inc.
+# Copyright 2001-2019 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 
 # Test GDB's character set support.
 
-if $tracelevel then {
-       strace $tracelevel
-}
 
-set prms_id 0
-set bug_id 0
+standard_testfile .c charset-malloc.c
 
-set testfile "charset"
-set srcfile ${testfile}.c
-set binfile ${objdir}/${subdir}/${testfile}
-if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
-    untested "couldn't compile ${srcdir}/${subdir}/${srcfile}"
+if { [prepare_for_testing "failed to prepare" ${testfile} [list $srcfile $srcfile2]] } {
     return -1
 }
 
-# Start with a fresh gdb.
-gdb_exit
-gdb_start
-gdb_reinitialize_dir $srcdir/$subdir
-gdb_load ${binfile}
-
 # Parse the output from a `show charset' command.  Return the host
 # and target charset as a two-element list.
 proc parse_show_charset_output {testname} {
     global gdb_prompt
 
     gdb_expect {
-        -re "The current host and target character set is `(.*)'\\.\[\r\n\]+$gdb_prompt $" {
-            set host_charset $expect_out(1,string)
-            set target_charset $expect_out(1,string)
-           set retlist [list $host_charset $target_charset]
-            pass $testname
-        }
-        -re "The current host character set is `(.*)'\\.\[\r\n\]+The current target character set is `(.*)'\\.\[\r\n\]+$gdb_prompt $" {
+        -re "The host character set is \"(.*)\"\\.\[\r\n\]+The target character set is \"(.*)\"\\.\[\r\n\]+The target wide character set is \"(.*)\"\\.\[\r\n\]+$gdb_prompt $" {
             set host_charset $expect_out(1,string)
             set target_charset $expect_out(2,string)
            set retlist [list $host_charset $target_charset]
@@ -81,76 +61,31 @@ proc parse_show_charset_output {testname} {
 }
 
 
-# Try the various `show charset' commands.  These are all aliases of each
-# other; `show target-charset' and `show host-charset' actually print
-# both the host and target charsets.
+# Try the various `show charset' commands.
 
 send_gdb "show charset\n"
 set show_charset [parse_show_charset_output "show charset"]
 
 send_gdb "show target-charset\n"
-set show_target_charset [parse_show_charset_output "show target-charset"]
+set show_target_charset \
+  [lindex [parse_show_charset_output "show target-charset"] 0]
 
-if {[lsearch $show_charset $show_target_charset] >= 0} {
+if {[lsearch -exact $show_charset $show_target_charset] >= 0} {
     pass "check `show target-charset' against `show charset'"
 } else {
     fail "check `show target-charset' against `show charset'"
 }
 
 send_gdb "show host-charset\n"
-set show_host_charset [parse_show_charset_output "show host-charset"]
+set show_host_charset \
+  [lindex [parse_show_charset_output "show host-charset"] 0]
 
-if {[lsearch $show_charset $show_host_charset] >= 0} {
+if {[lsearch -exact $show_charset $show_host_charset] >= 0} {
     pass "check `show host-charset' against `show charset'"
 } else {
     fail "check `show host-charset' against `show charset'"
 }
 
-
-# Get the list of supported (host) charsets as possible completions.
-send_gdb "set charset \t\t"
-
-# Check that we can at least use ASCII as a host character set.
-sleep 1
-gdb_expect {
-    -re "^set charset .*\r\nASCII.*\r\n$gdb_prompt set charset " {
-       # We got the output that we wanted, including ASCII as possible
-       # charset. Send a newline to get us back to the prompt. This will
-       # also generate an error message. Let's not check here that the error
-       # message makes sense, we do that below, as a separate testcase.
-        send_gdb "\n"
-        gdb_expect {
-           -re ".*Requires an argument.*$gdb_prompt $" {
-               pass "get valid character sets"
-           }
-           -re ".*$gdb_prompt $" {
-               send_gdb "\n"
-               gdb_expect {
-                   -re ".*$gdb_prompt $" {
-                       fail "get valid character sets"
-                   }
-               }
-           }
-           timeout {
-               fail "(timeout) get valid character sets"
-           }
-       }
-    }
-    -re ".*$gdb_prompt $" {
-       # We got some output that ended with a regular prompt
-        fail "get valid character sets"
-    }
-    -re ".*$gdb_prompt set charset.*$" {
-       # We got some other output, send a cntrl-c to gdb to get us back
-        # to the prompt.
-       send_gdb "\003"
-        fail "get valid character sets"
-    }
-    timeout {
-        fail "get valid character sets (timeout)"
-    }
-}
-
 # Try a malformed `set charset'.
 gdb_test "set charset" \
          "Requires an argument. Valid arguments are.*" \
@@ -179,60 +114,53 @@ proc all_charset_names {} {
 
 proc valid_host_charset {charset} {
     global charsets
-    return $charsets($charset)
+    return [expr {[info exists charsets($charset)] && $charsets($charset)}]
+}
+
+proc valid_target_charset {charset} {
+    global charsets
+    return [info exists charsets($charset)]
 }
 
 send_gdb "set host-charset\n"
 gdb_expect {
-    -re "Requires an argument. Valid arguments are (\[^ \t\n\r,.\]*)" {
-       #set host_charset_list $expect_out(1,string)
-       set charsets($expect_out(1,string)) 1
-       exp_continue
-       #pass "capture valid host charsets"
-    }
-
-    -re ", (\[^ \t\n\r,.\]*)" {
-       #set host_charset_list $expect_out(1,string)
-       set charsets($expect_out(1,string)) 1
-       exp_continue
-       #pass "capture valid host charsets"
-    }
-
-    -re "\\.\r\n$gdb_prompt $" {
-       #set host_charset_list $expect_out(1,string)
+    -re "Requires an argument. Valid arguments are (.*)\\.\r\n$gdb_prompt $" {
+       set host_charset_list $expect_out(1,string)
+       regsub -all {, } $host_charset_list {,} host_charset_list
+       foreach host_charset [split $host_charset_list ","] {
+           set charsets($host_charset) 1
+       }
        pass "capture valid host charsets"
     }
 
     -re ".*$gdb_prompt $" {
        fail "capture valid host charsets"
     }
+
     timeout {
        fail "(timeout) capture valid host charsets"
     }
 }
 
+# If gdb was built with a phony iconv, it will only have two character
+# sets: "auto" and the default.  In this situation, this set of tests
+# is pointless.
+if {[llength [array names charsets]] < 3} {
+    untested "fewer than 3 charsets"
+    return -1
+}
 
 send_gdb "set target-charset\n"
 gdb_expect {
-    -re "Requires an argument. Valid arguments are (\[^ \t\n\r,.\]*)" {
-       set target_charset $expect_out(1,string)
-       if {! [info exists charsets($target_charset)]} {
-           set charsets($target_charset) 0
-       }
-       exp_continue
-    }
-
-    -re ", (\[^ \t\n\r,.\]*)" {
-       set target_charset $expect_out(1,string)
-       if {! [info exists charsets($target_charset)]} {
-           set charsets($target_charset) 0
+    -re "Requires an argument. Valid arguments are (.*)\\.\r\n$gdb_prompt $" {
+       set target_charset_list $expect_out(1,string)
+       regsub -all {, } $target_charset_list {,} target_charset_list
+       foreach target_charset [split $target_charset_list ","] {
+           if {! [info exists charsets($target_charset)]} {
+               set charsets($target_charset) 0
+           }
        }
-       exp_continue
-    }
-
-    -re "\\.\r\n$gdb_prompt $" {
        pass "capture valid target charsets"
-
     }
 
     -re ".*$gdb_prompt $" {
@@ -244,8 +172,10 @@ gdb_expect {
     }
 }
 
-# Make sure that GDB supports every host/target charset combination.
-foreach host_charset [all_charset_names] {
+# We don't want to test all the charset names here, since that would
+# be too many combinations.  We we pick a subset.
+set charset_subset {ASCII ISO-8859-1 EBCDIC-US IBM1047}
+foreach_with_prefix host_charset $charset_subset {
     if {[valid_host_charset $host_charset]} {
 
         set testname "try `set host-charset $host_charset'"
@@ -279,7 +209,10 @@ foreach host_charset [all_charset_names] {
 
         # Now try setting every possible target character set,
         # given that host charset.
-        foreach target_charset [all_charset_names] {
+        foreach target_charset $charset_subset {
+           if {![valid_target_charset $target_charset]} {
+               continue
+           }
             set testname "try `set target-charset $target_charset'"
             send_gdb "set target-charset $target_charset\n"
             gdb_expect {
@@ -391,36 +324,40 @@ gdb_test "break ${srcfile}:[gdb_get_line_number "all strings initialized"]" \
          ".*Breakpoint.* at .*" \
          "set breakpoint after all strings have been initialized"
 gdb_run_cmd
-gdb_expect {
-    -re "Breakpoint.*all strings initialized.*$gdb_prompt $" {
-        pass "run until all strings have been initialized"
-    }
-    -re "$gdb_prompt $" {
-        fail "run until all strings have been initialized"
-    }
-    timeout {
-        fail "run until all strings have been initialized (timeout)"
-    }
+gdb_test "" "Breakpoint.*all strings initialized.*" "run until all strings have been initialized"
+
+# We only try the wide character tests on machines where the wchar_t
+# typedef in the test case has the right size.
+set wchar_size [get_sizeof wchar_t 99]
+set wchar_ok 0
+if {$wchar_size == 2} {
+    lappend charset_subset UTF-16
+    set wchar_ok 1
+} elseif {$wchar_size == 4} {
+    lappend charset_subset UTF-32
+    set wchar_ok 1
 }
 
+gdb_test_no_output "set host-charset ASCII"
+foreach target_charset $charset_subset {
+    if {![valid_target_charset $target_charset]} {
+       continue
+    }
 
-gdb_test "set host-charset ASCII" ""
-foreach target_charset [all_charset_names] {
-    send_gdb "set target-charset $target_charset\n" 
-    gdb_expect {
-        -re "$gdb_prompt $" {
-            pass "set target-charset $target_charset"
-        }
-        timeout {
-            fail "set target-charset $target_charset (timeout)"
-        }
+    if {$target_charset == "UTF-32" || $target_charset == "UTF-16"} {
+       set param target-wide-charset
+       set L L
+    } else {
+       set param target-charset
+       set L ""
     }
+    gdb_test_no_output "set $param $target_charset"
 
     # Try printing the null character.  There seems to be a bug in
     # gdb_test that requires us to use gdb_expect here.
-    send_gdb "print '\\0'\n"
+    send_gdb "print $L'\\0'\n"
     gdb_expect {
-        -re "\\\$${decimal} = 0 '\\\\0'\[\r\n\]+$gdb_prompt $" {
+        -re "\\\$${decimal} = 0 $L'\\\\000'\[\r\n\]+$gdb_prompt $" {
             pass "print the null character in ${target_charset}"
         }
         -re "$gdb_prompt $" {
@@ -435,8 +372,14 @@ foreach target_charset [all_charset_names] {
     # a string in $target_charset.  The variable's name is the
     # character set's name, in lower-case, with all non-identifier
     # characters replaced with '_', with "_string" stuck on the end.
-    set var_name [string tolower "${target_charset}_string"]
-    regsub -all -- "\[^a-z0-9_\]" $var_name "_" var_name
+    if {$target_charset == "UTF-16"} {
+       # We still use the utf_32_string variable -- but the size is
+       # correct for UTF-16.
+       set var_name utf_32_string
+    } else {
+       set var_name [string tolower "${target_charset}_string"]
+       regsub -all -- "\[^a-z0-9_\]" $var_name "_" var_name
+    }
     
     # Compute a regexp matching the results we expect.  This is static,
     # but it's easier than writing it out.
@@ -444,12 +387,12 @@ foreach target_charset [all_charset_names] {
     set uppercase "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     set lowercase "abcdefghijklmnopqrstuvwxyz"
     set digits "0123456789"
-    set octal_escape "\\\\\[0-9\]\[0-9\]\[0-9\]"
+    set octal_escape "\\\\\[0-9\]+"
 
     send_gdb "print $var_name\n"
     # ${escapes}${uppercase}${lowercase}${digits}${octal}${octal}
     gdb_expect {
-        -re ".* = \"(\\\\a|x)(\\\\b|x)(\\\\f|x)(\\\\n|x)(\\\\r|x)(\\\\t|x)(\\\\v|x)${uppercase}${lowercase}${digits}(\\\\\[0-9\]\[0-9\]\[0-9\]|x)(\\\\\[0-9\]\[0-9\]\[0-9\]|x).*\"\[\r\n\]+$gdb_prompt $" {
+        -re ".* = $L\"(\\\\a|x)(\\\\b|x)(\\\\f|x)(\\\\n|x)(\\\\r|x)(\\\\t|x)(\\\\v|x)${uppercase}${lowercase}${digits}(${octal_escape}|x)+\"\[\r\n\]+$gdb_prompt $" {
             pass "print string in $target_charset"
         }
         -re "$gdb_prompt $" {
@@ -461,22 +404,22 @@ foreach target_charset [all_charset_names] {
     }
 
     # Try entering a character literal, and see if it comes back unchanged.
-    gdb_test "print 'A'" \
-             " = \[0-9-\]+ 'A'" \
+    gdb_test "print $L'A'" \
+             " = \[0-9-\]+ $L'A'" \
              "parse character literal in ${target_charset}"
 
     # Check that the character literal was encoded correctly.
-    gdb_test "print 'A' == $var_name\[7\]" \
+    gdb_test "print $L'A' == $var_name\[7\]" \
              " = 1" \
              "check value of parsed character literal in ${target_charset}"
 
     # Try entering a string literal, and see if it comes back unchanged.
-    gdb_test "print \"abcdefABCDEF012345\"" \
-             " = \"abcdefABCDEF012345\"" \
+    gdb_test "print $L\"abcdefABCDEF012345\"" \
+             " = $L\"abcdefABCDEF012345\"" \
              "parse string literal in ${target_charset}"
 
     # Check that the string literal was encoded correctly.
-    gdb_test "print \"q\"\[0\] == $var_name\[49\]" \
+    gdb_test "print $L\"q\"\[0\] == $var_name\[49\]" \
              " = 1" \
              "check value of parsed string literal in ${target_charset}"
 
@@ -509,7 +452,7 @@ foreach target_charset [all_charset_names] {
         send_gdb "print $var_name\[$i\]\n"
         set have_escape 1
         gdb_expect {
-            -re "= \[0-9-\]+ '\\\\${escape}'\[\r\n\]+$gdb_prompt $" {
+            -re "= \[0-9-\]+ $L'\\\\${escape}'\[\r\n\]+$gdb_prompt $" {
                 pass "try printing '\\${escape}' in ${target_charset}"
             }
             -re "= \[0-9-\]+ 'x'\[\r\n\]+$gdb_prompt $" {
@@ -527,12 +470,12 @@ foreach target_charset [all_charset_names] {
         if {$have_escape} {
 
             # Try parsing a backslash escape in a character literal.
-            gdb_test "print '\\${escape}' == $var_name\[$i\]" \
+            gdb_test "print $L'\\${escape}' == $var_name\[$i\]" \
                      " = 1" \
                      "check value of '\\${escape}' in ${target_charset}"
 
             # Try parsing a backslash escape in a string literal.
-            gdb_test "print \"\\${escape}\"\[0\] == $var_name\[$i\]" \
+            gdb_test "print $L\"\\${escape}\"\[0\] == $var_name\[$i\]" \
                      " = 1" \
                      "check value of \"\\${escape}\" in ${target_charset}"
         }
@@ -540,10 +483,142 @@ foreach target_charset [all_charset_names] {
 
     # Try printing a character escape that doesn't exist.  We should 
     # get the unescaped character, in the target character set.
-    gdb_test "print '\\q'" " = \[0-9-\]+ 'q'" \
+    gdb_test "print $L'\\q'" " = \[0-9-\]+ $L'q'" \
              "print escape that doesn't exist in $target_charset"
-    gdb_test "print '\\q' == $var_name\[49\]" " = 1" \
+    gdb_test "print $L'\\q' == $var_name\[49\]" " = 1" \
              "check value of escape that doesn't exist in $target_charset"
 }
 
+# Reset the target charset.
+gdb_test_no_output "set target-charset UTF-8"
+
+# \242 is not a valid UTF-8 character.
+gdb_test "print \"\\242\"" " = \"\\\\242\"" \
+  "non-representable target character"
+
+gdb_test "print '\\x'" "\\\\x escape without a following hex digit."
+gdb_test "print '\\u'" "\\\\u escape without a following hex digit."
+gdb_test "print '\\9'" " = \[0-9\]+ '9'"
+
+# An octal escape can only be 3 digits.
+gdb_test "print \"\\1011\"" " = \"A1\""
+
+# Tests for wide- or unicode- strings.  L is the prefix letter to use,
+# either "L" (for wide strings), "u" (for UTF-16), or "U" (for UTF-32).
+# NAME is used in the test names and should be related to the prefix
+# letter in some easy-to-undestand way.
+proc test_wide_or_unicode {L name} {
+    gdb_test "print $L\"ab\" $L\"c\"" " = $L\"abc\"" \
+      "basic $name string concatenation"
+    gdb_test "print $L\"ab\" \"c\"" " = $L\"abc\"" \
+      "narrow and $name string concatenation"
+    gdb_test "print \"ab\" $L\"c\"" " = $L\"abc\"" \
+      "$name and narrow string concatenation"
+    gdb_test "print $L\"\\xe\" $L\"c\"" " = $L\"\\\\016c\"" \
+      "$name string concatenation with escape"
+    gdb_test "print $L\"\" \"abcdef\" \"g\"" \
+      "$L\"abcdefg\"" \
+      "concatenate three strings with empty $name string"
+
+    gdb_test "print $L'a'" "= \[0-9\]+ $L'a'" \
+      "basic $name character"
+}
+
+if {$wchar_ok} {
+    test_wide_or_unicode L wide
+}
+
+set ucs2_ok [expr {[get_sizeof char16_t 99] == 2}]
+
+if ![valid_host_charset "UTF-16"] {
+    verbose -log "Disabling UTF-16 tests."
+    set ucs2_ok 0
+}
+
+if {$ucs2_ok} {
+    test_wide_or_unicode u UTF-16
+}
+
+set ucs4_ok [expr {[get_sizeof char32_t 99] == 4}]
+if {$ucs4_ok} {
+    test_wide_or_unicode U UTF-32
+}
+
+# Test an invalid string combination.
+proc test_combination {L1 name1 L2 name2} {
+    gdb_test "print $L1\"abc\" $L2\"def\"" \
+      "Undefined string concatenation." \
+      "undefined concatenation of $name1 and $name2"
+}
+
+if {$wchar_ok && $ucs2_ok} {
+    test_combination L wide u UTF-16
+}
+if {$wchar_ok && $ucs4_ok} {
+    test_combination L wide U UTF-32
+  # Regression test for a typedef to a typedef.
+  gdb_test "print myvar" "= \[0-9\]+ L'A'" \
+      "typedef to wchar_t"
+}
+if {$ucs2_ok && $ucs4_ok} {
+    test_combination u UTF-16 U UTF-32
+}
+
+if {$ucs2_ok} {
+    set go 1
+    gdb_test_multiple "python print ('hello, world!')" \
+       "verify python support for charset tests" {
+           -re "not supported.*$gdb_prompt $"  {
+               unsupported "python support is disabled"
+               set go 0
+           }
+           -re "$gdb_prompt $" {}
+       }
+
+    if {$go} {
+       gdb_test "print u\"abcdef\"" " = u\"abcdef\"" \
+           "set up for python printing of utf-16 string"
+
+       gdb_test "python print (gdb.history(0).string())" "abcdef" \
+           "extract utf-16 string using python"
+    }
+}
+
+# Regression test for a cleanup bug in the charset code.
+gdb_test "print 'a' == 'a' || 'b' == 'b'" \
+  ".* = 1" \
+  "EVAL_SKIP cleanup handling regression test"
+
+
+proc string_display { var_name set_prefix x_size x_type} {
+    with_test_prefix "set_prefix=$set_prefix" {
+       gdb_test_no_output "set ${var_name} = ${set_prefix}\"Test String\\0with zeroes\""\
+           "assign ${var_name} with prefix ${set_prefix}"
+       gdb_test "x /2${x_size}s ${var_name}" ".*\t${x_type}\"Test String\"\[\r\n\]+.*\t${x_type}\"with zeroes\"" \
+           "display String ${var_name} with x/${x_size}s"
+    }
+}
+
+if {$ucs2_ok} {
+    string_display String16 u h u
+    if {$wchar_size == 2} {
+       string_display String16 L h u
+    }
+}
+
+string_display String32 U w U
+if {$wchar_size == 4} {
+  string_display String32 L w U
+}
+
+
+foreach name {short int long} {
+    # We're really just checking to make sure this doesn't give an
+    # error.
+    gdb_test "print ${name}_array = \"hi\"" \
+       " = {.*}" \
+       "assign string to $name array"
+}
+
+
 gdb_exit 
This page took 0.030249 seconds and 4 git commands to generate.