X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ftestsuite%2Fgdb.base%2Fcharset.exp;h=16e986c51906d4261a703abaef7064c862acf57b;hb=2b74ba5a194fdfb152465e786a173b039e28964a;hp=f423203b906adc8f63f796beac75dda4ee1ce228;hpb=9b254dd1ce46c19dde1dde5b8d1e22e862dfacce;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/testsuite/gdb.base/charset.exp b/gdb/testsuite/gdb.base/charset.exp index f423203b90..16e986c519 100644 --- a/gdb/testsuite/gdb.base/charset.exp +++ b/gdb/testsuite/gdb.base/charset.exp @@ -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 @@ -20,40 +20,20 @@ # 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