[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

8–9

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/benchmarks/stepping/TestSteppingSpeed.py

class SteppingSpeedBench(BenchBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
         self.exe = lldbtest_config.lldbExec
         self.break_spec = '-n main'
         self.count = 50
 
-        #print("self.exe=%s" % self.exe)
-        #print("self.break_spec=%s" % self.break_spec)
+        self.trace("self.exe=%s" % self.exe)
+        self.trace("self.break_spec=%s" % self.break_spec)
 
     @benchmarks_test
     @no_debug_info_test
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_lldb_steppings(self):
         """Test lldb steppings on a large executable."""

lldb/test/API/commands/target/basic/TestTargetCommand.py

def do_target_command(self):
             # Find the largest index of the existing list.
             import re
             pattern = re.compile("target #(\d+):")
             for line in reversed(output.split(os.linesep)):
                 match = pattern.search(line)
                 if match:
                     # We will start from (index + 1) ....
                     base = int(match.group(1), 10) + 1
-                    #print("base is:", base)
+                    self.trace("base is:", base)
                     break
 
         self.runCmd("target create " + exe_a, CURRENT_EXECUTABLE_SET)
         self.runCmd("run", RUN_SUCCEEDED)
 
         self.runCmd("target create " + exe_b, CURRENT_EXECUTABLE_SET)
         lldbutil.run_break_set_by_file_and_line(
             self, 'b.c', self.line_b, num_expected_locations=1, loc_exact=True)

lldb/test/API/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py

def breakpoint_conditions_python(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
-        #print("breakpoint:", breakpoint)
+        self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # We didn't associate a thread index with the breakpoint, so it should
         # be invalid.
         self.assertTrue(breakpoint.GetThreadIndex() == lldb.UINT32_MAX,
                         "The thread index should be invalid")
def breakpoint_invalid_conditions_python(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
-        #print("breakpoint:", breakpoint)
+        self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Set the condition on the breakpoint.
         breakpoint.SetCondition('no_such_variable == not_this_one_either')
         self.expect(breakpoint.GetCondition(), exe=False,
                     startstr='no_such_variable == not_this_one_either')

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/functionalities/data-formatter/data-formatter-skip-summary/TestDataFormatterSkipSummary.py

def data_formatter_commands(self):
                 '}'])
 
         # Bad debugging info on SnowLeopard gcc (Apple Inc. build 5666).
         # Skip the following tests if the condition is met.
         if self.getCompiler().endswith('gcc') and not self.getCompiler().endswith('llvm-gcc'):
             import re
             gcc_version_output = system(
                 [[lldbutil.which(self.getCompiler()), "-v"]])[1]
-            #print("my output:", gcc_version_output)
+            self.trace("my output:", gcc_version_output)
             for line in gcc_version_output.split(os.linesep):
                 m = re.search('\(Apple Inc\. build ([0-9]+)\)', line)
-                #print("line:", line)
+                self.trace("line:", line)
                 if m:
                     gcc_build = int(m.group(1))
-                    #print("gcc build:", gcc_build)
+                    self.trace("gcc build:", gcc_build)
                     if gcc_build >= 5666:
                         # rdar://problem/9804600"
                         self.skipTest(
                             "rdar://problem/9804600 wrong namespace for std::string in debug info")
 
         # Expand same expression, skipping 3 layers of summaries
         self.expect(
             'frame variable data1.m_child1->m_child2 --show-types --no-summary-depth=3',

lldb/test/API/functionalities/load_unload/TestLoadUnload.py

def run_lldb_process_load_and_unload_commands(self):
             patterns=[
                 'Loading "%s".*ok' % re.escape(localDylibPath),
                 'Image [0-9]+ loaded'])
 
         # Search for and match the "Image ([0-9]+) loaded" pattern.
         output = self.res.GetOutput()
         pattern = re.compile("Image ([0-9]+) loaded")
         for l in output.split(os.linesep):
-            #print("l:", l)
+            self.trace("l:", l)
             match = pattern.search(l)
             if match:
                 break
         index = match.group(1)
 
         # Now we should have an entry for a_function.
         self.expect(
             "image lookup -n a_function",

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))
-    if var is None or not var.IsValid():
-        # print("{} 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...")
-    if value is None:
-        # print("value is invalid")
-        return False
-    # else:
-        # print("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...")
-    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))
-        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))
-        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))
-        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...")
-    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))
-        return False
-    else:
-        # print("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))
 
 
 class RegisterVariableTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
