X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ftestsuite%2Fgdb.python%2Fpy-cmd.exp;h=944851dd9443241d64c0dcb1b34bd924ff811315;hb=11bc5fe47ff897f8aa8bfe4dc9268e8bb68c4d9a;hp=f6ef938f48af4e40db1e119226670c2100748e01;hpb=5172aecbd2b65e71aedbd21c46253ca6a20227aa;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/testsuite/gdb.python/py-cmd.exp b/gdb/testsuite/gdb.python/py-cmd.exp index f6ef938f48..944851dd94 100644 --- a/gdb/testsuite/gdb.python/py-cmd.exp +++ b/gdb/testsuite/gdb.python/py-cmd.exp @@ -1,4 +1,4 @@ -# Copyright (C) 2009 Free Software Foundation, Inc. +# Copyright (C) 2009-2020 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 @@ -16,40 +16,20 @@ # This file is part of the GDB testsuite. It tests the mechanism # for defining new GDB commands in Python. -if $tracelevel then { - strace $tracelevel -} +load_lib gdb-python.exp -# Usage: gdb_py_test_multiple NAME INPUT RESULT {INPUT RESULT}... -# Run a test named NAME, consisting of multiple lines of input. -# After each input line INPUT, search for result line RESULT. -# Succeed if all results are seen; fail otherwise. -proc gdb_py_test_multiple {name args} { - global gdb_prompt - foreach {input result} $args { - if {[gdb_test_multiple $input "$name - $input" { - -re "\[\r\n\]*($result)\[\r\n\]+($gdb_prompt | *>)$" { - pass "$name - $input" - } - }]} { - return 1 - } - } - return 0 -} +standard_testfile -# Start with a fresh gdb. +if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } { + return -1 +} -gdb_exit -gdb_start -gdb_reinitialize_dir $srcdir/$subdir +# Skip all tests if Python scripting is not enabled. +if { [skip_python_tests] } { continue } -gdb_test_multiple "python print 'hello, world!'" "verify python support" { - -re "not supported.*$gdb_prompt $" { - unsupported "python support is disabled" - return -1 - } - -re "$gdb_prompt $" {} +if ![runto_main] then { + fail "cannot run to main." + return 0 } # Test a simple command. @@ -60,7 +40,7 @@ gdb_py_test_multiple "input simple command" \ " def __init__ (self):" "" \ " super (test_cmd, self).__init__ (\"test_cmd\", gdb.COMMAND_OBSCURE)" "" \ " def invoke (self, arg, from_tty):" "" \ - " print \"test_cmd output, arg = %s\" % arg" "" \ + " print (\"test_cmd output, arg = %s\" % arg)" "" \ "test_cmd ()" "" \ "end" "" @@ -74,7 +54,7 @@ gdb_py_test_multiple "input prefix command" \ " def __init__ (self):" "" \ " super (prefix_cmd, self).__init__ (\"prefix_cmd\", gdb.COMMAND_OBSCURE, gdb.COMPLETE_NONE, True)" "" \ " def invoke (self, arg, from_tty):" "" \ - " print \"prefix_cmd output, arg = %s\" % arg" "" \ + " print (\"prefix_cmd output, arg = %s\" % arg)" "" \ "prefix_cmd ()" "" \ "end" "" @@ -86,7 +66,7 @@ gdb_py_test_multiple "input subcommand" \ " def __init__ (self):" "" \ " super (subcmd, self).__init__ (\"prefix_cmd subcmd\", gdb.COMMAND_OBSCURE)" "" \ " def invoke (self, arg, from_tty):" "" \ - " print \"subcmd output, arg = %s\" % arg" "" \ + " print (\"subcmd output, arg = %s\" % arg)" "" \ "subcmd ()" "" \ "end" "" @@ -100,7 +80,7 @@ gdb_py_test_multiple "input prefix command, keyword arguments" \ " def __init__ (self):" "" \ " super (prefix_cmd2, self).__init__ (\"prefix_cmd2\", gdb.COMMAND_OBSCURE, prefix = True, completer_class = gdb.COMPLETE_FILENAME)" "" \ " def invoke (self, arg, from_tty):" "" \ - " print \"prefix_cmd2 output, arg = %s\" % arg" "" \ + " print (\"prefix_cmd2 output, arg = %s\" % arg)" "" \ "prefix_cmd2 ()" "" \ "end" "" @@ -112,7 +92,7 @@ gdb_py_test_multiple "input subcommand under prefix_cmd2" \ " def __init__ (self):" "" \ " super (subcmd, self).__init__ (\"prefix_cmd2 subcmd\", gdb.COMMAND_OBSCURE)" "" \ " def invoke (self, arg, from_tty):" "" \ - " print \"subcmd output, arg = %s\" % arg" "" \ + " print (\"subcmd output, arg = %s\" % arg)" "" \ "subcmd ()" "" \ "end" "" @@ -126,8 +106,198 @@ gdb_py_test_multiple "input new subcommand" \ " def __init__ (self):" "" \ " super (newsubcmd, self).__init__ (\"info newsubcmd\", gdb.COMMAND_OBSCURE)" "" \ " def invoke (self, arg, from_tty):" "" \ - " print \"newsubcmd output, arg = %s\" % arg" "" \ + " print (\"newsubcmd output, arg = %s\" % arg)" "" \ "newsubcmd ()" "" \ "end" "" gdb_test "info newsubcmd ugh" "newsubcmd output, arg = ugh" "call newsubcmd" + +# Test a command that throws gdb.GdbError. + +gdb_py_test_multiple "input command to throw error" \ + "python" "" \ + "class test_error_cmd (gdb.Command):" "" \ + " def __init__ (self):" "" \ + " super (test_error_cmd, self).__init__ (\"test_error_cmd\", gdb.COMMAND_OBSCURE)" "" \ + " def invoke (self, arg, from_tty):" "" \ + " raise gdb.GdbError ('you lose!')" "" \ + "test_error_cmd ()" "" \ + "end" "" + +gdb_test "test_error_cmd ugh" "you lose!" "call error command" + +# Test gdb.string_to_argv. + +gdb_test "python print (gdb.string_to_argv (\"1 2 3\"))" \ + {\['1', '2', '3'\]} \ + "string_to_argv (\"1 2 3\")" + +gdb_test "python print (gdb.string_to_argv (\"'1 2' 3\"))" \ + {\['1 2', '3'\]} \ + "string_to_argv (\"'1 2' 3\")" + +gdb_test "python print (gdb.string_to_argv ('\"1 2\" 3'))" \ + {\['1 2', '3'\]} \ + "string_to_argv ('\"1 2\" 3')" + +gdb_test "python print (gdb.string_to_argv ('1\\ 2 3'))" \ + {\['1 2', '3'\]} \ + "string_to_argv ('1\\ 2 3')" + +# Test user-defined python commands. +gdb_py_test_multiple "input simple user-defined command" \ + "python" "" \ + "class test_help (gdb.Command):" "" \ + " \"\"\"Docstring\"\"\"" "" \ + " def __init__ (self):" "" \ + " super (test_help, self).__init__ (\"test_help\", gdb.COMMAND_USER)" "" \ + " def invoke (self, arg, from_tty):" "" \ + " print (\"test_cmd output, arg = %s\" % arg)" "" \ + "test_help ()" "" \ + "end" "" + +gdb_test "test_help ugh" "test_cmd output, arg = ugh" "call simple user-defined command" + +# Make sure the command shows up in `help user-defined`. +test_user_defined_class_help {"test_help -- Docstring[\r\n]"} + +# Make sure the command does not show up in `show user`. +gdb_test "show user test_help" "Not a user command\." \ + "don't show user-defined python command in `show user command`" + +# Test expression completion on fields +gdb_py_test_multiple "expression completion command" \ + "python" "" \ + "class expr_test (gdb.Command):" "" \ + " def __init__ (self):" "" \ + " super (expr_test, self).__init__ (\"expr_test\", gdb.COMMAND_USER, gdb.COMPLETE_EXPRESSION)" "" \ + " def invoke (self, arg, from_tty):" "" \ + " print (\"invoked on = %s\" % arg)" "" \ + "expr_test ()" "" \ + "end" "" + + +gdb_test "complete expr_test bar\." \ + "expr_test bar\.bc.*expr_test bar\.ij.*" \ + "test completion through complete command" + +# Test that the "python" command is correctly recognized as +# inline/multi-line when entering a sequence of commands. +# +# This proc tests PR cli/21688. The PR is not language-specific, but +# the easiest way is just to test with Python. +proc test_python_inline_or_multiline { } { + global gdb_prompt + set end "\r\n$gdb_prompt $" + + set define_cmd_not_inline [ list \ + [ list "if 1" " >$" "multi-line if 1" ] \ + [ list "python" " >$" "multi-line python command" ] \ + [ list "print ('hello')" " >$" "multi-line print" ] \ + [ list "end" " >$" "multi-line first end" ] \ + [ list "end" "hello$end" "multi-line last end" ] ] + + # This also tests trailing whitespace on the command. + set define_cmd_alias_not_inline [ list \ + [ list "if 1" " >$" "multi-line if 1 alias" ] \ + [ list "py " " >$" "multi-line python command alias" ] \ + [ list "print ('hello')" " >$" "multi-line print alias" ] \ + [ list "end" " >$" "multi-line first end alias" ] \ + [ list "end" "hello$end" "multi-line last end alias" ] ] + + set define_cmd_alias_foo_not_inline [ list \ + [ list "alias foo=python" "$end" "multi-line alias foo" ] \ + [ list "if 1" " >$" "multi-line if 1 alias foo" ] \ + [ list "foo " " >$" "multi-line python command alias foo" ] \ + [ list "print ('hello')" " >$" "multi-line print alias foo" ] \ + [ list "end" " >$" "multi-line first end alias foo" ] \ + [ list "end" "hello$end" "multi-line last end alias foo" ] ] + + set define_cmd_inline [ list \ + [ list "if 1" " >$" "inline if 1" ] \ + [ list "python print ('hello')" " >$" "inline python command" ] \ + [ list "end" "hello$end" "inline end" ] ] + + set define_cmd_alias_inline [ list \ + [ list "if 1" " >$" "inline if 1 alias" ] \ + [ list "py print ('hello')" " >$" "inline python command alias" ] \ + [ list "end" "hello$end" "inline end alias" ] ] + + set define_cmd_alias_foo_inline [ list \ + [ list "if 1" " >$" "inline if 1 alias foo" ] \ + [ list "foo print ('hello')" " >$" "inline python command alias foo" ] \ + [ list "end" "hello$end" "inline end alias foo" ] ] + + foreach t [list $define_cmd_not_inline \ + $define_cmd_alias_not_inline \ + $define_cmd_alias_foo_not_inline \ + $define_cmd_inline \ + $define_cmd_alias_inline \ + $define_cmd_alias_foo_inline] { + foreach l $t { + lassign $l command regex testmsg + gdb_test_multiple "$command" "$testmsg" { + -re "$regex" { + pass "$testmsg" + } + } + } + } +} + +test_python_inline_or_multiline + +if { [readline_is_used] } { + set test "complete 'expr_test bar.i'" + send_gdb "expr_test bar\.i\t\t" + gdb_test_multiple "" "$test" { + -re "expr_test bar\.ij \\\x07$" { + send_gdb "\n" + gdb_test_multiple "" $test { + -re "invoked on = bar.ij.*$gdb_prompt $" { + pass "$test" + } + } + } + } +} + + +# Test that interrupting pagination throws a gdb quit. +gdb_test_no_output "set height 10" + +gdb_py_test_multiple "input multi-line-output command" \ + "python" "" \ + "class test_mline (gdb.Command):" "" \ + " \"\"\"Docstring\"\"\"" "" \ + " def __init__ (self):" "" \ + " super (test_mline, self).__init__ (\"test_multiline\", gdb.COMMAND_USER)" "" \ + " def invoke (self, arg, from_tty):" "" \ + " for f in range(20):" "" \ + " print (\"test_multiline output\")" "" \ + "test_mline ()" "" \ + "end" "" + +set test "verify pagination from test_multiline" +gdb_test_multiple "test_multiline" $test { + -re "--Type " { + exp_continue + } + -re " for more, q to quit" { + exp_continue + } + -re ", c to continue without paging--$" { + pass $test + } +} + +send_gdb "q\n" +set test "verify pagination from test_multiline: q" +gdb_test_multiple "test_multiline" $test { + -re "Error occurred in Python" { + fail $test + } + -re "Quit" { + pass $test + } +}