[lldb] Remove uses of six module (NFC)

[kastiglione]

Summary

With lldb (& llvm) requiring Python 3.6+, use of the six module can be removed.

[kastiglione]

lldb/packages/Python/lldbsuite/support/encoded_file.py

17–25

this function only deviated in the case of python 2, so I removed it.

lldb/packages/Python/lldbsuite/support/seven.py

12

this function was not used externally, so I inlined it into get_command_output.

27

this was also not used.

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

2278–2281

this function had a parameter named str, which shadowed builtin.str. As a fix, in this file I renamed all variables named str to string.

[kastiglione]

I left third_party/Python/module/six, in case there are any lldb scripts that depend on the existence of six.

[mib]

Very cool! Thanks for taking care of this! LGTM with the 2 comments and assuming the test suite runs fine :)

lldb/examples/python/scripted_process/scripted_process.py

5

nit: no need to specify metaclass=ABCMeta, it can just be ScriptedProcess(ABC)

194

ditto

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

2278–2281

nit: If you feel like it, may be you can split everything related to the str-> string refactor into a separate since it's orthogonal to removing six

[mib]

lldb/examples/python/scripted_process/scripted_process.py

5

disregard this comment, that's actually the way to do it ...

[kastiglione]

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

2278–2281

I need to at least make the str -> string rename in the functions where the refactor involves isinstance(..., str). I will remove the other renames, for another diff.

[kastiglione]

Restore some "str" variable names

[kastiglione]

@mib the tests pass on my machine.

[kastiglione]

Missed a restore of str variable name

[DavidSpickett]

There is also a cmake var LLDB_USE_SYSTEM_SIX which can be removed.

[kastiglione]

remove LLDB_USE_SYSTEM_SIX

[kastiglione]

lldb/bindings/python/CMakeLists.txt

63–68 ↗