def test_and_run_command(self):
 
         # The breakpoint should have a hit count of 1.
         self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
                     substrs=[' resolved, hit count = 1'])
 
         # Try some variables that should be visible
         frame = self.dbg.GetSelectedTarget().GetProcess(
         ).GetSelectedThread().GetSelectedFrame()
-        if is_variable_in_register(frame, 'a'):
+        if self.is_variable_in_register(frame, 'a'):
             register_variables_count += 1
             self.expect("expr a", VARIABLES_DISPLAYED_CORRECTLY,
                         patterns=[re_expr_equals('int', 2)])
 
-        if is_struct_pointer_in_register(frame, 'b', self.TraceOn()):
+        if self.is_struct_pointer_in_register(frame, 'b', self.TraceOn()):
             register_variables_count += 1
             self.expect("expr b->m1", VARIABLES_DISPLAYED_CORRECTLY,
                         patterns=[re_expr_equals('int', 3)])
 
         #####################
         # Second breakpoint
 
         self.runCmd("continue")
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
         self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
                     substrs=[' resolved, hit count = 1'])
 
         # Try some variables that should be visible
         frame = self.dbg.GetSelectedTarget().GetProcess(
         ).GetSelectedThread().GetSelectedFrame()
-        if is_struct_pointer_in_register(frame, 'b', self.TraceOn()):
+        if self.is_struct_pointer_in_register(frame, 'b', self.TraceOn()):
             register_variables_count += 1
             self.expect("expr b->m2", VARIABLES_DISPLAYED_CORRECTLY,
                         patterns=[re_expr_equals('int', 5)])
 
-        if is_variable_in_register(frame, 'c'):
+        if self.is_variable_in_register(frame, 'c'):
             register_variables_count += 1
             self.expect("expr c", VARIABLES_DISPLAYED_CORRECTLY,
                         patterns=[re_expr_equals('int', 5)])
 
         #####################
         # Third breakpoint
 
         self.runCmd("continue")
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
         self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
                     substrs=[' resolved, hit count = 1'])
 
         # Try some variables that should be visible
         frame = self.dbg.GetSelectedTarget().GetProcess(
         ).GetSelectedThread().GetSelectedFrame()
-        if is_variable_in_register(frame, 'f'):
+        if self.is_variable_in_register(frame, 'f'):
             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")
