[lldb/Test] Add a trace method to replace (commented out) print statements.

[JDevlieghere]

Summary

While debugging replay failures I noticed that a lot of tests have print statements, sometimes commented out, which half of the time don't show up in the terminal anyway because dotest swallows the output.

We already have a good mechanism for these kind of things: the -t flag to enable tracing. I've added a trace method to replace these print statements. In this patch I've only updated the ones that are commented out, but I feel all the print statements in the API tests should be replaced by this.

[JDevlieghere]

lldb/packages/Python/lldbsuite/test/lldbtest.py

510

This should be

print(*args, kwargs, file=sbuf)

[labath]

Yes, this is a good idea. It might it also nice to go through the if self.traceOn() calls and see which ones can be replaced by this function.

lldb/packages/Python/lldbsuite/test/lldbtest.py

510

Actually, it should be print(*args, **kwargs, file=sbuf)

lldb/test/API/lang/c/register_variables/TestRegisterVariables.py

32

uncomment this as well

[mboehme]

lldb/packages/Python/lldbsuite/test/lldbtest.py

510

With both Python 2 and 3, this, is giving me an error:

    print(*args, **kwargs, file=sbuf)
                         ^
SyntaxError: invalid syntax

I believe this should be print(*args, file=sbuf, **kwargs). Can you fix this?

[JDevlieghere]

lldb/packages/Python/lldbsuite/test/lldbtest.py

510

Thanks, fixed by 5fa9c9d7f276b44b3da949382e0d0b5dbfd0ac8b

[aprantl]

nice!

[mboehme]

Thank you!

lldb/packages/Python/lldbsuite/test/lldbtest.py

def compute_mydir(test_file):
         # /abs/path/to/packages/group/subdir/mytest.py -> group/subdir
         rel_prefix = test_file[len(os.environ["LLDB_TEST_SRC"]) + 1:]
         return os.path.dirname(rel_prefix)
 
     def TraceOn(self):
         """Returns True if we are in trace mode (tracing detailed test execution)."""
         return traceAlways
 
+    def trace(self, *args,**kwargs):
+        with recording(self, self.TraceOn()) as sbuf:
+            print(args, kwargs, file=sbuf)
+
     @classmethod
     def setUpClass(cls):
         """
         Python unittest framework class setup fixture.
         Do current directory manipulation.
         """
         # Fail fast if 'mydir' attribute is not overridden.
         if not cls.mydir or len(cls.mydir) == 0:

lldb/test/API/functionalities/breakpoint/serialize/TestBreakpointSerialization.py

def check_equivalence(self, source_bps, do_write = True):
             copy_bp = copy_bps.FindBreakpointByID(copy_id)
             self.assertTrue(copy_bp.IsValid(), "Could not find copy breakpoint %d."%(copy_id))
 
             copy_desc = lldb.SBStream()
             copy_bp.GetDescription(copy_desc, False)
             copy_text = copy_desc.GetData()
 
             # These two should be identical.
-            # print ("Source text for %d is %s."%(i, source_text))
+            self.trace("Source text for %d is %s."%(i, source_text))
             self.assertTrue (source_text == copy_text, "Source and dest breakpoints are not identical: \nsource: %s\ndest: %s"%(source_text, copy_text))
 
     def do_check_resolvers(self):
         """Use Python APIs to check serialization of breakpoint resolvers"""
 
         empty_module_list = lldb.SBFileSpecList()
         empty_cu_list = lldb.SBFileSpecList()
         blubby_file_spec = lldb.SBFileSpec(os.path.join(self.getSourceDir(), "blubby.c"))

lldb/test/API/lang/c/register_variables/TestRegisterVariables.py

 """Check that compiler-generated register values work correctly"""
 
-from __future__ import print_function
-
 import re
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 # This method attempts to figure out if a given variable
 # is in a register.
 #
 # Return:
 #   True if the value has a readable value and is in a register
 #   False otherwise
 
 
 def is_variable_in_register(frame, var_name):
     # Ensure we can lookup the variable.
     var = frame.FindVariable(var_name)
-    # print("\nchecking {}...".format(var_name))
+    self.trace("\nchecking {}...".format(var_name))
     if var is None or not var.IsValid():
-        # print("{} cannot be found".format(var_name))
+        self.trace("{} cannot be found".format(var_name))
         return False
 
     # Check that we can get its value.  If not, this
     # may be a variable that is just out of scope at this point.
     value = var.GetValue()
-    # print("checking value...")
+    self.trace("checking value...")
     if value is None:
-        # print("value is invalid")
+        self.trace("value is invalid")
         return False
     # else:
-        # print("value is {}".format(value))
+        self.trace("value is {}".format(value))
 
     # We have a variable and we can get its value.  The variable is in
     # a register if we cannot get an address for it, assuming it is
     # not a struct pointer.  (This is an approximation - compilers can
     # do other things with spitting up a value into multiple parts of
     # multiple registers, but what we're verifying here is much more
     # than it was doing before).
     var_addr = var.GetAddress()
