gdb/testsuite: Reduce test name duplication in gdb.python tests
authorAndrew Burgess <andrew.burgess@embecosm.com>
Mon, 16 Sep 2019 01:53:11 +0000 (21:53 -0400)
committerAndrew Burgess <andrew.burgess@embecosm.com>
Thu, 3 Oct 2019 16:48:03 +0000 (17:48 +0100)
This commit removes some, but not all, of the test name duplication
within the gdb.python tests.  On my local machine this takes the
number of duplicate test names in this set of tests from 174 to 85.
It is possible that different setups might encounter more duplicate
tests.

gdb/testsuite/ChangeLog:

* gdb.python/py-parameter.exp: Make test names unique.
* gdb.python/py-template.exp: Likewise.
* gdb.python/py-value.exp: Likewise.

gdb/testsuite/ChangeLog
gdb/testsuite/gdb.python/py-parameter.exp
gdb/testsuite/gdb.python/py-template.exp
gdb/testsuite/gdb.python/py-value.exp

index 2261b15542b30b4296393f6b9b1fefefbdc40a66..c0f4a589857a9bf77f88a232565e96f8f8702a6a 100644 (file)
@@ -1,3 +1,9 @@
+2019-10-03  Andrew Burgess  <andrew.burgess@embecosm.com>
+
+       * gdb.python/py-parameter.exp: Make test names unique.
+       * gdb.python/py-template.exp: Likewise.
+       * gdb.python/py-value.exp: Likewise.
+
 2019-10-03  Andrew Burgess  <andrew.burgess@embecosm.com>
 
        * gdb.base/break-interp.exp: Reduce test name duplication.