+
+
+    def is_variable_in_register(self, frame, var_name):
+        # Ensure we can lookup the variable.
+        var = frame.FindVariable(var_name)
+        self.trace("\nchecking {}...".format(var_name))
+        if var is None or not var.IsValid():
+            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()
+        self.trace("checking value...")
+        if value is None:
+            self.trace("value is invalid")
+            return False
+        else:
+            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()
+        self.trace("checking address...")
+        if var_addr.IsValid():
+            # We have an address, it must not be in a register.
+            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.
+            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(self, 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():
+            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()
+        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.
+            self.trace("frame var {} is not in a register".format(var_name))
+            return False
+        else:
+            self.trace("frame var {} is in a register".format(var_name))
+            return True
+

lldb/test/API/lang/cpp/class_types/TestClassTypesDisassembly.py

def test_and_run_command(self):
                               0x[0-9a-f]{16}    # the frame pc, and
                               \sa.out`(.+)      # module`function, and
                               \s\+\s            # the rest ' + ....'
                               """, re.VERBOSE)
         for line in raw_output.split(os.linesep):
             match = frameRE.search(line)
             if match:
                 function = match.group(1)
-                #print("line:", line)
-                #print("function:", function)
+                self.trace("line:", line)
+                self.trace("function:", function)
                 self.runCmd("disassemble -n '%s'" % function)
 
     @add_test_categories(['pyapi'])
     def test_and_python_api(self):
         """Disassemble each call frame when stopped on C's constructor."""
         self.build()
         self.breakOnCtor()
 

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/lang/objc/foundation/TestSymbolTable.py

def test_with_python_api(self):
         #
 
         # Create the filespec by which to locate our a.out module.
         filespec = lldb.SBFileSpec(exe, False)
 
         module = target.FindModule(filespec)
         self.assertTrue(module, VALID_MODULE)
 
-        # Create the set of known symbols.  As we iterate through the symbol
-        # table, remove the symbol from the set if it is a known symbol.
-        expected_symbols = set(self.symbols_list)
-        for symbol in module:
-            self.assertTrue(symbol, VALID_SYMBOL)
-            #print("symbol:", symbol)
-            name = symbol.GetName()
-            if name in expected_symbols:
-                #print("Removing %s from known_symbols %s" % (name, expected_symbols))
-                expected_symbols.remove(name)
-
-        # At this point, the known_symbols set should have become an empty set.
-        # If not, raise an error.
-        #print("symbols unaccounted for:", expected_symbols)
-        self.assertTrue(len(expected_symbols) == 0,
-                        "All the known symbols are accounted for")

lldb/test/API/python_api/breakpoint/TestBreakpointAPI.py

def test_breakpoint_is_valid(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'AFunction'.
         breakpoint = target.BreakpointCreateByName('AFunction', 'a.out')
-        #print("breakpoint:", breakpoint)
+        self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Now delete it:
         did_delete = target.BreakpointDelete(breakpoint.GetID())
         self.assertTrue(
             did_delete,
def test_target_delete(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'AFunction'.
         breakpoint = target.BreakpointCreateByName('AFunction', 'a.out')
-        #print("breakpoint:", breakpoint)
+        self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
         location = breakpoint.GetLocationAtIndex(0)
         self.assertTrue(location.IsValid())
 
         self.assertTrue(self.dbg.DeleteTarget(target))
         self.assertFalse(breakpoint.IsValid())
         self.assertFalse(location.IsValid())

lldb/test/API/python_api/event/TestEvents.py

def test_wait_for_event(self):
         self.dbg.SetAsync(True)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
-        #print("breakpoint:", breakpoint)
+        self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Get the debugger listener.
         listener = self.dbg.GetListener()
 
         # Now launch the process, and do not stop at entry point.
def test_wait_for_event(self):
 
         class MyListeningThread(threading.Thread):
 
             def run(self):
                 count = 0
                 # Let's only try at most 3 times to retrieve any kind of event.
                 while not count > 3:
                     if listener.WaitForEvent(5, event):
-                        #print("Got a valid event:", event)
-                        #print("Event data flavor:", event.GetDataFlavor())
-                        #print("Event type:", lldbutil.state_type_to_str(event.GetType()))
+                        self.trace("Got a valid event:", event)
+                        self.trace("Event data flavor:", event.GetDataFlavor())
+                        self.trace("Event type:", lldbutil.state_type_to_str(event.GetType()))
                         listener.Clear()
                         return
                     count = count + 1
                     print("Timeout: listener.WaitForEvent")
                 listener.Clear()
                 return
 
         # Use Python API to kill the process.  The listening thread should be
def test_add_listener_to_broadcaster(self):
         self.dbg.SetAsync(True)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
-        #print("breakpoint:", breakpoint)
+        self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         listener = lldb.SBListener("my listener")
 
         # Now launch the process, and do not stop at the entry point.
         error = lldb.SBError()
def test_add_listener_to_broadcaster(self):
         # Create MyListeningThread to wait for state changed events.
         # By design, a "running" event is expected following by a "stopped"
         # event.
         import threading
 
         class MyListeningThread(threading.Thread):
 
             def run(self):
-                #print("Running MyListeningThread:", self)
+                self.trace("Running MyListeningThread:", self)
 
                 # Regular expression pattern for the event description.
                 pattern = re.compile("data = {.*, state = (.*)}$")
 
                 # Let's only try at most 6 times to retrieve our events.
                 count = 0
                 while True:
                     if listener.WaitForEvent(5, event):
                         desc = lldbutil.get_description(event)
-                        #print("Event description:", desc)
+                        self.trace("Event description:", desc)
                         match = pattern.search(desc)
                         if not match:
                             break
                         if match.group(1) == 'connected':
                             # When debugging remote targets with lldb-server, we
                             # first get the 'connected' event.
                             self.context.assertTrue(self.context.state is None)
                             self.context.state = 'connected'

lldb/test/API/python_api/frame/TestFrames.py

def test_get_arg_vals_for_call_stack(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
-        #print("breakpoint:", breakpoint)
+        self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
def test_frame_api_boundary_condition(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
-        #print("breakpoint:", breakpoint)
+        self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
def test_frame_api_IsEqual(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
-        #print("breakpoint:", breakpoint)
+        self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 

lldb/test/API/python_api/frame/inlines/TestInlinedFrame.py

def test_stop_at_outer_inline(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by the name of 'inner_inline'.
         breakpoint = target.BreakpointCreateByName('inner_inline', 'a.out')
-        #print("breakpoint:", breakpoint)
+        self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() > 1,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 

lldb/test/API/python_api/function_symbol/TestDisasmAPI.py

def test(self):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create the two breakpoints inside function 'a'.
         breakpoint1 = target.BreakpointCreateByLocation('main.c', self.line1)
         breakpoint2 = target.BreakpointCreateByLocation('main.c', self.line2)
-        #print("breakpoint1:", breakpoint1)
-        #print("breakpoint2:", breakpoint2)
+        self.trace("breakpoint1:", breakpoint1)
+        self.trace("breakpoint2:", breakpoint2)
         self.assertTrue(breakpoint1 and
                         breakpoint1.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
         self.assertTrue(breakpoint2 and
                         breakpoint2.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # Frame #0 should be on self.line1.
         self.assertTrue(process.GetState() == lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
         frame0 = thread.GetFrameAtIndex(0)
         lineEntry = frame0.GetLineEntry()
         self.assertTrue(lineEntry.GetLine() == self.line1)
 
         address1 = lineEntry.GetStartAddress()
-        #print("address1:", address1)
+        self.trace("address1:", address1)
 
         # Now call SBTarget.ResolveSymbolContextForAddress() with address1.
         context1 = target.ResolveSymbolContextForAddress(
             address1, lldb.eSymbolContextEverything)
 
         self.assertTrue(context1)
         if self.TraceOn():
             print("context1:", context1)
def test(self):
             print("disassembly=>\n", disasm_output)
 
         disasm_output = lldbutil.disassemble(target, function)
         if self.TraceOn():
             print("function:", function)
             print("disassembly=>\n", disasm_output)
 
         sa1 = symbol.GetStartAddress()
-        #print("sa1:", sa1)
-        #print("sa1.GetFileAddress():", hex(sa1.GetFileAddress()))
-        #ea1 = symbol.GetEndAddress()
-        #print("ea1:", ea1)
+        self.trace("sa1:", sa1)
+        self.trace("sa1.GetFileAddress():", hex(sa1.GetFileAddress()))
         sa2 = function.GetStartAddress()
-        #print("sa2:", sa2)
-        #print("sa2.GetFileAddress():", hex(sa2.GetFileAddress()))
-        #ea2 = function.GetEndAddress()
-        #print("ea2:", ea2)
+        self.trace("sa2:", sa2)
+        self.trace("sa2.GetFileAddress():", hex(sa2.GetFileAddress()))
         self.assertTrue(sa1 and sa2 and sa1 == sa2,
                         "The two starting addresses should be the same")
 
         from lldbsuite.test.lldbutil import get_description
         desc1 = get_description(sa1)
         desc2 = get_description(sa2)
         self.assertTrue(
             desc1 and desc2 and desc1 == desc2,
             "SBAddress.GetDescription() API of sa1 and sa2 should return the same string")

lldb/test/API/python_api/function_symbol/TestSymbolAPI.py

def test(self):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create the two breakpoints inside function 'a'.
         breakpoint1 = target.BreakpointCreateByLocation('main.c', self.line1)
         breakpoint2 = target.BreakpointCreateByLocation('main.c', self.line2)
-        #print("breakpoint1:", breakpoint1)
-        #print("breakpoint2:", breakpoint2)
+        self.trace("breakpoint1:", breakpoint1)
+        self.trace("breakpoint2:", breakpoint2)
         self.assertTrue(breakpoint1 and
                         breakpoint1.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
         self.assertTrue(breakpoint2 and
                         breakpoint2.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.

lldb/test/API/python_api/target/TestTargetAPI.py

def resolve_symbol_context_with_address(self):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create the two breakpoints inside function 'a'.
         breakpoint1 = target.BreakpointCreateByLocation('main.c', self.line1)
         breakpoint2 = target.BreakpointCreateByLocation('main.c', self.line2)
-        #print("breakpoint1:", breakpoint1)
-        #print("breakpoint2:", breakpoint2)
+        self.trace("breakpoint1:", breakpoint1)
+        self.trace("breakpoint2:", breakpoint2)
         self.assertTrue(breakpoint1 and
                         breakpoint1.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
         self.assertTrue(breakpoint2 and
                         breakpoint2.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
def resolve_symbol_context_with_address(self):
             "There should be a thread stopped due to breakpoint condition")
         #self.runCmd("process status")
         frame0 = thread.GetFrameAtIndex(0)
         lineEntry = frame0.GetLineEntry()
         self.assertTrue(lineEntry.GetLine() == self.line2)
 
         address2 = lineEntry.GetStartAddress()
 
-        #print("address1:", address1)
-        #print("address2:", address2)
+        self.trace("address1:", address1)
+        self.trace("address2:", address2)
 
         # Now call SBTarget.ResolveSymbolContextForAddress() with the addresses
         # from our line entry.
         context1 = target.ResolveSymbolContextForAddress(
             address1, lldb.eSymbolContextEverything)
         context2 = target.ResolveSymbolContextForAddress(
             address2, lldb.eSymbolContextEverything)
 
         self.assertTrue(context1 and context2)
-        #print("context1:", context1)
-        #print("context2:", context2)
+        self.trace("context1:", context1)
+        self.trace("context2:", context2)
 
         # Verify that the context point to the same function 'a'.
         symbol1 = context1.GetSymbol()
         symbol2 = context2.GetSymbol()
         self.assertTrue(symbol1 and symbol2)
-        #print("symbol1:", symbol1)
-        #print("symbol2:", symbol2)
+        self.trace("symbol1:", symbol1)
+        self.trace("symbol2:", symbol2)
 
         from lldbsuite.test.lldbutil import get_description
         desc1 = get_description(symbol1)
         desc2 = get_description(symbol2)
         self.assertTrue(desc1 and desc2 and desc1 == desc2,
                         "The two addresses should resolve to the same symbol")

lldb/test/API/python_api/thread/TestThreadAPI.py

def get_process(self):
 
         thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint")
         self.runCmd("process status")
 
         proc_of_thread = thread.GetProcess()
-        #print("proc_of_thread:", proc_of_thread)
+        self.trace("proc_of_thread:", proc_of_thread)
         self.assertTrue(proc_of_thread.GetProcessID()
                         == process.GetProcessID())
 
     def get_stop_description(self):
         """Test Python SBThread.GetStopDescription() API."""
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)

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):