[lldb] Remove Python 2 checks from the test suite

[JDevlieghere]

Summary

Remove Python 2 checks from the test suite

[clayborg]

Are we removing Python2 support?

[JDevlieghere]

In D124430#3475136, @clayborg wrote:

Are we removing Python2 support?

Yep, AFAIK we were the only ones that still needed it. We dropped support downstream in the previous release and we just rebranched for the next one, so I'm no longer worried about merge conflicts for cherrypicks.

[JDevlieghere]

0e9af88b7099

lldb/test/API/functionalities/step_scripted/TestStepScripted.py

class StepScriptedTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         TestBase.setUp(self)
         self.main_source_file = lldb.SBFileSpec("main.c")
         self.runCmd("command script import Steps.py")
 
     def test_standard_step_out(self):
-        """Tests stepping with the scripted thread plan laying over a standard 
+        """Tests stepping with the scripted thread plan laying over a standard
         thread plan for stepping out."""
         self.build()
         self.step_out_with_scripted_plan("Steps.StepOut")
 
     def test_scripted_step_out(self):
-        """Tests stepping with the scripted thread plan laying over an another 
+        """Tests stepping with the scripted thread plan laying over an another
         scripted thread plan for stepping out."""
         self.build()
         self.step_out_with_scripted_plan("Steps.StepScripted")
 
     def step_out_with_scripted_plan(self, name):
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                                                             "Set a breakpoint here",
                                                                             self.main_source_file)
def test_misspelled_plan_name(self):
         """Test that we get a useful error if we misspell the plan class name"""
         self.build()
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                                                             "Set a breakpoint here",
                                                                             self.main_source_file)
         stop_id = process.GetStopID()
         # Pass a non-existent class for the plan class:
         err = thread.StepUsingScriptedThreadPlan("NoSuchModule.NoSuchPlan")
-        
         # Make sure we got a good error:
         self.assertTrue(err.Fail(), "We got a failure state")
         msg = err.GetCString()
         self.assertIn("NoSuchModule.NoSuchPlan", msg, "Mentioned missing class")
-        
         # Make sure we didn't let the process run:
         self.assertEqual(stop_id, process.GetStopID(), "Process didn't run")
-        
     def test_checking_variable(self):
         """Test that we can call SBValue API's from a scripted thread plan - using SBAPI's to step"""
         self.do_test_checking_variable(False)
-        
     def test_checking_variable_cli(self):
         """Test that we can call SBValue API's from a scripted thread plan - using cli to step"""
         self.do_test_checking_variable(True)
-        
     def do_test_checking_variable(self, use_cli):
         self.build()
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                                                             "Set a breakpoint here",
                                                                             self.main_source_file)
 
         frame = thread.GetFrameAtIndex(0)
         self.assertEqual("foo", frame.GetFunctionName())
def do_test_checking_variable(self, use_cli):
             error = args_data.SetFromJSON(data)
             self.assertSuccess(error, "Made the args_data correctly")
 
             err = thread.StepUsingScriptedThreadPlan("Steps.StepUntil", args_data, True)
             self.assertSuccess(err)
 
         # We should not have exited:
         self.assertEqual(process.GetState(), lldb.eStateStopped, "We are stopped")