index a199f72dd14322d53d5cb8a10ee2ddbd47d123d9..b2f78777338a072e2e92aeb0e4d877b82e972096 100644 (file)
@@ -38,147 +38,204 @@ if { [is_remote host] } {
 gdb_test "python print (gdb.parameter ('directories'))" $directories
 
 # Test a simple boolean parameter.
-gdb_py_test_multiple "Simple gdb booleanparameter" \
-   "python" "" \
-   "class TestParam (gdb.Parameter):" "" \
-   "   \"\"\"When enabled, test param does something useful. When disabled, does nothing.\"\"\"" "" \
-   "   show_doc = \"Show the state of the boolean test-param\"" ""\
-   "   set_doc = \"Set the state of the boolean test-param\"" "" \
-   "   def get_show_string (self, pvalue):" ""\
-   "      return \"The state of the Test Parameter is \" + pvalue" ""\
-   "   def get_set_string (self):" ""\
-   "      val = \"on\"" ""\
-   "      if (self.value == False):" ""\
-   "         val = \"off\"" ""\
-   "      return \"Test Parameter has been set to \" + val" ""\
-   "   def __init__ (self, name):" "" \
-   "      super (TestParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN)" "" \
-   "      self.value = True" "" \
-   "test_param = TestParam ('print test-param')" ""\
-   "end"
-
-gdb_test "python print (test_param.value)" "True" "test parameter value"
-gdb_test "show print test-param" "The state of the Test Parameter is on.*" "show parameter on"
-gdb_test "set print test-param off" "Test Parameter has been set to off" "turn off parameter"
-gdb_test "show print test-param" "The state of the Test Parameter is off.*" "show parameter off"
-gdb_test "python print (test_param.value)" "False" "test parameter value"
-gdb_test "help show print test-param" "Show the state of the boolean test-param.*" "test show help"
-gdb_test "help set print test-param" "Set the state of the boolean test-param.*" "test set help"
-gdb_test "help set print" "set print test-param -- Set the state of the boolean test-param.*" "test general help"
+with_test_prefix "boolean parameter" {
+    gdb_py_test_multiple "Simple gdb booleanparameter" \
+       "python" "" \
+       "class TestParam (gdb.Parameter):" "" \
+       "   \"\"\"When enabled, test param does something useful. When disabled, does nothing.\"\"\"" "" \
+       "   show_doc = \"Show the state of the boolean test-param\"" ""\
+       "   set_doc = \"Set the state of the boolean test-param\"" "" \
+       "   def get_show_string (self, pvalue):" ""\
+       "      return \"The state of the Test Parameter is \" + pvalue" ""\
+       "   def get_set_string (self):" ""\
+       "      val = \"on\"" ""\
+       "      if (self.value == False):" ""\
+       "         val = \"off\"" ""\
+       "      return \"Test Parameter has been set to \" + val" ""\
+       "   def __init__ (self, name):" "" \
+       "      super (TestParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN)" "" \
+       "      self.value = True" "" \
+       "test_param = TestParam ('print test-param')" ""\
+       "end"
 
+    gdb_test "python print (test_param.value)" "True" \
+       "test boolean parameter value is True"
+    gdb_test "show print test-param" \
+       "The state of the Test Parameter is on.*" "show parameter on"
+    gdb_test "set print test-param off" \
+       "Test Parameter has been set to off" "turn off parameter"
+    gdb_test "show print test-param" \
+       "The state of the Test Parameter is off.*" "show parameter off"
+    gdb_test "python print (test_param.value)" "False" \
+       "test boolean parameter value is False"
+    gdb_test "help show print test-param" \
+       "Show the state of the boolean test-param.*" "test show help"
+    gdb_test "help set print test-param" \
+       "Set the state of the boolean test-param.*" "test set help"
+    gdb_test "help set print" \
+       "set print test-param -- Set the state of the boolean test-param.*" \
+       "test general help"
+}
 
 # Test an enum parameter.
-gdb_py_test_multiple "enum gdb parameter" \
-   "python" "" \
-   "class TestEnumParam (gdb.Parameter):" "" \
-   "   \"\"\"When set, test param does something useful. When disabled, does nothing.\"\"\"" "" \
-   "   show_doc = \"Show the state of the enum\"" ""\
-   "   set_doc = \"Set the state of the enum\"" "" \
-   "   def get_show_string (self, pvalue):" ""\
-   "      return \"The state of the enum is \" + pvalue" ""\
-   "   def get_set_string (self):" ""\
-   "      return \"The state of the enum has been set to \" + self.value" ""\
-   "   def __init__ (self, name):" "" \
-   "      super (TestEnumParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_ENUM, \[\"one\", \"two\"\])" "" \
-   "      self.value = \"one\"" "" \
-   "test_enum_param = TestEnumParam ('print test-enum-param')" ""\
-   "end"
-
-gdb_test "python print (test_enum_param.value)" "one" "test enum parameter value"
-gdb_test "show print test-enum-param" "The state of the enum is one.*" "show parameter is initial value"
-gdb_test "set print test-enum-param two" "The state of the enum has been set to two" "set enum to two"
-gdb_test "show print test-enum-param" "The state of the enum is two.*" "show parameter is new value"
-gdb_test "python print (test_enum_param.value)" "two" "test enum parameter value"
-gdb_test "set print test-enum-param three" "Undefined item: \"three\".*" "set invalid enum parameter"
+with_test_prefix "enum parameter" {
+    gdb_py_test_multiple "enum gdb parameter" \
+       "python" "" \
+       "class TestEnumParam (gdb.Parameter):" "" \
+       "   \"\"\"When set, test param does something useful. When disabled, does nothing.\"\"\"" "" \
+       "   show_doc = \"Show the state of the enum\"" ""\
+       "   set_doc = \"Set the state of the enum\"" "" \
+       "   def get_show_string (self, pvalue):" ""\
+       "      return \"The state of the enum is \" + pvalue" ""\
+       "   def get_set_string (self):" ""\
+       "      return \"The state of the enum has been set to \" + self.value" ""\
+       "   def __init__ (self, name):" "" \
+       "      super (TestEnumParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_ENUM, \[\"one\", \"two\"\])" "" \
+       "      self.value = \"one\"" "" \
+       "test_enum_param = TestEnumParam ('print test-enum-param')" ""\
+       "end"
+
+    gdb_test "python print (test_enum_param.value)" "one" \
+       "test enum parameter value is one"
+    gdb_test "show print test-enum-param" \
+       "The state of the enum is one.*" \
+       "show parameter is initial value"
+    gdb_test "set print test-enum-param two" \
+       "The state of the enum has been set to two" "set enum to two"
+    gdb_test "show print test-enum-param" \
+       "The state of the enum is two.*" "show parameter is new value"
+    gdb_test "python print (test_enum_param.value)" "two" \
+       "test enum parameter value is two"
+    gdb_test "set print test-enum-param three" \
+       "Undefined item: \"three\".*" "set invalid enum parameter"
+}
 
 # Test a file parameter.
-gdb_py_test_multiple "file gdb parameter" \
-   "python" "" \
-   "class TestFileParam (gdb.Parameter):" "" \
-   "   \"\"\"When set, test param does something useful. When disabled, does nothing.\"\"\"" "" \
-   "   show_doc = \"Show the name of the file\"" ""\
-   "   set_doc = \"Set the name of the file\"" "" \
-   "   def get_show_string (self, pvalue):" ""\
-   "      return \"The name of the file is \" + pvalue" ""\
-   "   def get_set_string (self):" ""\
-   "      return \"The name of the file has been changed to \" + self.value" ""\
-   "   def __init__ (self, name):" "" \
-   "      super (TestFileParam, self).__init__ (name, gdb.COMMAND_FILES, gdb.PARAM_FILENAME)" "" \
-   "      self.value = \"foo.txt\"" "" \
-   "test_file_param = TestFileParam ('test-file-param')" ""\
-   "end"
-
-gdb_test "python print (test_file_param.value)" "foo.txt" "test file parameter value"
-gdb_test "show test-file-param" "The name of the file is foo.txt.*" "show initial file value"
-gdb_test "set test-file-param bar.txt" "The name of the file has been changed to bar.txt" "set new file parameter" 1
-gdb_test "show test-file-param" "The name of the file is bar.txt.*" "show new file value"
-gdb_test "python print (test_file_param.value)" "bar.txt" "test new file parameter value"
-gdb_test "set test-file-param" "Argument required.*" 
+with_test_prefix "file parameter" {
+    gdb_py_test_multiple "file gdb parameter" \
+       "python" "" \
+       "class TestFileParam (gdb.Parameter):" "" \
+       "   \"\"\"When set, test param does something useful. When disabled, does nothing.\"\"\"" "" \
+       "   show_doc = \"Show the name of the file\"" ""\
+       "   set_doc = \"Set the name of the file\"" "" \
+       "   def get_show_string (self, pvalue):" ""\
+       "      return \"The name of the file is \" + pvalue" ""\
+       "   def get_set_string (self):" ""\
+       "      return \"The name of the file has been changed to \" + self.value" ""\
+       "   def __init__ (self, name):" "" \
+       "      super (TestFileParam, self).__init__ (name, gdb.COMMAND_FILES, gdb.PARAM_FILENAME)" "" \
+       "      self.value = \"foo.txt\"" "" \
+       "test_file_param = TestFileParam ('test-file-param')" ""\
+       "end"
+
+    gdb_test "python print (test_file_param.value)" "foo.txt" \
+       "test file parameter value"
+    gdb_test "show test-file-param" \
+       "The name of the file is foo.txt.*" "show initial file value"
+    gdb_test "set test-file-param bar.txt" \
+       "The name of the file has been changed to bar.txt" \
+       "set new file parameter" 1
+    gdb_test "show test-file-param" \
+       "The name of the file is bar.txt.*" "show new file value"
+    gdb_test "python print (test_file_param.value)" \
+       "bar.txt" "test new file parameter value"
+    gdb_test "set test-file-param" "Argument required.*"
+}
 
 # Test a parameter that is not documented.
-gdb_py_test_multiple "Simple gdb booleanparameter" \
-   "python" "" \
-   "class TestUndocParam (gdb.Parameter):" "" \
-   "   def get_show_string (self, pvalue):" ""\
-   "      return \"The state of the Test Parameter is \" + pvalue" ""\
-   "   def get_set_string (self):" ""\
-   "      val = \"on\"" ""\
-   "      if (self.value == False):" ""\
-   "         val = \"off\"" ""\
-   "      return \"Test Parameter has been set to \" + val" ""\
-   "   def __init__ (self, name):" "" \
-   "      super (TestUndocParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN)" "" \
-   "      self.value = True" "" \
-   "test_undoc_param = TestUndocParam ('print test-undoc-param')" ""\
-   "end"
-
-gdb_test "show print test-undoc-param" "The state of the Test Parameter is on.*" "show parameter on"
-gdb_test "set print test-undoc-param off" "Test Parameter has been set to off" "turn off parameter"
-gdb_test "show print test-undoc-param" "The state of the Test Parameter is off.*" "show parameter off"
-gdb_test "python print (test_undoc_param.value)" "False" "test parameter value"
-gdb_test "help show print test-undoc-param" "This command is not documented.*" "test show help"
-gdb_test "help set print test-undoc-param" "This command is not documented.*" "test set help"
-gdb_test "help set print" "set print test-undoc-param -- This command is not documented.*" "test general help"
+with_test_prefix "undocumented parameter" {
+    gdb_py_test_multiple "Simple gdb booleanparameter" \
+       "python" "" \
+       "class TestUndocParam (gdb.Parameter):" "" \
+       "   def get_show_string (self, pvalue):" ""\
+       "      return \"The state of the Test Parameter is \" + pvalue" ""\
+       "   def get_set_string (self):" ""\
+       "      val = \"on\"" ""\
+       "      if (self.value == False):" ""\
+       "         val = \"off\"" ""\
+       "      return \"Test Parameter has been set to \" + val" ""\
+       "   def __init__ (self, name):" "" \
+       "      super (TestUndocParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN)" "" \
+       "      self.value = True" "" \
+       "test_undoc_param = TestUndocParam ('print test-undoc-param')" ""\
+       "end"
+
+    gdb_test "show print test-undoc-param" \
+       "The state of the Test Parameter is on.*" "show parameter on"
+    gdb_test "set print test-undoc-param off" \
+       "Test Parameter has been set to off" "turn off parameter"
+    gdb_test "show print test-undoc-param" \
+       "The state of the Test Parameter is off.*" "show parameter off"
+    gdb_test "python print (test_undoc_param.value)" \
+       "False" "test undocumented parameter value is False"
+    gdb_test "help show print test-undoc-param" \
+       "This command is not documented.*" "test show help"
+    gdb_test "help set print test-undoc-param" \
+       "This command is not documented.*" "test set help"
+    gdb_test "help set print" \
+       "set print test-undoc-param -- This command is not documented.*" \
+       "test general help"
+}
 
 # Test a parameter that is not documented in any way..
-gdb_py_test_multiple "Simple gdb booleanparameter" \
-   "python" "" \
-   "class TestNodocParam (gdb.Parameter):" "" \
-   "   def __init__ (self, name):" "" \
-   "      super (TestNodocParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN)" "" \
-   "      self.value = True" "" \
-   "test_nodoc_param = TestNodocParam ('print test-nodoc-param')" ""\
-   "end"
-
-gdb_test "show print test-nodoc-param" "This command is not documented.*" "show parameter on"
-gdb_test_no_output "set print test-nodoc-param off" "turn off parameter"
-gdb_test "show print test-nodoc-param" "This command is not documented.*.*" "show parameter off"
-gdb_test "python print (test_nodoc_param.value)" "False" "test parameter value"
-gdb_test "help show print test-nodoc-param" "This command is not documented.*" "test show help"
-gdb_test "help set print test-nodoc-param" "This command is not documented.*" "test set help"
-gdb_test "help set print" "set print test-nodoc-param -- This command is not documented.*" "test general help"
+with_test_prefix "really undocumented parameter" {
+    gdb_py_test_multiple "Simple gdb booleanparameter" \
+       "python" "" \
+       "class TestNodocParam (gdb.Parameter):" "" \
+       "   def __init__ (self, name):" "" \
+       "      super (TestNodocParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN)" "" \
+       "      self.value = True" "" \
+       "test_nodoc_param = TestNodocParam ('print test-nodoc-param')" ""\
+       "end"
+
+    gdb_test "show print test-nodoc-param" \
+       "This command is not documented.*" "show parameter on"
+    gdb_test_no_output "set print test-nodoc-param off" \
+       "turn off parameter"
+    gdb_test "show print test-nodoc-param" \
+       "This command is not documented.*.*" "show parameter off"
+    gdb_test "python print (test_nodoc_param.value)" \
+       "False" "test really undocumented parameter value is False"
+    gdb_test "help show print test-nodoc-param" \
+       "This command is not documented.*" "test show help"
+    gdb_test "help set print test-nodoc-param" \
+       "This command is not documented.*" "test set help"
+    gdb_test "help set print" \
+       "set print test-nodoc-param -- This command is not documented.*" \
+       "test general help"
+}
 
 # Test deprecated API. Do not use in your own implementations.
-gdb_py_test_multiple "Simple gdb booleanparameter" \
-   "python" "" \
-   "class TestParam (gdb.Parameter):" "" \
-   "   \"\"\"When enabled, test param does something useful. When disabled, does nothing.\"\"\"" "" \
-   "   show_doc = \"State of the Test Parameter\"" ""\
-   "   set_doc = \"Set the state of the Test Parameter\"" "" \
-   "   def __init__ (self, name):" "" \
-   "      super (TestParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN)" "" \
-   "      self.value = True" "" \
-   "test_param = TestParam ('print test-param')" ""\
-   "end"
-
-gdb_test "python print (test_param.value)" "True" "test parameter value"
-gdb_test "show print test-param" "State of the Test Parameter on.*" "show parameter on"
-gdb_test_no_output "set print test-param off" "turn off parameter"
-gdb_test "show print test-param" "State of the Test Parameter off.*" "show parameter off"
-gdb_test "python print (test_param.value)" "False" "test parameter value"
-gdb_test "help show print test-param" "State of the Test Parameter.*" "test show help"
-gdb_test "help set print test-param" "Set the state of the Test Parameter.*" "test set help"
-gdb_test "help set print" "set print test-param -- Set the state of the Test Parameter.*" "test general help"
+with_test_prefix "deprecated API parameter" {
+    gdb_py_test_multiple "Simple gdb booleanparameter" \
+       "python" "" \
+       "class TestParam (gdb.Parameter):" "" \
+       "   \"\"\"When enabled, test param does something useful. When disabled, does nothing.\"\"\"" "" \
+       "   show_doc = \"State of the Test Parameter\"" ""\
+       "   set_doc = \"Set the state of the Test Parameter\"" "" \
+       "   def __init__ (self, name):" "" \
+       "      super (TestParam, self).__init__ (name, gdb.COMMAND_DATA, gdb.PARAM_BOOLEAN)" "" \
+       "      self.value = True" "" \
+       "test_param = TestParam ('print test-param')" ""\
+       "end"
+
+    gdb_test "python print (test_param.value)" "True" \
+       "test deprecated API parameter value is True"
+    gdb_test "show print test-param" \
+       "State of the Test Parameter on.*" "show parameter on"
+    gdb_test_no_output "set print test-param off" "turn off parameter"
+    gdb_test "show print test-param" \
+       "State of the Test Parameter off.*" "show parameter off"
+    gdb_test "python print (test_param.value)" "False" \
+       "test deprecated API parameter value is False"
+    gdb_test "help show print test-param" \
+       "State of the Test Parameter.*" "test show help"
+    gdb_test "help set print test-param" \
+       "Set the state of the Test Parameter.*" "test set help"
+    gdb_test "help set print" \
+       "set print test-param -- Set the state of the Test Parameter.*" \
+       "test general help"
+}
 
 foreach kind {PARAM_ZUINTEGER PARAM_ZUINTEGER_UNLIMITED} {
     gdb_py_test_multiple "Simple gdb $kind" \
index 82b9f35fbaa500f38242d5a243202ea5c7f1d149..d0bded49d923f4a6ebf843d67cefba56089974e8 100644 (file)
@@ -48,8 +48,10 @@ proc test_template_arg {exefile type} {
        return
     }
     # There is no executable code in main(), so we are where we want to be
-    gdb_test "print (foo)" ".*"
-    gdb_test_no_output "python foo = gdb.history(0)"
+    gdb_test "print (foo)" ".*" \
+       "print (foo) in template test of $type"
+    gdb_test_no_output "python foo = gdb.history(0)" \
+       "fetch foo from gdb.history(0) in template test of $type"
 
     # Replace '*' with '\*' in regex.
     regsub -all {\*} $type {\*} t
@@ -57,7 +59,7 @@ proc test_template_arg {exefile type} {
 
     gdb_test "python print(foo.type.template_argument(-1))" \
        "Template argument number must be non-negative\r\nError while executing Python code." \
-       "negative template argument number"
+       "negative template argument number in template test of $type"
 }
 
 test_template_arg "${binfile}-ci" "const int"
index 51edfa30958a056fcbd35f48603600cc3cc14533..44939800b9f4d789ca0587a691dee72722d2e06a 100644 (file)
@@ -189,9 +189,9 @@ proc test_value_boolean {} {
 
   gdb_test "py test_bool (gdb.Value (0))" "nay" "check evaluation of false integer value in expression"
 
-  gdb_test "py test_bool (gdb.Value (5.2))" "yay" "check evaluation of true integer value in expression"
+  gdb_test "py test_bool (gdb.Value (5.2))" "yay" "check evaluation of true float value in expression"
 
-  gdb_test "py test_bool (gdb.Value (0.0))" "nay" "check evaluation of false integer value in expression"
+  gdb_test "py test_bool (gdb.Value (0.0))" "nay" "check evaluation of false float value in expression"
 }
 
 proc test_value_compare {} {
@@ -232,13 +232,12 @@ proc test_value_in_inferior {} {
   global gdb_py_is_py3k
 
   gdb_breakpoint [gdb_get_line_number "break to inspect struct and union"]
-
   gdb_continue_to_breakpoint "break to inspect struct and union"
 
   # Just get inferior variable s in the value history, available to python.
   gdb_test "print s" " = {a = 3, b = 5}" ""
 
-  gdb_py_test_silent_cmd "python s = gdb.history (0)" "get value from history" 1
+  gdb_py_test_silent_cmd "python s = gdb.history (0)" "get value from history" 1
 
   gdb_test "python print ('result = ' + str(s\['a'\]))" " = 3" "access element inside struct using 8-bit string name"
   if { $gdb_py_is_py3k == 0 } {
@@ -290,17 +289,23 @@ proc test_value_in_inferior {} {
   } else {
     gdb_test "python inval = gdb.parse_and_eval('*(int*)0')"
     gdb_test "python print (inval.is_lazy)" "True"
-    gdb_test "python inval2 = inval+1" "gdb.MemoryError: Cannot access memory at address 0x0.*" $test
-    gdb_test "python inval.fetch_lazy ()" "gdb.MemoryError: Cannot access memory at address 0x0.*" $test
+    gdb_test "python inval2 = inval+1" \
+       "gdb.MemoryError: Cannot access memory at address 0x0.*" \
+       "$test, first test"
+    gdb_test "python inval.fetch_lazy ()" \
+       "gdb.MemoryError: Cannot access memory at address 0x0.*" \
+       "$test, second test"
   }
   set argc_value [get_integer_valueof "argc" 0]
   gdb_test "python argc_lazy = gdb.parse_and_eval('argc')"
   gdb_test "python argc_notlazy = gdb.parse_and_eval('argc')"
   gdb_test "python argc_notlazy.fetch_lazy()"
-  gdb_test "python print (argc_lazy.is_lazy)" "True"
+  gdb_test "python print (argc_lazy.is_lazy)" "True" \
+      "python print (argc_lazy.is_lazy) the first time"
   gdb_test "python print (argc_notlazy.is_lazy)" "False"
   gdb_test "print argc" " = $argc_value" "sanity check argc"
-  gdb_test "python print (argc_lazy.is_lazy)" "\r\nTrue"
+  gdb_test "python print (argc_lazy.is_lazy)" "\r\nTrue" \
+      "python print (argc_lazy.is_lazy) the second time"
   gdb_test_no_output "set argc=[expr $argc_value + 1]" "change argc"
   gdb_test "python print (argc_notlazy)" "\r\n$argc_value"
   gdb_test "python print (argc_lazy)" "\r\n[expr $argc_value + 1]"
@@ -308,7 +313,7 @@ proc test_value_in_inferior {} {
 
   # Test string fetches,  both partial and whole.
   gdb_test "print st" "\"divide et impera\""
-  gdb_py_test_silent_cmd "python st = gdb.history (0)" "get value from history" 1
+  gdb_py_test_silent_cmd "python st = gdb.history (0)" "get value st from history" 1
   gdb_test "python print (st.string ())"  "divide et impera"  "Test string with no length"
   gdb_test "python print (st.string (length = -1))" "divide et impera" "test string (length = -1) is all of the string"
   gdb_test "python print (st.string (length = 6))" "divide"
@@ -325,7 +330,7 @@ proc test_value_in_inferior {} {
 
   # Fetch a string that has embedded nulls.
   gdb_test "print nullst" "\"divide\\\\000et\\\\000impera\".*"
-  gdb_py_test_silent_cmd "python nullst = gdb.history (0)" "get value from history" 1
+  gdb_py_test_silent_cmd "python nullst = gdb.history (0)" "get value nullst from history" 1
   gdb_test "python print (nullst.string ())" "divide" "test string to first null"
   # Python cannot print strings that contain the null (\0) character.
   # For the purposes of this test, use repr()
@@ -350,26 +355,28 @@ proc test_inferior_function_call {} {
 
     # Correct inferior call without arguments.
     gdb_test "p/x fp1" " = $hex.*"
-    gdb_py_test_silent_cmd "python fp1 = gdb.history (0)" "get value from history" 1
+    gdb_py_test_silent_cmd "python fp1 = gdb.history (0)" "get value fp1 from history" 1
     gdb_test "python fp1 = fp1.dereference()" ""
     gdb_test "python result = fp1()" ""
     gdb_test "python print (result)" "void"
 
     # Correct inferior call with arguments.
-    gdb_test "p/x fp2" " = $hex.*"
-    gdb_py_test_silent_cmd "python fp2 = gdb.history (0)" "get value from history" 1
+    gdb_test "p/x fp2" " = $hex.*" \
+       "print fp2 to place it into history"
+    gdb_py_test_silent_cmd "python fp2 = gdb.history (0)" "get value fp2 from history" 1
     gdb_test "python fp2 = fp2.dereference()" ""
     gdb_test "python result2 = fp2(10,20)" ""
     gdb_test "python print (result2)" "30"
 
     # Incorrect to call an int value.
     gdb_test "p i" " = $decimal.*"
-    gdb_py_test_silent_cmd "python i = gdb.history (0)" "get value from history" 1
+    gdb_py_test_silent_cmd "python i = gdb.history (0)" "get value from history" 1
     gdb_test "python result3 = i()" ".*Value is not callable.*"
 
     # Incorrect number of arguments.
-    gdb_test "p/x fp2" " = $hex.*"
-    gdb_py_test_silent_cmd "python fp3 = gdb.history (0)" "get value from history" 1
+    gdb_test "p/x fp2" " = $hex.*" \
+       "print fp2 again to place it into history"
+    gdb_py_test_silent_cmd "python fp3 = gdb.history (0)" "get value fp3 from history" 1
     gdb_test "python fp3 = fp3.dereference()" ""
     gdb_test "python result2 = fp3(10)" ".*Too few arguments in function call.*"
 }
@@ -451,12 +458,13 @@ proc test_subscript_regression {exefile lang} {
  }
 
  gdb_breakpoint [gdb_get_line_number "break to inspect struct and union"]
- gdb_continue_to_breakpoint "break to inspect struct and union"
+ gdb_continue_to_breakpoint \
+     "break to inspect struct and union for subscript regression test"
 
  gdb_py_test_silent_cmd "python intv = gdb.Value(1)" \
-     "Create a value for subscript test" 1
+     "Create value intv for subscript test" 1
  gdb_py_test_silent_cmd "python stringv = gdb.Value(\"foo\")" \
-     "Create a value for subscript test" 1
+     "Create value stringv for subscript test" 1
 
  # Try to access an int with a subscript.  This should fail.
  gdb_test "python print (intv)" "1" "baseline print of an int Python value"
@@ -469,19 +477,19 @@ proc test_subscript_regression {exefile lang} {
 
  # Try to access an int array via a pointer with a subscript.  This should pass.
  gdb_py_test_silent_cmd "print p" "Build pointer to array" 1
- gdb_py_test_silent_cmd "python pointer = gdb.history(0)" "" 1
+ gdb_py_test_silent_cmd "python pointer = gdb.history(0)" "fetch pointer" 0
  gdb_test "python print (pointer\[0\])" "1" "access array via pointer with int subscript"
  gdb_test "python print (pointer\[intv\])" "2" "access array via pointer with value subscript"
 
  # Try to access a single dimension array with a subscript to the
  # result.  This should fail.
  gdb_test "python print (pointer\[intv\]\[0\])" "gdb.error: Cannot subscript requested type.*" \
-     "Attempt to access an integer with a subscript"
+     "Attempt to access a single dimension array with a two subscripts"
 
  # Lastly, test subscript access to an array with multiple
  # dimensions.  This should pass.
  gdb_py_test_silent_cmd "print {\"fu \",\"foo\",\"bar\"}" "Build array" 1
- gdb_py_test_silent_cmd "python marray = gdb.history(0)" "" 1
+ gdb_py_test_silent_cmd "python marray = gdb.history(0)" "fetch marray" 0
  gdb_test "python print (marray\[1\]\[2\])" "o." "test multiple subscript"
 }
 
@@ -505,9 +513,9 @@ proc test_value_hash {} {
     "three = gdb.Value(3)" "" \
     "vdict = {one:\"one str\",two:\"two str\",three:\"three str\"}" "" \
     "end"
-    gdb_test "python print (vdict\[one\])" "one str" "test dictionary hash"
-    gdb_test "python print (vdict\[two\])" "two str" "test dictionary hash"
-    gdb_test "python print (vdict\[three\])" "three str" "test dictionary hash"
+    gdb_test "python print (vdict\[one\])" "one str" "test dictionary hash for one"
+    gdb_test "python print (vdict\[two\])" "two str" "test dictionary hash for two"
+    gdb_test "python print (vdict\[three\])" "three str" "test dictionary hash for three"
     gdb_test "python print (one.__hash__() == hash(one))" "True" "test inbuilt hash"
 }