-    # print("checking address...")
+    self.trace("checking address...")
     if var_addr.IsValid():
         # We have an address, it must not be in a register.
-        # print("var {} is not in a register: has a valid address {}".format(var_name, var_addr))
+        self.trace("var {} is not in a register: has a valid address {}".format(var_name, var_addr))
         return False
     else:
         # We don't have an address but we can read the value.
         # It is likely stored in a register.
-        # print("var {} is in a register (we don't have an address for it)".format(var_name))
+        self.trace("var {} is in a register (we don't have an address for it)".format(var_name))
         return True
 
 
 def is_struct_pointer_in_register(frame, var_name, trace):
     # Ensure we can lookup the variable.
     var = frame.FindVariable(var_name)
     if trace:
         print("\nchecking {}...".format(var_name))
 
     if var is None or not var.IsValid():
-        # print("{} cannot be found".format(var_name))
+        self.trace("{} cannot be found".format(var_name))
         return False
 
     # Check that we can get its value.  If not, this
     # may be a variable that is just out of scope at this point.
     value = var.GetValue()
-    # print("checking value...")
+    self.trace("checking value...")
     if value is None:
         if trace:
             print("value is invalid")
         return False
     else:
         if trace:
              print("value is {}".format(value))
 
     var_loc = var.GetLocation()
     if trace:
         print("checking location: {}".format(var_loc))
     if var_loc is None or var_loc.startswith("0x"):
         # The frame var is not in a register but rather a memory location.
-        # print("frame var {} is not in a register".format(var_name))
+        self.trace("frame var {} is not in a register".format(var_name))
         return False
     else:
-        # print("frame var {} is in a register".format(var_name))
+        self.trace("frame var {} is in a register".format(var_name))
         return True
 
 
 def re_expr_equals(val_type, val):
     # Match ({val_type}) ${sum_digits} = {val}
     return re.compile(r'\(' + val_type + '\) \$\d+ = ' + str(val))
 
 
def test_and_run_command(self):
             register_variables_count += 1
             self.expect("expr f", VARIABLES_DISPLAYED_CORRECTLY,
                         patterns=[re_expr_equals('float', '3.1')])
 
         # Validate that we verified at least one register variable
         self.assertTrue(
             register_variables_count > 0,
             "expected to verify at least one variable in a register")
-        # print("executed {} expressions with values in registers".format(register_variables_count))
+        self.trace("executed {} expressions with values in registers".format(register_variables_count))
 
         self.runCmd("kill")

lldb/test/API/lang/objc/blocks/TestObjCIvarsInBlocks.py

def test_with_python_api(self):
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame, "frame 0 is valid")
 
         expr = frame.EvaluateExpression("(ret)")
         self.assertTrue(
             expr, "Successfully got a local variable in a block in a class method.")
 
         ret_value_signed = expr.GetValueAsSigned(error)
-        # print('ret_value_signed = %i' % (ret_value_signed))
+        self.trace('ret_value_signed = %i' % (ret_value_signed))
         self.assertTrue(
             ret_value_signed == 5,
             "The local variable in the block was what we expected.")

lldb/test/API/tools/lldb-server/TestGdbRemoteAuxvSupport.py

-from __future__ import print_function
-
-
 import gdbremote_testcase
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestGdbRemoteAuxvSupport(gdbremote_testcase.GdbRemoteTestCaseBase):
 