-        
         # We should still be in foo:
         self.assertEqual("foo", frame.GetFunctionName())
 
         # And foo should have changed:
         self.assertTrue(foo_val.GetValueDidChange(), "Foo changed")
 
     def test_stop_others_from_command(self):
         """Test that the stop-others flag is set correctly by the command line.
def run_step(self, stop_others_value, run_mode, token):
         if run_mode != None:
             cmd = cmd + " --run-mode %s"%(run_mode)
         print(cmd)
         interp.HandleCommand(cmd, result)
         self.assertTrue(result.Succeeded(), "Step scripted failed: %s."%(result.GetError()))
         print(Steps.StepReportsStopOthers.stop_mode_dict)
         value = Steps.StepReportsStopOthers.stop_mode_dict[token]
         self.assertEqual(value, stop_others_value, "Stop others has the correct value.")
-        
     def do_test_stop_others(self):
         self.build()
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                                                             "Set a breakpoint here",
                                                                             self.main_source_file)
         # First run with stop others false and see that we got that.
-        thread_id = ""
-        if sys.version_info.major == 2:
-            thread_id = str(threading._get_ident())
-        else:
-            thread_id = str(threading.get_ident())
 
         # all-threads should set stop others to False.
         self.run_step(False, "all-threads", thread_id)
 
         # this-thread should set stop others to True
         self.run_step(True, "this-thread", thread_id)
 
         # The default value should be stop others:
         self.run_step(True, None, thread_id)
 
         # The target.process.run-all-threads should override this:
         interp = self.dbg.GetCommandInterpreter()
         result = lldb.SBCommandReturnObject()
-        
         interp.HandleCommand("settings set target.process.run-all-threads true", result)
         self.assertTrue(result.Succeeded, "setting run-all-threads works.")
 
         self.run_step(False, None, thread_id)
-
-        
-        
-
-        

lldb/test/API/lldbtest.py

def execute(self, test, litConfig):
                 timeout=litConfig.maxIndividualTestTime)
         except lit.util.ExecuteCommandTimeoutException as e:
             out = e.out
             err = e.err
             exitCode = e.exitCode
             timeoutInfo = 'Reached timeout of {} seconds'.format(
                 litConfig.maxIndividualTestTime)
 
-        if sys.version_info.major == 2:
-            # In Python 2, string objects can contain Unicode characters. Use
-            # the non-strict 'replace' decoding mode. We cannot use the strict
-            # mode right now because lldb's StringPrinter facility and the
-            # Python utf8 decoder have different interpretations of which
-            # characters are "printable". This leads to Python utf8 decoding
-            # exceptions even though lldb is behaving as expected.
-            out = out.decode('utf-8', 'replace')
-            err = err.decode('utf-8', 'replace')
-
         output = """Script:\n--\n%s\n--\nExit Code: %d\n""" % (
             ' '.join(cmd), exitCode)
         if timeoutInfo is not None:
             output += """Timeout: %s\n""" % (timeoutInfo,)
         output += "\n"
 
         if out:
             output += """Command Output (stdout):\n--\n%s\n--\n""" % (out,)

lldb/test/API/macosx/nslog/TestDarwinNSLogOutput.py

 """
 Test DarwinLog "source include debug-level" functionality provided by the
 StructuredDataDarwinLog plugin.
 
 These tests are currently only supported when running against Darwin
 targets.
 """
 
 
 import lldb
 import platform
 import re
+import sys
 
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbtest_config
 
 
 class DarwinNSLogOutputTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
class DarwinNSLogOutputTestCase(TestBase):
 
     def run_lldb_to_breakpoint(self, exe, source_file, line,
                                settings_commands=None):
         # Set self.child_prompt, which is "(lldb) ".
         prompt = self.child_prompt
 
         # So that the child gets torn down after the test.
         import pexpect
-        import sys
-        if sys.version_info.major == 3:
-          self.child = pexpect.spawnu('%s %s %s' % (lldbtest_config.lldbExec,
-                                                    self.lldbOption, exe))
-        else:
-          self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec,
-                                                   self.lldbOption, exe))
         child = self.child
 
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout
 
         # Disable showing of source lines at our breakpoint.
         # This is necessary for the logging tests, because the very

lldb/test/API/python_api/disassemble-raw-data/TestDisassemble_VST1_64.py

def test_disassemble_invalid_vst_1_64_raw_data(self):
 
         insts = target.GetInstructions(lldb.SBAddress(), raw_bytes)
 
         if self.TraceOn():
             print()
             for i in insts:
                 print("Disassembled %s" % str(i))
 
-        if sys.version_info.major >= 3:
-            sio = StringIO()
-            insts.Print(sio)
-            self.assertEqual(split(assembly), split(sio.getvalue()))
 
         self.assertEqual(insts.GetSize(), len(split(assembly)))
 
-        if sys.version_info.major >= 3:
-            for i,asm in enumerate(split(assembly)):
-                inst = insts.GetInstructionAtIndex(i)
-                sio = StringIO()
-                inst.Print(sio)
-                self.assertEqual(asm, sio.getvalue().strip())
 
         raw_bytes = bytearray([0x04, 0xf9, 0xed, 0x82])
 
         insts = target.GetInstructions(lldb.SBAddress(), raw_bytes)
 
         inst = insts.GetInstructionAtIndex(0)
 
         if self.TraceOn():
             print()
             print("Raw bytes:    ", [hex(x) for x in raw_bytes])
             print("Disassembled%s" % str(inst))
 
         self.assertEqual(inst.GetMnemonic(target), "vst1.64")

lldb/test/API/python_api/file_handle/TestFileHandle.py

def test_immediate(self):
             f.write("\nQUUX\n")
         ret = None # call destructor and flush streams
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertTrue(re.search(r'Show a list of all debugger commands', output))
             self.assertTrue(re.search(r'QUUX', output))
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_immediate_string(self):
         f = io.StringIO()
         ret = lldb.SBCommandReturnObject()
         ret.SetImmediateOutputFile(f)
         interpreter = self.dbg.GetCommandInterpreter()
         interpreter.HandleCommand("help help", ret)
         # make sure the file wasn't closed early.
         f.write("\nQUUX\n")
         ret = None # call destructor and flush streams
         output = f.getvalue()
         self.assertTrue(re.search(r'Show a list of all debugger commands', output))
         self.assertTrue(re.search(r'QUUX', output))
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_immediate_sbfile_string(self):
         f = io.StringIO()
         ret = lldb.SBCommandReturnObject()
         ret.SetImmediateOutputFile(lldb.SBFile(f))
         interpreter = self.dbg.GetCommandInterpreter()
         interpreter.HandleCommand("help help", ret)
         output = f.getvalue()
         ret = None # call destructor and flush streams
def test_binary_inout(self):
             opts = lldb.SBCommandInterpreterRunOptions()
             self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
             self.dbg.GetOutputFile().Flush()
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertIn('Show a list of all debugger commands', output)
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_string_inout(self):
         inf = io.StringIO("help help\np/x ~0\n")
         outf = io.StringIO()
         status = self.dbg.SetOutputFile(lldb.SBFile(outf))
         self.assertSuccess(status)
         status = self.dbg.SetInputFile(lldb.SBFile(inf))
         self.assertSuccess(status)
         opts = lldb.SBCommandInterpreterRunOptions()
         self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
         self.dbg.GetOutputFile().Flush()
         output = outf.getvalue()
         self.assertIn('Show a list of all debugger commands', output)
         self.assertIn('0xfff', output)
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_bytes_inout(self):
         inf = io.BytesIO(b"help help\nhelp b\n")
         outf = io.BytesIO()
         status = self.dbg.SetOutputFile(lldb.SBFile(outf))
         self.assertSuccess(status)
         status = self.dbg.SetInputFile(lldb.SBFile(inf))
         self.assertSuccess(status)
         opts = lldb.SBCommandInterpreterRunOptions()
def test_sbfile_write_borrowed(self):
             sbf.Close()
             self.assertFalse(f.closed)
             f.write('BAR\n')
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), 'FOOBAR')
 
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_sbfile_write_forced(self):
         with open(self.out_filename, 'w') as f:
             written = MutableBool(False)
             orig_write = f.write
             def mywrite(x):
                 written.set(True)
                 return orig_write(x)
             f.write = mywrite
             sbf = lldb.SBFile.Create(f, force_io_methods=True)
             e, n = sbf.Write(b'FOO')
             self.assertTrue(written)
             self.assertSuccess(e)
             self.assertEqual(n, 3)
             sbf.Close()
             self.assertTrue(f.closed)
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), 'FOO')
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_sbfile_write_forced_borrowed(self):
         with open(self.out_filename, 'w') as f:
             written = MutableBool(False)
             orig_write = f.write
             def mywrite(x):
                 written.set(True)
                 return orig_write(x)
             f.write = mywrite
             sbf = lldb.SBFile.Create(f, borrow=True, force_io_methods=True)
             e, n = sbf.Write(b'FOO')
             self.assertTrue(written)
             self.assertSuccess(e)
             self.assertEqual(n, 3)
             sbf.Close()
             self.assertFalse(f.closed)
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), 'FOO')
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_sbfile_write_string(self):
         f = io.StringIO()
         sbf = lldb.SBFile(f)
         e, n = sbf.Write(b'FOO')
         self.assertEqual(f.getvalue().strip(), "FOO")
         self.assertSuccess(e)
         self.assertEqual(n, 3)
         sbf.Close()
         self.assertTrue(f.closed)
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_string_out(self):
         f = io.StringIO()
         status = self.dbg.SetOutputFile(f)
         self.assertSuccess(status)
         self.handleCmd("script 'foobar'")
         self.assertEqual(f.getvalue().strip(), "'foobar'")
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_string_error(self):
         f = io.StringIO()
         status = self.dbg.SetErrorFile(f)
         self.assertSuccess(status)
         self.handleCmd('lolwut', check=False, collect_result=False)
         errors = f.getvalue()
         self.assertTrue(re.search(r'error:.*lolwut', errors))
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_sbfile_write_bytes(self):
         f = io.BytesIO()
         sbf = lldb.SBFile(f)
         e, n = sbf.Write(b'FOO')
         self.assertEqual(f.getvalue().strip(), b"FOO")
         self.assertSuccess(e)
         self.assertEqual(n, 3)
         sbf.Close()
         self.assertTrue(f.closed)
 
-    @skipIf(py_version=['<', (3,)])
     def test_sbfile_read_string(self):
         f = io.StringIO('zork')
         sbf = lldb.SBFile(f)
         buf = bytearray(100)
         e, n = sbf.Read(buf)
         self.assertSuccess(e)
         self.assertEqual(buf[:n], b'zork')
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_sbfile_read_string_one_byte(self):
         f = io.StringIO('z')
         sbf = lldb.SBFile(f)
         buf = bytearray(1)
         e, n = sbf.Read(buf)
         self.assertTrue(e.Fail())
         self.assertEqual(n, 0)
         self.assertEqual(e.GetCString(), "can't read less than 6 bytes from a utf8 text stream")
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_sbfile_read_bytes(self):
         f = io.BytesIO(b'zork')
         sbf = lldb.SBFile(f)
         buf = bytearray(100)
         e, n = sbf.Read(buf)
         self.assertSuccess(e)
         self.assertEqual(buf[:n], b'zork')
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_sbfile_out(self):
         with open(self.out_filename, 'w') as f:
             sbf = lldb.SBFile(f)
             status = self.dbg.SetOutputFile(sbf)
             self.assertSuccess(status)
             self.handleCmd('script 2+2')
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), '4')
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_file_out(self):
         with open(self.out_filename, 'w') as f:
             status = self.dbg.SetOutputFile(f)
             self.assertSuccess(status)
             self.handleCmd('script 2+2')
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), '4')
 
def test_file_error(self):
         with open(self.out_filename, 'r') as f:
             errors = f.read()
             self.assertTrue(re.search(r'error:.*lolwut', errors))
 
 
     def test_exceptions(self):
         self.assertRaises(Exception, lldb.SBFile, None)
         self.assertRaises(Exception, lldb.SBFile, "ham sandwich")
-        if sys.version_info[0] < 3:
-            self.assertRaises(Exception, lldb.SBFile, ReallyBadIO())
-        else:
-            self.assertRaises(OhNoe, lldb.SBFile, ReallyBadIO())
-            error, n = lldb.SBFile(BadIO()).Write(b"FOO")
-            self.assertEqual(n, 0)
-            self.assertTrue(error.Fail())
-            self.assertIn('OH NOE', error.GetCString())
-            error, n = lldb.SBFile(BadIO()).Read(bytearray(100))
-            self.assertEqual(n, 0)
-            self.assertTrue(error.Fail())
-            self.assertIn('OH NOE', error.GetCString())
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_exceptions_logged(self):
         messages = list()
         self.dbg.SetLoggingCallback(messages.append)
         self.handleCmd('log enable lldb script')
         self.dbg.SetOutputFile(lldb.SBFile(BadIO()))
         self.handleCmd('script 1+1')
         self.assertTrue(any('OH NOE' in msg for msg in messages))
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_flush(self):
         flushed = MutableBool(False)
         closed = MutableBool(False)
         f = FlushTestIO(flushed, closed)
         self.assertFalse(flushed)
         self.assertFalse(closed)
         sbf = lldb.SBFile(f)
         self.assertFalse(flushed)
def test_close(self):
             with self.assertRaises(ValueError):
                 f.write("\nQUUX\n")
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertTrue(re.search(r'Show a list of all debugger commands', output))
             self.assertTrue(re.search(r'ZAP', output))
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_stdout(self):
         f = io.StringIO()
         status = self.dbg.SetOutputFile(f)
         self.assertSuccess(status)
         self.handleCmd(r"script sys.stdout.write('foobar\n')")
         self.assertEqual(f.getvalue().strip().split(), ["foobar", "7"])
 
 
     def test_stdout_file(self):
         with open(self.out_filename, 'w') as f:
             status = self.dbg.SetOutputFile(f)
             self.assertSuccess(status)
             self.handleCmd(r"script sys.stdout.write('foobar\n')")
         with open(self.out_filename, 'r') as f:
             # In python2 sys.stdout.write() returns None, which
             # the REPL will ignore, but in python3 it will
             # return the number of bytes written, which the REPL
             # will print out.
             lines = [x for x in f.read().strip().split() if x != "7"]
             self.assertEqual(lines, ["foobar"])
 
 
-    @skipIf(py_version=['<', (3,)])
     def test_identity(self):
-
         f = io.StringIO()
         sbf = lldb.SBFile(f)
         self.assertTrue(f is sbf.GetFile())
         sbf.Close()
         self.assertTrue(f.closed)
 
         f = io.StringIO()
         sbf = lldb.SBFile.Create(f, borrow=True)
def test_set_filehandle_none(self):
         with open(self.out_filename, 'w') as f:
             status = self.dbg.SetOutputFile(f)
             self.assertSuccess(status)
             status = self.dbg.SetErrorFile(f)
             self.assertSuccess(status)
             self.dbg.SetOutputFileHandle(None, False)
             self.dbg.SetErrorFileHandle(None, False)
             sbf = self.dbg.GetOutputFile()
-            if sys.version_info.major >= 3:
-                # python 2 lacks PyFile_FromFd, so GetFile() will
-                # have to duplicate the file descriptor and make a FILE*
-                # in order to convert a NativeFile it back to a python
-                # file.
-                self.assertEqual(sbf.GetFile().fileno(), 1)
             sbf = self.dbg.GetErrorFile()
-            if sys.version_info.major >= 3:
-                self.assertEqual(sbf.GetFile().fileno(), 2)
         with open(self.out_filename, 'r') as f:
             status = self.dbg.SetInputFile(f)
             self.assertSuccess(status)
             self.dbg.SetInputFileHandle(None, False)
             sbf = self.dbg.GetInputFile()
-            if sys.version_info.major >= 3:
-                self.assertEqual(sbf.GetFile().fileno(), 0)
 
 
     def test_sbstream(self):
 
         with open(self.out_filename, 'w') as f:
             stream = lldb.SBStream()
             stream.RedirectToFile(f)
             stream.Print("zork")

lldb/test/API/terminal/TestSTTYBeforeAndAfter.py

 """
 Test that 'stty -a' displays the same output before and after running the lldb command.
 """
 
 from __future__ import print_function
 
 
 import lldb
 import six
+import sys
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestSTTYBeforeAndAfter(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
def test_stty_dash_a_before_and_afetr_invoking_lldb_command(self):
                 "The 'expect' program cannot be located, skip the test")
 
         # The expect prompt.
         expect_prompt = "expect[0-9.]+> "
         # The default lldb prompt.
         lldb_prompt = "(lldb) "
 
         # So that the child gets torn down after the test.
-        import sys
-        if sys.version_info.major == 3:
-          self.child = pexpect.spawnu('expect')
-        else:
-          self.child = pexpect.spawn('expect')
         child = self.child
 
         child.expect(expect_prompt)
         child.setecho(True)
         if self.TraceOn():
             child.logfile = sys.stdout
 
         if self.platformIsDarwin():