(On Diff #450843)

@DavidSpickett I removed LLDB_USE_SYSTEM_SIX but left the code that copies vendored copy of six.py. Is this what you had in mind? My thinking is there might be lldb scripts that use six, and I don't want the removal of internal use of six to be a breaking change downstream, not yet anyway.

[JDevlieghere]

🥳

[DavidSpickett]

lldb/bindings/python/CMakeLists.txt

63–68 ↗

(On Diff #450843)

I hadn't considered user scripts good point.

If you were using this option, you'd now get a warning from cmake that it's value was unused. Would it make more sense to have a proper deprecation warning and remove it and the copy of six at some later point?

Please land this change minus the LLDB_USE_SYSTEM_SIX stuff though. I don't want to block the rest on this.

[kastiglione]

Restore LLDB_USE_SYSTEM_SIX

lldb/bindings/interface/SBData.i

%pythoncode %{
                 self.readerfunc = readerfunc
                 self.item_size = item_size
             def __getitem__(self,key):
                 if isinstance(key,slice):
                     list = []
                     for x in range(*key.indices(self.__len__())):
                         list.append(self.__getitem__(x))
                     return list
-                if not (isinstance(key,six.integer_types)):
+                if not (isinstance(key, int)):
                     raise TypeError('must be int')
                 key = key * self.item_size # SBData uses byte-based indexes, but we want to use itemsize-based indexes here
                 error = SBError()
                 my_data = self.readerfunc(self.sbdata,error,key)
                 if error.Fail():
                     raise IndexError(error.GetCString())
                 else:
                     return my_data

lldb/bindings/python/python.swig

 }
 %}
 %enddef
 
 %pythoncode%{
 import uuid
 import re
 import os
-
-import six
 %}
 
 // Include the version of swig that was used to generate this interface.
 %define EMBED_VERSION(VERSION)
 %pythoncode%{
 # SWIG_VERSION is written as a single hex number, but the components of it are
 # meant to be interpreted in decimal. So, 0x030012 is swig 3.0.12, and not
 # 3.0.18.

lldb/examples/python/scripted_process/scripted_process.py

 from abc import ABCMeta, abstractmethod
-import six
 
 import lldb
 
[e-mail]_metaclass(ABCMeta)
-class ScriptedProcess:
+class ScriptedProcess(metaclass=ABCMeta):
 
     """
     The base class for a scripted process.
 
     Most of the base class methods are `@abstractmethod` that need to be
     overwritten by the inheriting class.
 
     DISCLAIMER: THIS INTERFACE IS STILL UNDER DEVELOPMENT AND NOT STABLE.
class ScriptedProcess(metaclass=ABCMeta):
     def get_scripted_thread_plugin(self):
         """ Get scripted thread plugin name.
 
         Returns:
             str: Name of the scripted thread plugin.
         """
         return None
 
[e-mail]_metaclass(ABCMeta)
-class ScriptedThread:
+class ScriptedThread(metaclass=ABCMeta):
 
     """
     The base class for a scripted thread.
 
     Most of the base class methods are `@abstractmethod` that need to be
     overwritten by the inheriting class.
 
     DISCLAIMER: THIS INTERFACE IS STILL UNDER DEVELOPMENT AND NOT STABLE.

lldb/examples/summaries/synth.py

def update(self):
         pass
 
     def has_children(self):
         return len(self.values) > 0
 
     def gen_child(self, name, value):
         data = None
         type = None
-        import six
-        if isinstance(value, six.integer_types):
+        if isinstance(value, int):
             data = lldb.SBData.CreateDataFromUInt64Array(
                 self.bo, self.ps, [value])
             type = self.value.target.GetBasicType(lldb.eBasicTypeLong)
         elif isinstance(value, float):
             data = lldb.SBData.CreateDataFromDoubleArray(
                 self.bo, self.ps, [value])
             type = self.value.target.GetBasicType(lldb.eBasicTypeDouble)
         elif isinstance(value, str):

lldb/packages/Python/lldbsuite/support/encoded_file.py

 """
 Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 See https://llvm.org/LICENSE.txt for license information.
 SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 Prepares language bindings for LLDB build process.  Run with --help
 to see a description of the supported command line arguments.
 """
 
 # Python modules:
 import io
 
-# Third party modules
-import six
-
-
-def _encoded_read(old_read, encoding):
-    def impl(size):
-        result = old_read(size)
-        # If this is Python 2 then we need to convert the resulting `unicode` back
-        # into a `str` before returning
-        if six.PY2:
-            result = result.encode(encoding)
-        return result
-    return impl
-
 
 def _encoded_write(old_write, encoding):
     def impl(s):
-        # If we were asked to write a `str` (in Py2) or a `bytes` (in Py3) decode it
-        # as unicode before attempting to write.
-        if isinstance(s, six.binary_type):
+        # If we were asked to write a `bytes` decode it as unicode before
+        # attempting to write.
+        if isinstance(s, bytes):
             s = s.decode(encoding, "replace")
         # Filter unreadable characters, Python 3 is stricter than python 2 about them.
         import re
         s = re.sub(r'[^\x00-\x7f]',r' ',s)
         return old_write(s)
     return impl
 
 '''
-Create a Text I/O file object that can be written to with either unicode strings or byte strings
-under Python 2 and Python 3, and automatically encodes and decodes as necessary to return the
-native string type for the current Python version
+Create a Text I/O file object that can be written to with either unicode strings
+or byte strings.
 '''
 
 
 def open(
         file,
         encoding,
         mode='r',
         buffering=-1,
         errors=None,
         newline=None,
         closefd=True):
     wrapped_file = io.open(
         file,
         mode=mode,
         buffering=buffering,
         encoding=encoding,
         errors=errors,
         newline=newline,
         closefd=closefd)
-    new_read = _encoded_read(getattr(wrapped_file, 'read'), encoding)
     new_write = _encoded_write(getattr(wrapped_file, 'write'), encoding)
-    setattr(wrapped_file, 'read', new_read)
     setattr(wrapped_file, 'write', new_write)
     return wrapped_file

lldb/packages/Python/lldbsuite/support/seven.py

 import binascii
-import six
 import shlex
+import subprocess
 
-if six.PY2:
-    import commands
-    get_command_output = commands.getoutput
-    get_command_status_output = commands.getstatusoutput
-
-    cmp_ = cmp
-else:
-    def get_command_status_output(command):
-        try:
-            import subprocess
-            return (
-                0,
-                subprocess.check_output(
-                    command,
-                    shell=True,
-                    universal_newlines=True).rstrip())
-        except subprocess.CalledProcessError as e:
-            return (e.returncode, e.output)
-
-    def get_command_output(command):
-        return get_command_status_output(command)[1]
-
-    cmp_ = lambda x, y: (x > y) - (x < y)
+def get_command_output(command):
+        return subprocess.check_output(
+            universal_newlines=True).rstrip()
+        return e.output
 
-def bitcast_to_string(b):
+def bitcast_to_string(b: bytes) -> str:
     """
-    Take a string(PY2) or a bytes(PY3) object and return a string. The returned
-    string contains the exact same bytes as the input object (latin1 <-> unicode
-    transformation is an identity operation for the first 256 code points).
+    Take a bytes object and return a string. The returned string contains the
+    exact same bytes as the input object. (latin1 <-> unicode transformation is
+    an identity operation for the first 256 code points).
     """
-    return b if six.PY2 else b.decode("latin1")
+    return b.decode("latin1")
 
-def bitcast_to_bytes(s):
+def bitcast_to_bytes(s: str) -> bytes:
     """
-    Take a string and return a string(PY2) or a bytes(PY3) object. The returned
-    object contains the exact same bytes as the input string. (latin1 <->
-    unicode transformation is an identity operation for the first 256 code
-    points).
+    Take a string and return a bytes object. The returned object contains the
+    exact same bytes as the input string. (latin1 <-> unicode transformation isi
+    an identity operation for the first 256 code points).
     """
-    return s if six.PY2 else s.encode("latin1")
+    return s.encode("latin1")
 
 def unhexlify(hexstr):
     """Hex-decode a string. The result is always a string."""
     return bitcast_to_string(binascii.unhexlify(hexstr))
 
 def hexlify(data):
     """Hex-encode string data. The result if always a string."""
     return bitcast_to_string(binascii.hexlify(bitcast_to_bytes(data)))
 
 # TODO: Replace this with `shlex.join` when minimum Python version is >= 3.8
 def join_for_shell(split_command):
     return " ".join([shlex.quote(part) for part in split_command])

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

 from __future__ import absolute_import
 
 # System modules
 from distutils.version import LooseVersion
 from functools import wraps
 import ctypes
 import locale
 import os
 import platform
 import re
 import sys
 import tempfile
 import subprocess
 
 # Third-party modules
-import six
 import unittest2
 
 # LLDB modules
 import lldb
 from . import configuration
 from . import test_categories
 from . import lldbtest_config
 from lldbsuite.support import funcutils
def _check_expected_version(comparison, expected, actual):
     expected_str = '.'.join([str(x) for x in expected])
     actual_str = '.'.join([str(x) for x in actual])
 
     return op_lookup[comparison](
         LooseVersion(actual_str),
         LooseVersion(expected_str))
 
 
-_re_pattern_type = type(re.compile(''))
 def _match_decorator_property(expected, actual):
     if expected is None:
         return True
 
     if actual is None :
         return False
 
     if isinstance(expected, no_match):
         return not _match_decorator_property(expected.item, actual)
 
-    if isinstance(expected, (_re_pattern_type,) + six.string_types):
+    if isinstance(expected, (re.Pattern, str)):
         return re.search(expected, actual) is not None
 
     if hasattr(expected, "__iter__"):
         return any([x is not None and _match_decorator_property(x, actual)
                     for x in expected])
 
     return expected == actual
 
def expectedFailure_impl(func):
             else:
                 func(*args, **kwargs)
         return wrapper
     # Some decorators can be called both with no arguments (e.g. @expectedFailureWindows)
     # or with arguments (e.g. @expectedFailureWindows(compilers=['gcc'])).  When called
     # the first way, the first argument will be the actual function because decorators are
     # weird like that.  So this is basically a check that says "which syntax was the original
     # function decorated with?"
-    if six.callable(bugnumber):
+    if callable(bugnumber):
         return expectedFailure_impl(bugnumber)
     else:
         return expectedFailure_impl
 
 
 def skipTestIfFn(expected_fn, bugnumber=None):
     def skipTestIfFn_impl(func):
         if isinstance(func, type) and issubclass(func, unittest2.TestCase):
def skipTestIfFn_impl(func):
                 return func(*args, **kwargs)
         return wrapper
 
     # Some decorators can be called both with no arguments (e.g. @expectedFailureWindows)
     # or with arguments (e.g. @expectedFailureWindows(compilers=['gcc'])).  When called
     # the first way, the first argument will be the actual function because decorators are
     # weird like that.  So this is basically a check that says "how was the
     # decorator used"
-    if six.callable(bugnumber):
+    if callable(bugnumber):
         return skipTestIfFn_impl(bugnumber)
     else:
         return skipTestIfFn_impl
 
 
 def _decorateTest(mode,
                   bugnumber=None, oslist=None, hostoslist=None,
                   compiler=None, compiler_version=None,
def fn(self):
                 DecorateMode.Skip: "skipping",
                 DecorateMode.Xfail: "xfailing"}[mode]
             if len(reasons) > 0:
                 reason_str = ",".join(reasons)
                 reason_str = "{} due to the following parameter(s): {}".format(
                     mode_str, reason_str)
             else:
                 reason_str = "{} unconditionally".format(mode_str)
-            if bugnumber is not None and not six.callable(bugnumber):
+            if bugnumber is not None and not callable(bugnumber):
                 reason_str = reason_str + " [" + str(bugnumber) + "]"
         return reason_str
 
     if mode == DecorateMode.Skip:
         return skipTestIfFn(fn, bugnumber)
     elif mode == DecorateMode.Xfail:
         return expectedFailureIfFn(fn, bugnumber)
     else:
def expectedFailure_impl(func):
         def wrapper(*args, **kwargs):
             func(*args, **kwargs)
         return wrapper
     # Some decorators can be called both with no arguments (e.g. @expectedFailureWindows)
     # or with arguments (e.g. @expectedFailureWindows(compilers=['gcc'])).  When called
     # the first way, the first argument will be the actual function because decorators are
     # weird like that.  So this is basically a check that says "which syntax was the original
     # function decorated with?"
-    if six.callable(bugnumber):
+    if callable(bugnumber):
         return expectedFailure_impl(bugnumber)
     else:
         return expectedFailure_impl
 
 
 def expectedFlakeyOS(oslist, bugnumber=None, compilers=None):
     def fn(self):
         return (self.getPlatform() in oslist and

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

 import re
 import shutil
 import signal
 import subprocess
 import sys
 import tempfile
 
 # Third-party modules
-import six
 import unittest2
 
 # LLDB Modules
 import lldbsuite
 from . import configuration
 from . import dotest_args
 from . import lldbtest_config
 from . import test_categories

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

 from __future__ import absolute_import
 
 # System modules
 import os
 import sys
 
-# Third-party modules
-import six
-
 # LLDB Modules
 import lldb
 from .lldbtest import *
 from . import lldbutil
 from lldbsuite.test.decorators import *
 
 @skipIfRemote
 @skipIfWindows  # llvm.org/pr22274: need a pexpect replacement for windows
def launch(self, executable=None, extra_args=None, timeout=60,
             self.child.expect_exact("target create")
             self.child.expect_exact("Current executable set to")
             self.expect_prompt()
 
     def expect(self, cmd, substrs=None):
         self.assertNotIn('\n', cmd)
         # If 'substrs' is a string then this code would just check that every
         # character of the string is in the output.
-        assert not isinstance(substrs, six.string_types), \
+        assert not isinstance(substrs, str), \
             "substrs must be a collection of strings"
 
         self.child.sendline(cmd)
         if substrs is not None:
             for s in substrs:
                 self.child.expect_exact(s)
         self.expect_prompt()
 

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

 """ This module represents an abstraction of an lldb target / host platform. """
 
 from __future__ import absolute_import
 
 # System modules
 import itertools
 
-# Third-party modules
-import six
-
 # LLDB modules
 import lldb
 
 windows, linux, macosx, darwin, ios, tvos, watchos, bridgeos, darwin_all, \
     darwin_embedded, darwin_simulator, freebsd, netbsd, bsd_all, android \
     = range(15)
 
 __darwin_embedded = ["ios", "tvos", "watchos", "bridgeos"]
__name_lookup = {
     netbsd: ["netbsd"],
     bsd_all: ["freebsd", "netbsd"],
     android: ["android"]
 }
 
 
 def translate(values):
 
-    if isinstance(values, six.integer_types):
+    if isinstance(values, int):
         # This is a value from the platform enumeration, translate it.
         return __name_lookup[values]
-    elif isinstance(values, six.string_types):
+    elif isinstance(values, str):
         # This is a raw string, return it.
         return [values]
     elif hasattr(values, "__iter__"):
         # This is an iterable, convert each item.
         result = [translate(x) for x in values]
         result = list(itertools.chain(*result))
         return result
     return values

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

 """ This module contains functions used by the test cases to hide the
 architecture and/or the platform dependent nature of the tests. """
 
 from __future__ import absolute_import
 
 # System modules
 import itertools
 import re
 import subprocess
 import sys
 import os
-
-# Third-party modules
-import six
-from six.moves.urllib import parse as urlparse
+from urllib.parse import urlparse
 
 # LLDB modules
 from . import configuration
 import lldb
 import lldbsuite.test.lldbplatform as lldbplatform
 
 
 def check_first_register_readable(test_case):

 
 def target_is_android():
     return configuration.lldb_platform_name == "remote-android"
 
 def android_device_api():
     if not hasattr(android_device_api, 'result'):
         assert configuration.lldb_platform_url is not None
         device_id = None
-        parsed_url = urlparse.urlparse(configuration.lldb_platform_url)
+        parsed_url = urlparse(configuration.lldb_platform_url)
         host_name = parsed_url.netloc.split(":")[0]
         if host_name != 'localhost':
             device_id = host_name
             if device_id.startswith('[') and device_id.endswith(']'):
                 device_id = device_id[1:-1]
         retcode, stdout, stderr = _run_adb_command(
             ["shell", "getprop", "ro.build.version.sdk"], device_id)
         if retcode == 0:

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

 import signal
 from subprocess import *
 import sys
 import time
 import traceback
 
 # Third-party modules
 import unittest2
-from six import add_metaclass
-from six import StringIO as SixStringIO
-import six
 
 # LLDB modules
 import lldb
 from . import configuration
 from . import decorators
 from . import lldbplatformutil
 from . import lldbtest_config
 from . import lldbutil
def check_value_children(self, test_base, val, error_msg=None):
         test_base.assertEqual(len(self.children), val.GetNumChildren(), this_error_msg)
 
         for i in range(0, val.GetNumChildren()):
             expected_child = self.children[i]
             actual_child = val.GetChildAtIndex(i)
             child_error = "Checking child with index " + str(i) + ":\n" + error_msg
             expected_child.check_value(test_base, actual_child, child_error)
 
-class recording(SixStringIO):
+class recording(io.StringIO):
     """
     A nice little context manager for recording the debugger interactions into
     our session object.  If trace flag is ON, it also emits the interactions
     into the stderr.
     """
 
     def __init__(self, test, trace):
-        """Create a SixStringIO instance; record the session obj and trace flag."""
-        SixStringIO.__init__(self)
+        """Create a io.StringIO instance; record the session obj and trace flag."""
+        io.StringIO.__init__(self)
         # The test might not have undergone the 'setUp(self)' phase yet, so that
         # the attribute 'session' might not even exist yet.
         self.session = getattr(test, "session", None) if test else None
         self.trace = trace
 
     def __enter__(self):
         """
         Context management protocol on entry to the body of the with statement.
-        Just return the SixStringIO object.
+        Just return the io.StringIO object.
         """
         return self
 
     def __exit__(self, type, value, tb):
         """
         Context management protocol on exit from the body of the with statement.
         If trace is ON, it emits the recordings into stderr.  Always add the
-        recordings to our session object.  And close the SixStringIO object, too.
+        recordings to our session object.  And close the io.StringIO object, too.
         """
         if self.trace:
             print(self.getvalue(), file=sys.stderr)
         if self.session:
             print(self.getvalue(), file=self.session)
         self.close()
 
 
-@add_metaclass(abc.ABCMeta)
-class _BaseProcess(object):
+class _BaseProcess(object, metaclass=abc.ABCMeta):
 
     @abc.abstractproperty
     def pid(self):
         """Returns process PID if has been launched already."""
 
     @abc.abstractmethod
     def launch(self, executable, args, extra_env):
         """Launches new process with given executable and args."""
def addTearDownCleanup(self, dictionary):
         self.doTearDownCleanups = True
 
     def addTearDownHook(self, hook):
         """
         Add a function to be run during tearDown() time.
 
         Hooks are executed in a first come first serve manner.
         """
-        if six.callable(hook):
+        if callable(hook):
             with recording(self, traceAlways) as sbuf:
                 print(
                     "Adding tearDown hook:",
                     getsource_if_available(hook),
                     file=sbuf)
             self.hooks.append(hook)
 
         return self
def __new__(cls, name, bases, attrs):
             name,
             bases,
             newattrs)
 
 # Setup the metaclass for this class to change the list of the test
 # methods when a new class is loaded
 
 
-@add_metaclass(LLDBTestCaseFactory)
-class TestBase(Base):
+class TestBase(Base, metaclass=LLDBTestCaseFactory):
     """
     This abstract base class is meant to be subclassed.  It provides default
     implementations for setUpClass(), tearDownClass(), setUp(), and tearDown(),
     among other things.
 
     Important things for test class writers:
 
         - The setUp method sets up things to facilitate subsequent interactions
""".format(cmd_status, filecheck_cmd, output, cmd_stdout, cmd_stderr)
         trace = cmd_status != 0 or traceAlways
         with recording(self, trace) as sbuf:
             print(filecheck_trace, file=sbuf)
 
         self.assertTrue(cmd_status == 0)
 
     def expect(
             self,
-            str,
+            string,
             msg=None,
             patterns=None,
             startstr=None,
             endstr=None,
             substrs=None,
             trace=False,
             error=False,
             ordered=True,
def expect(
         client is expecting the command to fail.  In this case, the error stream
         from running the command is retrieved and compared against the golden
         input, instead.
 
         If the keyword argument matching is set to False, it signifies that the API
         client is expecting the output of the command not to match the golden
         input.
 
-        Finally, the required argument 'str' represents the lldb command to be
+        Finally, the required argument 'string' represents the lldb command to be
         sent to the command interpreter.  In case the keyword argument 'exe' is
-        set to False, the 'str' is treated as a string to be matched/not-matched
+        set to False, the 'string' is treated as a string to be matched/not-matched
         against the golden input.
         """
         # Catch cases where `expect` has been miscalled. Specifically, prevent
         # this easy to make mistake:
         #     self.expect("lldb command", "some substr")
         # The `msg` parameter is used only when a failed match occurs. A failed
         # match can only occur when one of `patterns`, `startstr`, `endstr`, or
         # `substrs` has been given. Thus, if a `msg` is given, it's an error to
         # not also provide one of the matcher parameters.
         if msg and not (patterns or startstr or endstr or substrs or error):
             assert False, "expect() missing a matcher argument"
 
         # Check `patterns` and `substrs` are not accidentally given as strings.
-        assert not isinstance(patterns, six.string_types), \
+        assert not isinstance(patterns, str), \
             "patterns must be a collection of strings"
-        assert not isinstance(substrs, six.string_types), \
+        assert not isinstance(substrs, str), \
             "substrs must be a collection of strings"
 
         trace = (True if traceAlways else trace)
 
         if exe:
             # First run the command.  If we are expecting error, set check=False.
             # Pass the assert message along since it provides more semantic
             # info.
             self.runCmd(
-                str,
+                string,
                 msg=msg,
                 trace=(
                     True if trace else False),
                 check=not error,
                 inHistory=inHistory)
 
             # Then compare the output against expected strings.
             output = self.res.GetError() if error else self.res.GetOutput()
 
             # If error is True, the API client expects the command to fail!
             if error:
                 self.assertFalse(self.res.Succeeded(),
-                                 "Command '" + str + "' is expected to fail!")
+                                 "Command '" + string + "' is expected to fail!")
         else:
-            # No execution required, just compare str against the golden input.
-            if isinstance(str, lldb.SBCommandReturnObject):
-                output = str.GetOutput()
+            # No execution required, just compare string against the golden input.
+            if isinstance(string, lldb.SBCommandReturnObject):
+                output = string.GetOutput()
             else:
-                output = str
+                output = string
             with recording(self, trace) as sbuf:
                 print("looking at:", output, file=sbuf)
 
         expecting_str = "Expecting" if matching else "Not expecting"
         def found_str(matched):
             return "was found" if matched else "was not found"
 
         # To be used as assert fail message and/or trace content
         log_lines = [
                 "{}:".format("Ran command" if exe else "Checking string"),
-                "\"{}\"".format(str),
+                "\"{}\"".format(string),
                 # Space out command and output
                 "",
         ]
         if exe:
             # Newline before output to make large strings more readable
             log_lines.append("Got output:\n{}".format(output))
 
         # Assume that we start matched if we want a match

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

 """
 This LLDB module contains miscellaneous utilities.
 Some of the test suite takes advantage of the utility functions defined here.
 They can also be useful for general purpose lldb scripting.
 """
 
 from __future__ import print_function
 from __future__ import absolute_import
 
 # System modules
 import errno
+import io
 import os
 import re
 import sys
 import subprocess
 from typing import Dict
 
-# Third-party modules
-from six import StringIO as SixStringIO
-import six
-
 # LLDB modules
 import lldb
 from . import lldbtest_config
 from . import configuration
 
 # How often failed simulator process launches are retried.
 SIMULATOR_RETRY = 3
 

 # ===================================================
 
 
 def disassemble(target, function_or_symbol):
     """Disassemble the function or symbol given a target.
 
     It returns the disassembly content in a string object.
     """
-    buf = SixStringIO()
+    buf = io.StringIO()
     insts = function_or_symbol.GetInstructions(target)
     for i in insts:
         print(i, file=buf)
     return buf.getvalue()
 
 # ==========================================================
 # Integer (byte size 1, 2, 4, and 8) to bytearray conversion
 # ==========================================================
def GetStackFrame(i):
         return thread.GetFrameAtIndex(i)
 
     return list(map(GetStackFrame, list(range(thread.GetNumFrames()))))
 
 
 def print_stacktrace(thread, string_buffer=False):
     """Prints a simple stack trace of this thread."""
 
-    output = SixStringIO() if string_buffer else sys.stdout
+    output = io.StringIO() if string_buffer else sys.stdout
     target = thread.GetProcess().GetTarget()
 
     depth = thread.GetNumFrames()
 
     mods = get_module_names(thread)
     funcs = get_function_names(thread)
     symbols = get_symbol_names(thread)
     files = get_filenames(thread)
def print_stacktrace(thread, string_buffer=False):
 
     if string_buffer:
         return output.getvalue()
 
 
 def print_stacktraces(process, string_buffer=False):
     """Prints the stack traces of all the threads."""
 
-    output = SixStringIO() if string_buffer else sys.stdout
+    output = io.StringIO() if string_buffer else sys.stdout
 
     print("Stack traces for " + str(process), file=output)
 
     for thread in process:
         print(print_stacktrace(thread, string_buffer=True), file=output)
 
     if string_buffer:
         return output.getvalue()
if showFuncName:
         return "%s(%s)" % (name, ", ".join(args))
     else:
         return "(%s)" % (", ".join(args))
 
 
 def print_registers(frame, string_buffer=False):
     """Prints all the register sets of the frame."""
 
-    output = SixStringIO() if string_buffer else sys.stdout
+    output = io.StringIO() if string_buffer else sys.stdout
 
     print("Register sets for " + str(frame), file=output)
 
     registerSet = frame.GetRegisters()  # Return type of SBValueList.
     print("Frame registers (size of register set = %d):" %
           registerSet.GetSize(), file=output)
     for value in registerSet:
         #print(value, file=output)

 # ======================================
 
 
 class BasicFormatter(object):
     """The basic formatter inspects the value object and prints the value."""
 
     def format(self, value, buffer=None, indent=0):
         if not buffer:
-            output = SixStringIO()
+            output = io.StringIO()
         else:
             output = buffer
         # If there is a summary, it suffices.
         val = value.GetSummary()
         # Otherwise, get the value.
         if val is None:
             val = value.GetValue()
         if val is None and value.GetNumChildren() > 0:
class ChildVisitingFormatter(BasicFormatter):
     """
 
     def __init__(self, indent_child=2):
         """Default indentation of 2 SPC's for the children."""
         self.cindent = indent_child
 
     def format(self, value, buffer=None):
         if not buffer:
-            output = SixStringIO()
+            output = io.StringIO()
         else:
             output = buffer
 
         BasicFormatter.format(self, value, buffer=output)
         for child in value:
             BasicFormatter.format(
                 self, child, buffer=output, indent=self.cindent)
 
class RecursiveDecentFormatter(BasicFormatter):
     """
 
     def __init__(self, indent_level=0, indent_child=2):
         self.lindent = indent_level
         self.cindent = indent_child
 
     def format(self, value, buffer=None):
         if not buffer:
-            output = SixStringIO()
+            output = io.StringIO()
         else:
             output = buffer
 
         BasicFormatter.format(self, value, buffer=output, indent=self.lindent)
         new_indent = self.lindent + self.cindent
         for child in value:
             if child.GetSummary() is not None:
                 BasicFormatter.format(
class PrintableRegex(object):
     def __str__(self):
         return "%s" % (self.text)
 
     def __repr__(self):
         return "re.compile(%s) -> %s" % (self.text, self.regex)
 
 
 def skip_if_callable(test, mycallable, reason):
-    if six.callable(mycallable):
+    if callable(mycallable):
         if mycallable(test):
             test.skipTest(reason)
             return True
     return False
 
 
 def skip_if_library_missing(test, target, library):
     def find_library(target, library):

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def __new__(cls, name, bases, attrs):
                 method_name = attrname + "_" + cat
                 test_method.__name__ = method_name
                 test_method.debug_server = cat
                 newattrs[method_name] = test_method
 
         return super(GdbRemoteTestCaseFactory, cls).__new__(
                 cls, name, bases, newattrs)
 
-@add_metaclass(GdbRemoteTestCaseFactory)
-class GdbRemoteTestCaseBase(Base):
+class GdbRemoteTestCaseBase(Base, metaclass=GdbRemoteTestCaseFactory):
 
     # Default time out in seconds. The timeout is increased tenfold under Asan.
     DEFAULT_TIMEOUT =  20 * (10 if ('ASAN_OPTIONS' in os.environ) else 1)
     # Default sleep time in seconds. The sleep time is doubled under Asan.
     DEFAULT_SLEEP   =  5  * (2  if ('ASAN_OPTIONS' in os.environ) else 1)
 
     _GDBREMOTE_KILL_PACKET = b"$k#6b"
 

lldb/packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

 """Module for supporting unit testing of the lldb-server debug monitor exe.
 """
 
 from __future__ import division, print_function
 
 import binascii
 import os
 import os.path
 import platform
 import re
-import six
 import socket
 import subprocess
 from lldbsuite.support import seven
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import configuration
 from textwrap import dedent
 import shutil
 
def process_is_running(pid, unknown_value=True):
     Returns:
 
         If we can figure out how to check running process ids on the given OS:
         return True if the process is running, or False otherwise.
 
         If we don't know how to check running process ids on the given OS:
         return the value provided by the unknown_value arg.
     """
-    if not isinstance(pid, six.integer_types):
+    if not isinstance(pid, int):
         raise Exception(
             "pid must be an integral type (actual type: %s)" % str(
                 type(pid)))
 
     process_ids = []
 
     if lldb.remote_platform:
         # Don't know how to get list of running process IDs on a remote
def send_ack(self):
         self.send_raw(b"+")
 
     def send_packet(self, packet):
         self.send_raw(b'$%s#%02x'%(packet, self._checksum(packet)))
 
     @staticmethod
     def _checksum(packet):
         checksum = 0
-        for c in six.iterbytes(packet):
+        for c in iter(packet):
             checksum += c
         return checksum % 256
 
     def _read(self, q):
         while not q:
             new_bytes = self._sock.recv(4096)
             self._process_new_bytes(new_bytes)
         return q.pop(0)

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

ScriptInterpreterPythonImpl::ScriptInterpreterPythonImpl(Debugger &debugger)
   run_string.Printf(
       "run_one_line (%s, 'import copy, keyword, os, re, sys, uuid, lldb')",
       m_dictionary_name.c_str());
   PyRun_SimpleString(run_string.GetData());
 
   // Reloading modules requires a different syntax in Python 2 and Python 3.
   // This provides a consistent syntax no matter what version of Python.
   run_string.Clear();
-  run_string.Printf("run_one_line (%s, 'from six.moves import reload_module')",
+  run_string.Printf("run_one_line (%s, 'from importlib import reload as reload_module')",
                     m_dictionary_name.c_str());
   PyRun_SimpleString(run_string.GetData());
 
   // WARNING: temporary code that loads Cocoa formatters - this should be done
   // on a per-platform basis rather than loading the whole set and letting the
   // individual formatter classes exploit APIs to check whether they can/cannot
   // do their task
   run_string.Clear();

lldb/test/API/api/listeners/TestListener.py

 """
 Test that we can listen to modules loaded events.
 """
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
-import six
-
 class ListenToModuleLoadedEvents (TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_clearing_listener(self):
         """Make sure we also clear listerers from the hook up for event type manager"""
         self.build()
 
         my_first_listener = lldb.SBListener("bonus_listener")

lldb/test/API/commands/command/script/import/thepackage/TPunitA.py

-
-import six
-
-
 def command(debugger, command, result, internal_dict):
-    result.PutCString(six.u("hello world A"))
+    result.PutCString("hello world A")
     return None

lldb/test/API/commands/command/script/import/thepackage/TPunitB.py

-
-import six
-
-
 def command(debugger, command, result, internal_dict):
-    result.PutCString(six.u("hello world B"))
+    result.PutCString("hello world B")
     return None

lldb/test/API/commands/process/launch/TestProcessLaunch.py

 """
 Test lldb process launch flags.
 """
 
 from __future__ import print_function
 
 import os
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
-import six
-
 
 class ProcessLaunchTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.runCmd("settings set auto-confirm true")

lldb/test/API/functionalities/gdb_remote_client/TestGdbClientModuleLoad.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from lldbsuite.test.gdbclientutils import *
 from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
-from lldbsuite.support import seven
 
 class MyResponder(MockGDBServerResponder):
     """
     A responder which simulates a process with a single shared library loaded.
     Its parameters allow configuration of various properties of the library.
     """
 
     def __init__(self, testcase, triple, library_name, auxv_entry, region_info):

lldb/test/API/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

 """
 Test basics of Minidump debugging.
 """
 
-from six import iteritems
-
 import shutil
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
def do_test_deeper_stack(self, binary, core, pid):
         target = self.dbg.CreateTarget(binary)
         process = target.LoadCore(core)
         thread = process.GetThreadAtIndex(0)
 
         self.assertEqual(process.GetProcessID(), pid)
 
         expected_stack = {1: 'bar', 2: 'foo', 3: '_start'}
         self.assertGreaterEqual(thread.GetNumFrames(), len(expected_stack))
-        for index, name in iteritems(expected_stack):
+        for index, name in expected_stack.items():
             frame = thread.GetFrameAtIndex(index)
             self.assertTrue(frame.IsValid())
             function_name = frame.GetFunctionName()
             self.assertIn(name, function_name)
 
     @skipIfLLVMTargetMissing("X86")
     def test_deeper_stack_in_minidump(self):
         """Test that we can examine a more interesting stack in a Minidump."""

lldb/test/API/functionalities/postmortem/minidump-new/TestMiniDumpUUID.py

 """
 Test basics of Minidump debugging.
 """
 
-from six import iteritems
-
-
 import lldb
 import os
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class MiniDumpUUIDTestCase(TestBase):

lldb/test/API/functionalities/postmortem/minidump/TestMiniDump.py

 """
 Test basics of mini dump debugging.
 """
 
-from six import iteritems
-
-
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class MiniDumpTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
def test_deeper_stack_in_mini_dump(self):
 
             # Launch with the mini dump, and inspect the stack.
             target = self.dbg.CreateTarget(None)
             process = target.LoadCore(core)
             thread = process.GetThreadAtIndex(0)
 
             expected_stack = {0: 'bar', 1: 'foo', 2: 'main'}
             self.assertGreaterEqual(thread.GetNumFrames(), len(expected_stack))
-            for index, name in iteritems(expected_stack):
+            for index, name in expected_stack.items():
                 frame = thread.GetFrameAtIndex(index)
                 self.assertTrue(frame.IsValid())
                 function_name = frame.GetFunctionName()
                 self.assertIn(name, function_name)
 
         finally:
             # Clean up the mini dump file.
             self.assertTrue(self.dbg.DeleteTarget(target))

lldb/test/API/functionalities/postmortem/wow64_minidump/TestWow64MiniDump.py

 """
 Test basics of a mini dump taken of a 32-bit process running in WoW64
 
 WoW64 is the subsystem that lets 32-bit processes run in 64-bit Windows.  If you
 capture a mini dump of a process running under WoW64 with a 64-bit debugger, you
 end up with a dump of the WoW64 layer.  In that case, LLDB must do extra work to
 get the 32-bit register contexts.
 """
 
-from six import iteritems
-
-
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class Wow64MiniDumpTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True

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

 """
 Use lldb Python SBFrame API to get the argument values of the call stacks.
 And other SBFrame API tests.
 """
 
 from __future__ import print_function
 
+import io
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class FrameAPITestCase(TestBase):
def test_get_arg_vals_for_call_stack(self):
         process = target.GetProcess()
         self.assertState(process.GetState(), lldb.eStateStopped,
                          PROCESS_STOPPED)
 
         # Keeps track of the number of times 'a' is called where it is within a
         # depth of 3 of the 'c' leaf function.
         callsOfA = 0
 
-        from six import StringIO as SixStringIO
-        session = SixStringIO()
+        session = io.StringIO()
         while process.GetState() == lldb.eStateStopped:
             thread = lldbutil.get_stopped_thread(
                 process, lldb.eStopReasonBreakpoint)
             self.assertIsNotNone(thread)
             # Inspect at most 3 frames.
             numFrames = min(3, thread.GetNumFrames())
             for i in range(numFrames):
                 frame = thread.GetFrameAtIndex(i)

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 io
 import sys
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestSTTYBeforeAndAfter(TestBase):
 
def test_stty_dash_a_before_and_afetr_invoking_lldb_command(self):
             child.sendline('set env(TERM) xterm')
         else:
             child.sendline('set env(TERM) vt100')
         child.expect(expect_prompt)
         child.sendline('puts $env(TERM)')
         child.expect(expect_prompt)
 
         # Turn on loggings for input/output to/from the child.
-        child.logfile_send = child_send1 = six.StringIO()
-        child.logfile_read = child_read1 = six.StringIO()
+        child.logfile_send = child_send1 = io.StringIO()
+        child.logfile_read = child_read1 = io.StringIO()
         child.sendline('stty -a')
         child.expect(expect_prompt)
 
         # Now that the stage1 logging is done, restore logfile to None to
         # stop further logging.
         child.logfile_send = None
         child.logfile_read = None
 
         # Invoke the lldb command.
         child.sendline(lldbtest_config.lldbExec)
         child.expect_exact(lldb_prompt)
 
         # Immediately quit.
         child.sendline('quit')
         child.expect(expect_prompt)
 
-        child.logfile_send = child_send2 = six.StringIO()
-        child.logfile_read = child_read2 = six.StringIO()
+        child.logfile_send = child_send2 = io.StringIO()
+        child.logfile_read = child_read2 = io.StringIO()
         child.sendline('stty -a')
         child.expect(expect_prompt)
 
         child.sendline('exit')
 
         # Now that the stage2 logging is done, restore logfile to None to
         # stop further logging.
         child.logfile_send = None

lldb/test/API/test_utils/base/TestBaseTest.py

 """
 Test TestBase test functions.
 """
 
+import io
+
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test_event import build_exception
-import six
 
 class TestBuildMethod(Base):
 
     def setUp(self):
         super().setUp()
         self._traces = []
         self.traceAlways = True
 
     # override the parent trace method
     def trace(self, *args, **kwargs):
-        io = six.StringIO()
-        print(*args, file=io, **kwargs)
-        self._traces.append(io.getvalue())
+        buf = io.StringIO()
+        print(*args, file=buf, **kwargs)
+        self._traces.append(buf.getvalue())
 
     def test_build_fails_helpfully(self):
         try:
             self.build(dictionary={"CXX_SOURCES": "nonexisting-file.cpp"})
         except build_exception.BuildError as e:
             self.assertIn("nonexisting-file.cpp", str(e))
         else:
             self.fail("BuildError not raised!")
 
     def test_build_logs_traces(self):
         self.build(dictionary={"CXX_SOURCES": "return0.cpp"})
         self.assertIn("CXX_SOURCES", self._traces[0])
         self.assertIn("return0.o", self._traces[1])

lldb/third_party/Python/module/progress/progress.py

 #!/usr/bin/env python
 
 from __future__ import print_function
 
 import use_lldb_suite
-import six
 
 import sys
 import time
 
 
 class ProgressBar(object):
     """ProgressBar class holds the options of the progress bar.
     The options are:
         start   State from which start the progress. For example, if start is
                 5 and the end is 10, the progress of this state is 50%
         end     State in which the progress has terminated.
         width   --
         fill    String to use for "filled" used to represent the progress
         blank   String to use for "filled" used to represent remaining space.
         format  Format
         incremental
     """
-    light_block = six.unichr(0x2591).encode("utf-8")
-    solid_block = six.unichr(0x2588).encode("utf-8")
-    solid_right_arrow = six.unichr(0x25BA).encode("utf-8")
+    light_block = chr(0x2591).encode("utf-8")
+    solid_block = chr(0x2588).encode("utf-8")
+    solid_right_arrow = chr(0x25BA).encode("utf-8")
 
     def __init__(self,
                  start=0,
                  end=10,
                  width=12,
-                 fill=six.unichr(0x25C9).encode("utf-8"),
-                 blank=six.unichr(0x25CC).encode("utf-8"),
-                 marker=six.unichr(0x25CE).encode("utf-8"),
+                 fill=chr(0x25C9).encode("utf-8"),
+                 blank=chr(0x25CC).encode("utf-8"),
+                 marker=chr(0x25CE).encode("utf-8"),
                  format='[%(fill)s%(marker)s%(blank)s] %(progress)s%%',
                  incremental=True):
         super(ProgressBar, self).__init__()
 
         self.start = start
         self.end = end
         self.width = width
         self.fill = fill
class AnimatedProgressBar(ProgressBar):
     Accepts an extra keyword argument named `stdout` (by default use sys.stdout)
     and may be any file-object to which send the progress status.
     """
 
     def __init__(self,
                  start=0,
                  end=10,
                  width=12,
-                 fill=six.unichr(0x25C9).encode("utf-8"),
-                 blank=six.unichr(0x25CC).encode("utf-8"),
-                 marker=six.unichr(0x25CE).encode("utf-8"),
+                 fill=chr(0x25C9).encode("utf-8"),
+                 blank=chr(0x25CC).encode("utf-8"),
+                 marker=chr(0x25CE).encode("utf-8"),
                  format='[%(fill)s%(marker)s%(blank)s] %(progress)s%%',
                  incremental=True,
                  stdout=sys.stdout):
         super(
             AnimatedProgressBar,
             self).__init__(
             start,
             end,
"""Extends AnimatedProgressBar to allow you to track a set of events that
        cause the progress to move. For instance, in a deletion progress bar, you
        can track files that were nuked and files that the user doesn't have access to
     """
 
     def __init__(self,
                  start=0,
                  end=10,
                  width=12,
-                 fill=six.unichr(0x25C9).encode("utf-8"),
-                 blank=six.unichr(0x25CC).encode("utf-8"),
-                 marker=six.unichr(0x25CE).encode("utf-8"),
+                 fill=chr(0x25C9).encode("utf-8"),
+                 blank=chr(0x25CC).encode("utf-8"),
+                 marker=chr(0x25CE).encode("utf-8"),
                  format='[%(fill)s%(marker)s%(blank)s] %(progress)s%%',
                  incremental=True,
                  stdout=sys.stdout):
         super(
             ProgressWithEvents,
             self).__init__(
             start,
             end,

lldb/third_party/Python/module/unittest2/unittest2/case.py

 """Test case implementation"""
 
 import sys
 import difflib
 import pprint
 import re
 import unittest
 import warnings
 
-import six
-
 from unittest2 import result
 from unittest2.util import (
     safe_repr, safe_str, strclass,
     unorderable_list_difference
 )
 
 from unittest2.compatibility import wraps
 
def __exit__(self, exc_type, exc_value, tb):
         if not issubclass(exc_type, self.expected):
             # let unexpected exceptions pass through
             return False
         self.exception = exc_value  # store for later retrieval
         if self.expected_regexp is None:
             return True
 
         expected_regexp = self.expected_regexp
-        if isinstance(expected_regexp, six.string_types):
+        if isinstance(expected_regexp, str):
             expected_regexp = re.compile(expected_regexp)
         if not expected_regexp.search(str(exc_value)):
             raise self.failureException(
                 '"%s" does not match "%s"' %
                 (expected_regexp.pattern, str(exc_value)))
         return True
 
 
 class _TypeEqualityDict(object):
 
     def __init__(self, testcase):
         self.testcase = testcase
         self._store = {}
 
     def __setitem__(self, key, value):
         self._store[key] = value
 
     def __getitem__(self, key):
         value = self._store[key]
-        if isinstance(value, six.string_types):
+        if isinstance(value, str):
             return getattr(self.testcase, value)
         return value
 
     def get(self, key, default=None):
         if key in self._store:
             return self[key]
         return default
 
def __init__(self, methodName='runTest'):
         # instances of said type in more detail to generate a more useful
         # error message.
         self._type_equality_funcs = _TypeEqualityDict(self)
         self.addTypeEqualityFunc(dict, 'assertDictEqual')
         self.addTypeEqualityFunc(list, 'assertListEqual')
         self.addTypeEqualityFunc(tuple, 'assertTupleEqual')
         self.addTypeEqualityFunc(set, 'assertSetEqual')
         self.addTypeEqualityFunc(frozenset, 'assertSetEqual')
-        if six.PY2:
-            self.addTypeEqualityFunc(unicode, 'assertMultiLineEqual')
-        else:
-            self.addTypeEqualityFunc(str, 'assertMultiLineEqual')
 
     def addTypeEqualityFunc(self, typeobj, function):
         """Add a type specific assertEqual style function to compare a type.
 
         This method is for use by TestCase subclasses that need to register
         their own type equality functions to provide nicer error messages.
 
         Args:
def assertItemsEqual(self, expected_seq, actual_seq, msg=None):
             errors.append('Unexpected, but present:\n    %s' %
                           safe_repr(unexpected))
         if errors:
             standardMsg = '\n'.join(errors)
             self.fail(self._formatMessage(msg, standardMsg))
 
     def assertMultiLineEqual(self, first, second, msg=None):
         """Assert that two multi-line strings are equal."""
-        self.assert_(isinstance(first, six.string_types), (
+        self.assert_(isinstance(first, str), (
             'First argument is not a string'))
-        self.assert_(isinstance(second, six.string_types), (
+        self.assert_(isinstance(second, str), (
             'Second argument is not a string'))
 
         if first != second:
             standardMsg = '%s != %s' % (
                 safe_repr(first, True), safe_repr(second, True))
             diff = '\n' + ''.join(difflib.ndiff(first.splitlines(True),
                                                 second.splitlines(True)))
             standardMsg = self._truncateMessage(standardMsg, diff)
def assertRaisesRegexp(self, expected_exception, expected_regexp,
             kwargs: Extra kwargs.
         """
         if callable_obj is None:
             return _AssertRaisesContext(
                 expected_exception, self, expected_regexp)
         try:
             callable_obj(*args, **kwargs)
         except expected_exception as exc_value:
-            if isinstance(expected_regexp, six.string_types):
+            if isinstance(expected_regexp, str):
                 expected_regexp = re.compile(expected_regexp)
             if not expected_regexp.search(str(exc_value)):
                 raise self.failureException(
                     '"%s" does not match "%s"' %
                     (expected_regexp.pattern, str(exc_value)))
         else:
             if hasattr(expected_exception, '__name__'):
                 excName = expected_exception.__name__
             else:
                 excName = str(expected_exception)
             raise self.failureException("%s not raised" % excName)
 
     def assertRegexpMatches(self, text, expected_regexp, msg=None):
         """Fail the test unless the text matches the regular expression."""
-        if isinstance(expected_regexp, six.string_types):
+        if isinstance(expected_regexp, str):
             expected_regexp = re.compile(expected_regexp)
         if not expected_regexp.search(text):
             msg = msg or "Regexp didn't match"
             msg = '%s: %r not found in %r' % (
                 msg, expected_regexp.pattern, text)
             raise self.failureException(msg)
 
     def assertNotRegexpMatches(self, text, unexpected_regexp, msg=None):
         """Fail the test if the text matches the regular expression."""
-        if isinstance(unexpected_regexp, six.string_types):
+        if isinstance(unexpected_regexp, str):
             unexpected_regexp = re.compile(unexpected_regexp)
         match = unexpected_regexp.search(text)
         if match:
             msg = msg or "Regexp matched"
             msg = '%s: %r matches %r in %r' % (msg,
                                                text[match.start():match.end()],
                                                unexpected_regexp.pattern,
                                                text)

lldb/third_party/Python/module/unittest2/unittest2/main.py

 """Unittest main program"""
 
 import sys
 import os
 import types
-import six
 
 from unittest2 import loader, runner
 try:
     from unittest2.signals import installHandler
 except ImportError:
     installHandler = None
 
 __unittest = True
class TestProgram(object):
 
     # defaults for testing
     failfast = catchbreak = buffer = progName = None
 
     def __init__(self, module='__main__', defaultTest=None,
                  argv=None, testRunner=None,
                  testLoader=loader.defaultTestLoader, exit=True,
                  verbosity=1, failfast=None, catchbreak=None, buffer=None):
-        if isinstance(module, six.string_types):
+        if isinstance(module, str):
             self.module = __import__(module)
             for part in module.split('.')[1:]:
                 self.module = getattr(self.module, part)
         else:
             self.module = module
         if argv is None:
             argv = sys.argv
 

lldb/third_party/Python/module/unittest2/unittest2/result.py

 """Test result object"""
 
 import use_lldb_suite
 
+import io
 import sys
 import traceback
 import unittest
 
-from six import StringIO as SixStringIO
-
 from unittest2 import util
 from unittest2.compatibility import wraps
 
 __unittest = True
 
 
 def failfast(method):
     @wraps(method)
def __init__(self):
         self._mirrorOutput = False
 
     def startTest(self, test):
         "Called when the given test is about to be run"
         self.testsRun += 1
         self._mirrorOutput = False
         if self.buffer:
             if self._stderr_buffer is None:
-                self._stderr_buffer = SixStringIO()
-                self._stdout_buffer = SixStringIO()
+                self._stderr_buffer = io.StringIO()
+                self._stdout_buffer = io.StringIO()
             sys.stdout = self._stdout_buffer
             sys.stderr = self._stderr_buffer
 
     def startTestRun(self):
         """Called once before any tests are executed.
 
         See startTest for a method called before each test.
         """

lldb/third_party/Python/module/unittest2/unittest2/suite.py

 """TestSuite"""
 
 import sys
 import unittest
 from unittest2 import case, util
-import six
 
 __unittest = True
 
 
 class BaseTestSuite(unittest.TestSuite):
     """A simple test suite that doesn't provide class or module shared fixtures.
     """
 
def addTest(self, test):
             raise TypeError("%r is not callable" % (repr(test),))
         if isinstance(test, type) and issubclass(test,
                                                  (case.TestCase, TestSuite)):
             raise TypeError("TestCases and TestSuites must be instantiated "
                             "before passing them to addTest()")
         self._tests.append(test)
 
     def addTests(self, tests):
-        if isinstance(tests, six.string_types):
+        if isinstance(tests, str):
             raise TypeError("tests must be an iterable of tests, not a string")
         for test in tests:
             self.addTest(test)
 
     def run(self, result):
         for test in self:
             if result.shouldStop:
                 break

lldb/third_party/Python/module/unittest2/unittest2/test/test_case.py

 import difflib
 import pprint
 import re
-import six
 
 from copy import deepcopy
 
 import unittest2
 
 from unittest2.test.support import (
     OldTestResult, EqualityMixin, HashingMixin, LoggingResult
 )
class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin):
     # will be a string (either 8-byte or unicode -- again, because the docs
     # just say "string")
     def test_id(self):
         class Foo(unittest2.TestCase):
 
             def runTest(self):
                 pass
 
-        self.assertIsInstance(Foo().id(), six.string_types)
+        self.assertIsInstance(Foo().id(), str)
 
     # "If result is omitted or None, a temporary result object is created
     # and used, but is not made available to the caller. As TestCase owns the
     # temporary result startTestRun and stopTestRun are called.
 
     def test_run__uses_defaultTestResult(self):
         events = []
 

lldb/third_party/Python/module/unittest2/unittest2/test/test_functiontestcase.py

 import unittest2
-import six
 
 from unittest2.test.support import LoggingResult
 
 
 class Test_FunctionTestCase(unittest2.TestCase):
 
     # "Return the number of tests represented by the this test object. For
     # unittest2.TestCase instances, this will always be 1"
class Test_FunctionTestCase(unittest2.TestCase):
     #
     # Because of the vague nature of the docs, I'm not going to lock this
     # test down too much. Really all that can be asserted is that the id()
     # will be a string (either 8-byte or unicode -- again, because the docs
     # just say "string")
     def test_id(self):
         test = unittest2.FunctionTestCase(lambda: None)
 
-        self.assertIsInstance(test.id(), six.string_types)
+        self.assertIsInstance(test.id(), str)
 
     # "Returns a one-line description of the test, or None if no description
     # has been provided. The default implementation of this method returns
     # the first line of the test method's docstring, if available, or None."
     def test_shortDescription__no_docstring(self):
         test = unittest2.FunctionTestCase(lambda: None)
 
         self.assertEqual(test.shortDescription(), None)