class TestGdbRemoteAuxvSupport(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     def auxv_data_is_correct_size(self):
         (word_size, auxv_data) = self.get_raw_auxv_data()
         self.assertIsNotNone(auxv_data)
 
         # Ensure auxv data is a multiple of 2*word_size (there should be two
         # unsigned long fields per auxv entry).
         self.assertEqual(len(auxv_data) % (2 * word_size), 0)
-        # print("auxv contains {} entries".format(len(auxv_data) / (2*word_size)))
+        self.trace("auxv contains {} entries".format(len(auxv_data) / (2*word_size)))
 
     @debugserver_test
     def test_auxv_data_is_correct_size_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_data_is_correct_size()
 
def auxv_keys_look_valid(self):
 
         auxv_dict = self.build_auxv_dict(endian, word_size, auxv_data)
         self.assertIsNotNone(auxv_dict)
 
         # Verify keys look reasonable.
         for auxv_key in auxv_dict:
             self.assertTrue(auxv_key >= 1)
             self.assertTrue(auxv_key <= 1000)
-        # print("auxv dict: {}".format(auxv_dict))
+        self.trace("auxv dict: {}".format(auxv_dict))
 
     @debugserver_test
     def test_auxv_keys_look_valid_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_keys_look_valid()
 

lldb/test/API/tools/lldb-server/TestGdbRemoteExpeditedRegisters.py

-from __future__ import print_function
-
-
 import gdbremote_testcase
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestGdbRemoteExpeditedRegisters(
         gdbremote_testcase.GdbRemoteTestCaseBase):
def stop_notification_contains_generic_register(
 
         # Find the generic register.
         reg_info = self.find_generic_register_with_name(
             reg_infos, generic_register_name)
         self.assertIsNotNone(reg_info)
 
         # Ensure the expedited registers contained it.
         self.assertTrue(reg_info["lldb_register_index"] in expedited_registers)
-        # print("{} reg_info:{}".format(generic_register_name, reg_info))
+        self.trace("{} reg_info:{}".format(generic_register_name, reg_info))
 
     def stop_notification_contains_any_registers(self):
         # Generate a stop reply, parse out expedited registers from stop
         # notification.
         expedited_registers = self.gather_expedited_registers()
         # Verify we have at least one expedited register.
         self.assertTrue(len(expedited_registers) > 0)
 

lldb/test/API/tools/lldb-server/TestGdbRemoteRegisterState.py

-from __future__ import print_function
-
-
 import gdbremote_testcase
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestGdbRemoteRegisterState(gdbremote_testcase.GdbRemoteTestCaseBase):
     """Test QSaveRegisterState/QRestoreRegisterState support."""
def grp_register_save_restore_works(self, with_suffix):
         self.assertTrue(len(gpr_reg_infos) > 0)
 
         # Gather thread info.
         if with_suffix:
             threads = self.parse_threadinfo_packets(context)
             self.assertIsNotNone(threads)
             thread_id = threads[0]
             self.assertIsNotNone(thread_id)
-            # print("Running on thread: 0x{:x}".format(thread_id))
+            self.trace("Running on thread: 0x{:x}".format(thread_id))
         else:
             thread_id = None
 
         # Save register state.
         self.reset_test_sequence()
         self.add_QSaveRegisterState_packets(thread_id)
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         (success, state_id) = self.parse_QSaveRegisterState_response(context)
         self.assertTrue(success)
         self.assertIsNotNone(state_id)
-        # print("saved register state id: {}".format(state_id))
+        self.trace("saved register state id: {}".format(state_id))
 
         # Remember initial register values.
         initial_reg_values = self.read_register_values(
             gpr_reg_infos, endian, thread_id=thread_id)
-        # print("initial_reg_values: {}".format(initial_reg_values))
+        self.trace("initial_reg_values: {}".format(initial_reg_values))
 
         # Flip gpr register values.
         (successful_writes, failed_writes) = self.flip_all_bits_in_each_register_value(
             gpr_reg_infos, endian, thread_id=thread_id)
-        # print("successful writes: {}, failed writes: {}".format(successful_writes, failed_writes))
+        self.trace("successful writes: {}, failed writes: {}".format(successful_writes, failed_writes))
         self.assertTrue(successful_writes > 0)
 
         flipped_reg_values = self.read_register_values(
             gpr_reg_infos, endian, thread_id=thread_id)
-        # print("flipped_reg_values: {}".format(flipped_reg_values))
+        self.trace("flipped_reg_values: {}".format(flipped_reg_values))
 
         # Restore register values.
         self.reset_test_sequence()
         self.add_QRestoreRegisterState_packets(state_id, thread_id)
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Verify registers match initial register values.
         final_reg_values = self.read_register_values(
             gpr_reg_infos, endian, thread_id=thread_id)
-        # print("final_reg_values: {}".format(final_reg_values))
+        self.trace("final_reg_values: {}".format(final_reg_values))
         self.assertIsNotNone(final_reg_values)
         self.assertEqual(final_reg_values, initial_reg_values)
 
     @debugserver_test
     def test_grp_register_save_restore_works_with_suffix_debugserver(self):
         USE_THREAD_SUFFIX = True
         self.init_debugserver_test()
         self.build()

lldb/test/API/tools/lldb-server/TestLldbGdbServer.py

 """
 Test case for testing the gdbremote protocol.
 
 Tests run against debugserver and lldb-server (llgs).
 lldb-server tests run where the lldb-server exe is
 available.
 
 This class will be broken into smaller test case classes by
 gdb remote packet functional areas.  For now it contains
 the initial set of tests implemented.
 """
 
-from __future__ import division, print_function
-
-
 import unittest2
 import gdbremote_testcase
 import lldbgdbserverutils
 from lldbsuite.support import seven
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.lldbdwarf import *
 from lldbsuite.test import lldbutil
def P_writes_all_gpr_registers(self):
         # successfully,.
         gpr_reg_infos = [
             reg_info for reg_info in reg_infos if self.is_bit_flippable_register(reg_info)]
         self.assertTrue(len(gpr_reg_infos) > 0)
 
         # Write flipped bit pattern of existing value to each register.
         (successful_writes, failed_writes) = self.flip_all_bits_in_each_register_value(
             gpr_reg_infos, endian)
-        # print("successful writes: {}, failed writes: {}".format(successful_writes, failed_writes))
+        self.trace("successful writes: {}, failed writes: {}".format(successful_writes, failed_writes))
         self.assertTrue(successful_writes > 0)
 
     # Note: as of this moment, a hefty number of the GPR writes are failing with E32 (everything except rax-rdx, rdi, rsi, rbp).
     # Come back to this.  I have the test rigged to verify that at least some
     # of the bit-flip writes work.
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_P_writes_all_gpr_registers_debugserver(self):