1 # This testcase is part of GDB, the GNU debugger.
3 # Copyright 2001, 2004, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 3 of the License, or
8 # (at your option) any later version.
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
15 # You should have received a copy of the GNU General Public License
16 # along with this program. If not, see <http://www.gnu.org/licenses/>.
18 # Please email any bugs, comments, and/or additions to this file to:
21 # Test GDB's character set support.
28 set testfile "charset"
29 set srcfile ${testfile}.c
30 set binfile ${objdir}/${subdir}/${testfile}
31 if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
32 untested "couldn't compile ${srcdir}/${subdir}/${srcfile}"
36 # Start with a fresh gdb.
39 gdb_reinitialize_dir $srcdir/$subdir
42 # Parse the output from a `show charset' command. Return the host
43 # and target charset as a two-element list.
44 proc parse_show_charset_output {testname} {
48 -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 $" {
49 set host_charset $expect_out(1,string)
50 set target_charset $expect_out(2,string)
51 set retlist [list $host_charset $target_charset]
54 -re "The host character set is \"(.*)\"\\.\[\r\n\]+$gdb_prompt $" {
55 set host_charset $expect_out(1,string)
56 set retlist [list $host_charset]
59 -re "The target character set is \"(.*)\"\\.\[\r\n\]+$gdb_prompt $" {
60 set target_charset $expect_out(1,string)
61 set retlist [list $target_charset]
64 -re ".*$gdb_prompt $" {
68 fail "$testname (timeout)"
76 # Try the various `show charset' commands.
78 send_gdb "show charset\n"
79 set show_charset [parse_show_charset_output "show charset"]
81 send_gdb "show target-charset\n"
82 set show_target_charset \
83 [lindex [parse_show_charset_output "show target-charset"] 0]
85 if {[lsearch -exact $show_charset $show_target_charset] >= 0} {
86 pass "check `show target-charset' against `show charset'"
88 fail "check `show target-charset' against `show charset'"
91 send_gdb "show host-charset\n"
92 set show_host_charset \
93 [lindex [parse_show_charset_output "show host-charset"] 0]
95 if {[lsearch -exact $show_charset $show_host_charset] >= 0} {
96 pass "check `show host-charset' against `show charset'"
98 fail "check `show host-charset' against `show charset'"
101 # Try a malformed `set charset'.
102 gdb_test "set charset" \
103 "Requires an argument. Valid arguments are.*" \
104 "try malformed `set charset'"
106 # Try using `set host-charset' on an invalid character set.
107 gdb_test "set host-charset my_grandma_bonnie" \
108 "Undefined item: \"my_grandma_bonnie\"." \
109 "try `set host-charset' with invalid charset"
111 # Try using `set target-charset' on an invalid character set.
112 gdb_test "set target-charset my_grandma_bonnie" \
113 "Undefined item: \"my_grandma_bonnie\"." \
114 "try `set target-charset' with invalid charset"
116 # A Tcl array mapping the names of all the character sets we've seen
117 # to "1" if the character set can be used as a host character set, or
118 # "0" otherwise. We can use `array names charsets' just to get a list
119 # of all character sets.
120 array set charsets {}
122 proc all_charset_names {} {
124 return [array names charsets]
127 proc valid_host_charset {charset} {
129 return [expr {[info exists charsets($charset)] && $charsets($charset)}]
132 proc valid_target_charset {charset} {
134 return [info exists charsets($charset)]
137 send_gdb "set host-charset\n"
139 -re "Requires an argument. Valid arguments are (.*)\\.\r\n$gdb_prompt $" {
140 set host_charset_list $expect_out(1,string)
141 regsub -all {, } $host_charset_list {,} host_charset_list
142 foreach host_charset [split $host_charset_list ","] {
143 set charsets($host_charset) 1
145 pass "capture valid host charsets"
148 -re ".*$gdb_prompt $" {
149 fail "capture valid host charsets"
153 fail "(timeout) capture valid host charsets"
157 # If gdb was built with a phony iconv, it will only have two character
158 # sets: "auto" and the default. In this situation, this set of tests
160 if {[llength [array names charsets]] < 3} {
165 send_gdb "set target-charset\n"
167 -re "Requires an argument. Valid arguments are (.*)\\.\r\n$gdb_prompt $" {
168 set target_charset_list $expect_out(1,string)
169 regsub -all {, } $target_charset_list {,} target_charset_list
170 foreach target_charset [split $target_charset_list ","] {
171 if {! [info exists charsets($target_charset)]} {
172 set charsets($target_charset) 0
175 pass "capture valid target charsets"
178 -re ".*$gdb_prompt $" {
179 fail "capture valid target charsets"
183 fail "(timeout) capture valid target charsets"
187 # We don't want to test all the charset names here, since that would
188 # be too many combinations. We we pick a subset.
189 set charset_subset {ASCII ISO-8859-1 EBCDIC-US IBM1047}
190 foreach host_charset $charset_subset {
191 if {[valid_host_charset $host_charset]} {
193 set testname "try `set host-charset $host_charset'"
194 send_gdb "set host-charset $host_charset\n"
196 -re "GDB doesn't know of any character set named.*\[\r\n]+${gdb_prompt} $" {
197 # How did it get into `charsets' then?
198 fail "$testname (didn't recognize name)"
200 -re "GDB can't use `.*' as its host character set\\.\[\r\n]+${gdb_prompt} $" {
201 # Well, then why does its `charsets' entry say it can?
204 -re "${gdb_prompt} $" {
208 fail "$testname (timeout)"
212 # Check that the command actually had its intended effect:
213 # $host_charset should now be the host character set.
214 send_gdb "show charset\n"
215 set result [parse_show_charset_output "parse `show charset' after `set host-charset $host_charset'"]
216 if {! [string compare [lindex $result 0] $host_charset]} {
217 pass "check effect of `set host-charset $host_charset'"
219 fail "check effect of `set host-charset $host_charset'"
222 # Now try setting every possible target character set,
223 # given that host charset.
224 foreach target_charset $charset_subset {
225 if {![valid_target_charset $target_charset]} {
228 set testname "try `set target-charset $target_charset'"
229 send_gdb "set target-charset $target_charset\n"
231 -re "GDB doesn't know of any character set named.*\[\r\n]+${gdb_prompt} $" {
232 fail "$testname (didn't recognize name)"
234 -re "GDB can't convert from the .* character set to .*\\.\[\r\n\]+${gdb_prompt} $" {
235 # This is a serious problem. GDB should be able to convert
236 # between any arbitrary pair of character sets.
237 fail "$testname (can't convert)"
239 -re "${gdb_prompt} $" {
243 fail "$testname (timeout)"
247 # Check that the command actually had its intended effect:
248 # $target_charset should now be the target charset.
249 send_gdb "show charset\n"
250 set result [parse_show_charset_output "parse `show charset' after `set target-charset $target_charset'"]
251 if {! [string compare $result [list $host_charset $target_charset]]} {
252 pass "check effect of `set target-charset $target_charset'"
254 fail "check effect of `set target-charset $target_charset'"
257 # Test handling of characters in the host charset which
258 # can't be translated into the target charset. \xA2 is
259 # `cent' in ISO-8859-1, which has no equivalent in ASCII.
261 # On some systems, the pseudo-tty through which we
262 # communicate with GDB insists on stripping the high bit
263 # from input characters, meaning that `cent' turns into
264 # `"'. Since ISO-8859-1 and ASCII are identical in the
265 # lower 128 characters, it's tough to see how we can test
266 # this behavior on such systems, so we just xfail it.
268 # Note: the \x16 (Control-V) is an escape to allow \xA2 to
270 if {! [string compare $host_charset iso-8859-1] && ! [string compare $target_charset ascii]} {
272 set testname "untranslatable character in character literal"
273 send_gdb "print '\x16\xA2'\n"
275 -re "There is no character corresponding to .* in the target character set .*\\.\[\r\n\]+$gdb_prompt $" {
278 -re " = 34 '\"'\[\r\n\]+$gdb_prompt $" {
279 xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
281 -re "$gdb_prompt $" {
285 fail "$testname (timeout)"
289 set testname "untranslatable character in string literal"
290 # If the PTTY zeros bit seven, then this turns into
292 # which gets us a syntax error. We don't care.
293 send_gdb "print \"\x16\xA2\"\n"
295 -re "There is no character corresponding to .* in the target character set .*\\.\[\r\n\]+$gdb_prompt $" {
298 -re "Unterminated string in expression.\[\r\n\]+$gdb_prompt $" {
299 xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
301 -re "$gdb_prompt $" {
305 fail "$testname (timeout)"
309 set testname "untranslatable characters in backslash escape"
310 send_gdb "print '\\\x16\xA2'\n"
312 -re "The escape sequence .* is equivalent to plain .*, which has no equivalent\[\r\n\]+in the .* character set\\.\[\r\n\]+$gdb_prompt $" {
315 -re " = 34 '\"'\[\r\n\]+$gdb_prompt $" {
316 xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
318 -re "$gdb_prompt $" {
322 fail "$testname (timeout)"
331 # Set the host character set to plain ASCII, and try actually printing
332 # some strings in various target character sets. We need to run the
333 # test program to the point at which the strings have been
335 gdb_test "break ${srcfile}:[gdb_get_line_number "all strings initialized"]" \
336 ".*Breakpoint.* at .*" \
337 "set breakpoint after all strings have been initialized"
340 -re "Breakpoint.*all strings initialized.*$gdb_prompt $" {
341 pass "run until all strings have been initialized"
343 -re "$gdb_prompt $" {
344 fail "run until all strings have been initialized"
347 fail "run until all strings have been initialized (timeout)"
352 # We only try the wide character tests on machines where the wchar_t
353 # typedef in the test case has the right size.
354 set wchar_size [get_sizeof wchar_t 99]
356 if {$wchar_size == 2} {
357 lappend charset_subset UTF-16
359 } elseif {$wchar_size == 4} {
360 lappend charset_subset UTF-32
364 gdb_test "set host-charset ASCII" ""
365 foreach target_charset $charset_subset {
366 if {![valid_target_charset $target_charset]} {
370 if {$target_charset == "UTF-32" || $target_charset == "UTF-16"} {
371 set param target-wide-charset
374 set param target-charset
377 send_gdb "set $param $target_charset\n"
379 -re "$gdb_prompt $" {
380 pass "set $param $target_charset"
383 fail "set $param $target_charset (timeout)"
387 # Try printing the null character. There seems to be a bug in
388 # gdb_test that requires us to use gdb_expect here.
389 send_gdb "print $L'\\0'\n"
391 -re "\\\$${decimal} = 0 $L'\\\\000'\[\r\n\]+$gdb_prompt $" {
392 pass "print the null character in ${target_charset}"
394 -re "$gdb_prompt $" {
395 fail "print the null character in ${target_charset}"
398 fail "print the null character in ${target_charset} (timeout)"
402 # Compute the name of the variable in the test program that holds
403 # a string in $target_charset. The variable's name is the
404 # character set's name, in lower-case, with all non-identifier
405 # characters replaced with '_', with "_string" stuck on the end.
406 if {$target_charset == "UTF-16"} {
407 # We still use the utf_32_string variable -- but the size is
408 # correct for UTF-16.
409 set var_name utf_32_string
411 set var_name [string tolower "${target_charset}_string"]
412 regsub -all -- "\[^a-z0-9_\]" $var_name "_" var_name
415 # Compute a regexp matching the results we expect. This is static,
416 # but it's easier than writing it out.
417 regsub -all "." "abfnrtv" "(\\\\&|x)" escapes
418 set uppercase "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
419 set lowercase "abcdefghijklmnopqrstuvwxyz"
420 set digits "0123456789"
421 set octal_escape "\\\\\[0-9\]+"
423 send_gdb "print $var_name\n"
424 # ${escapes}${uppercase}${lowercase}${digits}${octal}${octal}
426 -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 $" {
427 pass "print string in $target_charset"
429 -re "$gdb_prompt $" {
430 fail "print string in $target_charset"
433 fail "print string in $target_charset (timeout)"
437 # Try entering a character literal, and see if it comes back unchanged.
438 gdb_test "print $L'A'" \
439 " = \[0-9-\]+ $L'A'" \
440 "parse character literal in ${target_charset}"
442 # Check that the character literal was encoded correctly.
443 gdb_test "print $L'A' == $var_name\[7\]" \
445 "check value of parsed character literal in ${target_charset}"
447 # Try entering a string literal, and see if it comes back unchanged.
448 gdb_test "print $L\"abcdefABCDEF012345\"" \
449 " = $L\"abcdefABCDEF012345\"" \
450 "parse string literal in ${target_charset}"
452 # Check that the string literal was encoded correctly.
453 gdb_test "print $L\"q\"\[0\] == $var_name\[49\]" \
455 "check value of parsed string literal in ${target_charset}"
457 # Test handling of characters in the target charset which
458 # can't be translated into the host charset.
459 if {! [string compare $target_charset iso-8859-1]} {
460 gdb_test "print iso_8859_1_string\[69\]" \
461 " = \[0-9-\]+ '\\\\242'" \
462 "print character with no equivalent in host character set"
463 gdb_test "print iso_8859_1_string + 70" \
464 " = ${hex} \"\\\\242.*\"" \
465 "print string with no equivalent in host character set"
468 # Make sure that we don't apply the ISO-8859-1 `print_literally'
470 if {! [string compare $target_charset ascii]} {
471 gdb_test "print iso_8859_1_string\[69\]" \
472 " = \[0-9-\]+ '\\\\242'" \
473 "print ASCII unprintable character"
474 gdb_test "print iso_8859_1_string + 70" \
475 " = ${hex} \"\\\\242.*\"" \
476 "print ASCII unprintable string"
479 # Try printing characters with backslash escape equivalents.
480 set escapees {a b f n r t v}
481 for {set i 0} {$i < [llength $escapees]} {incr i} {
482 set escape [lindex $escapees $i]
483 send_gdb "print $var_name\[$i\]\n"
486 -re "= \[0-9-\]+ $L'\\\\${escape}'\[\r\n\]+$gdb_prompt $" {
487 pass "try printing '\\${escape}' in ${target_charset}"
489 -re "= \[0-9-\]+ 'x'\[\r\n\]+$gdb_prompt $" {
490 xfail "try printing '\\${escape}' in ${target_charset} (no such escape)"
493 -re "$gdb_prompt $" {
494 fail "try printing '\\${escape}' in ${target_charset}"
497 fail "try printing '\\${escape}' in ${target_charset} (timeout)"
503 # Try parsing a backslash escape in a character literal.
504 gdb_test "print $L'\\${escape}' == $var_name\[$i\]" \
506 "check value of '\\${escape}' in ${target_charset}"
508 # Try parsing a backslash escape in a string literal.
509 gdb_test "print $L\"\\${escape}\"\[0\] == $var_name\[$i\]" \
511 "check value of \"\\${escape}\" in ${target_charset}"
515 # Try printing a character escape that doesn't exist. We should
516 # get the unescaped character, in the target character set.
517 gdb_test "print $L'\\q'" " = \[0-9-\]+ $L'q'" \
518 "print escape that doesn't exist in $target_charset"
519 gdb_test "print $L'\\q' == $var_name\[49\]" " = 1" \
520 "check value of escape that doesn't exist in $target_charset"
523 # Reset the target charset.
524 gdb_test "set target-charset UTF-8" ""
526 # \242 is not a valid UTF-8 character.
527 gdb_test "print \"\\242\"" " = \"\\\\242\"" \
528 "non-representable target character"
530 gdb_test "print '\\x'" "\\\\x escape without a following hex digit."
531 gdb_test "print '\\u'" "\\\\u escape without a following hex digit."
532 gdb_test "print '\\9'" " = \[0-9\]+ '9'"
534 # An octal escape can only be 3 digits.
535 gdb_test "print \"\\1011\"" " = \"A1\""
537 # Tests for wide- or unicode- strings. L is the prefix letter to use,
538 # either "L" (for wide strings), "u" (for UTF-16), or "U" (for UTF-32).
539 # NAME is used in the test names and should be related to the prefix
540 # letter in some easy-to-undestand way.
541 proc test_wide_or_unicode {L name} {
542 gdb_test "print $L\"ab\" $L\"c\"" " = $L\"abc\"" \
543 "basic $name string concatenation"
544 gdb_test "print $L\"ab\" \"c\"" " = $L\"abc\"" \
545 "narrow and $name string concatenation"
546 gdb_test "print \"ab\" $L\"c\"" " = $L\"abc\"" \
547 "$name and narrow string concatenation"
548 gdb_test "print $L\"\\xe\" $L\"c\"" " = $L\"\\\\016c\"" \
549 "$name string concatenation with escape"
550 gdb_test "print $L\"\" \"abcdef\" \"g\"" \
552 "concatenate three strings with empty $name string"
554 gdb_test "print $L'a'" "= \[0-9\]+ $L'a'" \
555 "basic $name character"
559 test_wide_or_unicode L wide
562 set ucs2_ok [expr {[get_sizeof char16_t 99] == 2}]
564 test_wide_or_unicode u UTF-16
567 set ucs4_ok [expr {[get_sizeof char32_t 99] == 4}]
569 test_wide_or_unicode U UTF-32
572 # Test an invalid string combination.
573 proc test_combination {L1 name1 L2 name2} {
574 gdb_test "print $L1\"abc\" $L2\"def\"" \
575 "Undefined string concatenation." \
576 "undefined concatenation of $name1 and $name2"
579 if {$wchar_ok && $ucs2_ok} {
580 test_combination L wide u UTF-16
582 if {$wchar_ok && $ucs4_ok} {
583 test_combination L wide U UTF-32
584 # Regression test for a typedef to a typedef.
585 gdb_test "print myvar" "= \[0-9\]+ L'A'" \
588 if {$ucs2_ok && $ucs4_ok} {
589 test_combination u UTF-16 U UTF-32
594 gdb_test_multiple "python print 'hello, world!'" \
595 "verify python support for charset tests" {
596 -re "not supported.*$gdb_prompt $" {
597 unsupported "python support is disabled"
600 -re "$gdb_prompt $" {}
604 gdb_test "print u\"abcdef\"" " = u\"abcdef\"" \
605 "set up for python printing of utf-16 string"
607 gdb_test "python print gdb.history(0).string()" "abcdef" \
608 "extract utf-16 string using python"
612 # Regression test for a cleanup bug in the charset code.
613 gdb_test "print 'a' == 'a' || 'b' == 'b'" \
615 "EVAL_SKIP cleanup handling regression test"
618 proc string_display { var_name set_prefix x_size x_type} {
619 gdb_test "set ${var_name} = ${set_prefix}\"Test String\\0with zeroes\"" "" "Assign ${var_name} with prefix ${set_prefix}"
620 gdb_test "x /2${x_size}s ${var_name}" ".* ${x_type}\"Test String\"\[\r\n\]+.* ${x_type}\"with zeroes\"" "Display String ${var_name} with x/${x_size}s"
623 string_display String16 u h u
624 if {$wchar_size == 2} {
625 string_display String16 L h u
628 string_display String32 U w U
629 if {$wchar_size == 4} {
630 string_display String32 L w U