[lldb][test] Remove vendored packages `unittest2` and `progress` (#82670)

The `unittest2` package is unused since
5b386158aacac4b41126983a5379d36ed413d0ea.

The `progress` package was only used internally by `unittest2`, so it
can be deleted as well.

30 files changed, 0 insertions, 8975 deletions

diff --git a/lldb/third_party/Python/module/progress/progress.py b/lldb/third_party/Python/module/progress/progress.py
deleted file mode 100644
index f844b98..0000000
--- a/lldb/third_party/Python/module/progress/progress.py
+++ /dev/null
@@ -1,181 +0,0 @@
-#!/usr/bin/env python
-
-import use_lldb_suite
-
-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 = 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=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
-        self.blank = blank
-        self.marker = marker
-        self.format = format
-        self.incremental = incremental
-        self.step = 100 / float(width)  # fix
-        self.reset()
-
-    def __add__(self, increment):
-        increment = self._get_progress(increment)
-        if 100 > self.progress + increment:
-            self.progress += increment
-        else:
-            self.progress = 100
-        return self
-
-    def complete(self):
-        self.progress = 100
-        return self
-
-    def __str__(self):
-        progressed = int(self.progress / self.step)  # fix
-        fill = progressed * self.fill
-        blank = (self.width - progressed) * self.blank
-        return self.format % {
-            'fill': fill,
-            'blank': blank,
-            'marker': self.marker,
-            'progress': int(
-                self.progress)}
-
-    __repr__ = __str__
-
-    def _get_progress(self, increment):
-        return float(increment * 100) / self.end
-
-    def reset(self):
-        """Resets the current progress to the start point"""
-        self.progress = self._get_progress(self.start)
-        return self
-
-
-class AnimatedProgressBar(ProgressBar):
-    """Extends ProgressBar to allow you to use it straighforward on a script.
-    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=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,
-            width,
-            fill,
-            blank,
-            marker,
-            format,
-            incremental)
-        self.stdout = stdout
-
-    def show_progress(self):
-        if hasattr(self.stdout, 'isatty') and self.stdout.isatty():
-            self.stdout.write('\r')
-        else:
-            self.stdout.write('\n')
-        self.stdout.write(str(self))
-        self.stdout.flush()
-
-
-class ProgressWithEvents(AnimatedProgressBar):
-    """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=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,
-            width,
-            fill,
-            blank,
-            marker,
-            format,
-            incremental,
-            stdout)
-        self.events = {}
-
-    def add_event(self, event):
-        if event in self.events:
-            self.events[event] += 1
-        else:
-            self.events[event] = 1
-
-    def show_progress(self):
-        isatty = hasattr(self.stdout, 'isatty') and self.stdout.isatty()
-        if isatty:
-            self.stdout.write('\r')
-        else:
-            self.stdout.write('\n')
-        self.stdout.write(str(self))
-        if len(self.events) == 0:
-            return
-        self.stdout.write('\n')
-        for key in list(self.events.keys()):
-            self.stdout.write(str(key) + ' = ' + str(self.events[key]) + ' ')
-        if isatty:
-            self.stdout.write('\033[1A')
-        self.stdout.flush()
-
-
-if __name__ == '__main__':
-    p = AnimatedProgressBar(end=200, width=200)
-
-    while True:
-        p + 5
-        p.show_progress()
-        time.sleep(0.3)
-        if p.progress == 100:
-            break
-    print()  # new line
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/__init__.py b/lldb/third_party/Python/module/unittest2/unittest2/__init__.py
deleted file mode 100644
index 14fea5a..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/__init__.py
+++ /dev/null
@@ -1,78 +0,0 @@
-"""
-unittest2
-
-unittest2 is a backport of the new features added to the unittest testing
-framework in Python 2.7. It is tested to run on Python 2.4 - 2.6.
-
-To use unittest2 instead of unittest simply replace ``import unittest`` with
-``import unittest2``.
-
-
-Copyright (c) 1999-2003 Steve Purcell
-Copyright (c) 2003-2010 Python Software Foundation
-This module is free software, and you may redistribute it and/or modify
-it under the same terms as Python itself, so long as this copyright message
-and disclaimer are retained in their original form.
-
-IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
-SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF
-THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGE.
-
-THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE.  THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS,
-AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
-SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
-"""
-
-import sys
-
-if sys.version_info[0] >= 3:
-    # Python 3 doesn't have the builtin `cmp` function anymore
-    cmp_ = lambda x, y: (x > y) - (x < y)
-else:
-    cmp_ = cmp
-
-reversed_cmp_ = lambda x, y: -cmp_(x, y)
-
-__all__ = ['TestResult', 'TestCase', 'TestSuite',
-           'TextTestRunner', 'TestLoader', 'FunctionTestCase', 'main',
-           'defaultTestLoader', 'SkipTest', 'skip', 'skipIf', 'skipUnless',
-           'expectedFailure', 'TextTestResult', '__version__', 'collector']
-
-__version__ = '0.5.1'
-
-# Expose obsolete functions for backwards compatibility
-__all__.extend(['getTestCaseNames', 'makeSuite', 'findTestCases'])
-
-
-from unittest2.collector import collector
-from unittest2.result import TestResult
-from unittest2.case import (
-    TestCase, FunctionTestCase, SkipTest, skip, skipIf,
-    skipUnless, expectedFailure
-)
-from unittest2.suite import BaseTestSuite, TestSuite
-from unittest2.loader import (
-    TestLoader, defaultTestLoader, makeSuite, getTestCaseNames,
-    findTestCases
-)
-from unittest2.main import TestProgram, main, main_
-from unittest2.runner import TextTestRunner, TextTestResult
-
-try:
-    from unittest2.signals import (
-        installHandler, registerResult, removeResult, removeHandler
-    )
-except ImportError:
-    # Compatibility with platforms that don't have the signal module
-    pass
-else:
-    __all__.extend(['installHandler', 'registerResult', 'removeResult',
-                    'removeHandler'])
-
-# deprecated
-_TextTestResult = TextTestResult
-
-__unittest = True
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/__main__.py b/lldb/third_party/Python/module/unittest2/unittest2/__main__.py
deleted file mode 100644
index 04ed982..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/__main__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""Main entry point"""
-
-import sys
-if sys.argv[0].endswith("__main__.py"):
-    sys.argv[0] = "unittest2"
-
-__unittest = True
-
-from unittest2.main import main_
-main_()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/case.py b/lldb/third_party/Python/module/unittest2/unittest2/case.py
deleted file mode 100644
index a24b9af..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/case.py
+++ /dev/null
@@ -1,1169 +0,0 @@
-"""Test case implementation"""
-
-import sys
-import difflib
-import pprint
-import re
-import unittest
-import warnings
-
-from unittest2 import result
-from unittest2.util import (
-    safe_repr, safe_str, strclass,
-    unorderable_list_difference
-)
-
-from unittest2.compatibility import wraps
-
-__unittest = True
-
-
-DIFF_OMITTED = ('\nDiff is %s characters long. '
-                'Set self.maxDiff to None to see it.')
-
-
-class SkipTest(Exception):
-    """
-    Raise this exception in a test to skip it.
-
-    Usually you can use TestResult.skip() or one of the skipping decorators
-    instead of raising this directly.
-    """
-
-
-class _ExpectedFailure(Exception):
-    """
-    Raise this when a test is expected to fail.
-
-    This is an implementation detail.
-    """
-
-    def __init__(self, exc_info, bugnumber=None):
-        # can't use super because Python 2.4 exceptions are old style
-        Exception.__init__(self)
-        self.exc_info = exc_info
-        self.bugnumber = bugnumber
-
-
-class _UnexpectedSuccess(Exception):
-    """
-    The test was supposed to fail, but it didn't!
-    """
-
-    def __init__(self, exc_info, bugnumber=None):
-        # can't use super because Python 2.4 exceptions are old style
-        Exception.__init__(self)
-        self.exc_info = exc_info
-        self.bugnumber = bugnumber
-
-
-def _id(obj):
-    return obj
-
-
-def skip(reason):
-    """
-    Unconditionally skip a test.
-    """
-    def decorator(test_item):
-        if not (
-            isinstance(
-                test_item,
-                type) and issubclass(
-                test_item,
-                TestCase)):
-            @wraps(test_item)
-            def skip_wrapper(*args, **kwargs):
-                raise SkipTest(reason)
-            test_item = skip_wrapper
-
-        test_item.__unittest_skip__ = True
-        test_item.__unittest_skip_why__ = reason
-        return test_item
-    return decorator
-
-
-def skipIf(condition, reason):
-    """
-    Skip a test if the condition is true.
-    """
-    if condition:
-        return skip(reason)
-    return _id
-
-
-def skipUnless(condition, reason):
-    """
-    Skip a test unless the condition is true.
-    """
-    if not condition:
-        return skip(reason)
-    return _id
-
-
-def expectedFailure(bugnumber=None):
-    if callable(bugnumber):
-        @wraps(bugnumber)
-        def expectedFailure_easy_wrapper(*args, **kwargs):
-            try:
-                bugnumber(*args, **kwargs)
-            except Exception:
-                raise _ExpectedFailure(sys.exc_info(), None)
-            raise _UnexpectedSuccess(sys.exc_info(), None)
-        return expectedFailure_easy_wrapper
-    else:
-        def expectedFailure_impl(func):
-            @wraps(func)
-            def wrapper(*args, **kwargs):
-                try:
-                    func(*args, **kwargs)
-                except Exception:
-                    raise _ExpectedFailure(sys.exc_info(), bugnumber)
-                raise _UnexpectedSuccess(sys.exc_info(), bugnumber)
-            return wrapper
-        return expectedFailure_impl
-
-
-class _AssertRaisesContext(object):
-    """A context manager used to implement TestCase.assertRaises* methods."""
-
-    def __init__(self, expected, test_case, expected_regexp=None):
-        self.expected = expected
-        self.failureException = test_case.failureException
-        self.expected_regexp = expected_regexp
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        if exc_type is None:
-            try:
-                exc_name = self.expected.__name__
-            except AttributeError:
-                exc_name = str(self.expected)
-            raise self.failureException(
-                "%s not raised" % (exc_name,))
-        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, 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, str):
-            return getattr(self.testcase, value)
-        return value
-
-    def get(self, key, default=None):
-        if key in self._store:
-            return self[key]
-        return default
-
-
-class TestCase(unittest.TestCase):
-    """A class whose instances are single test cases.
-
-    By default, the test code itself should be placed in a method named
-    'runTest'.
-
-    If the fixture may be used for many test cases, create as
-    many test methods as are needed. When instantiating such a TestCase
-    subclass, specify in the constructor arguments the name of the test method
-    that the instance is to execute.
-
-    Test authors should subclass TestCase for their own tests. Construction
-    and deconstruction of the test's environment ('fixture') can be
-    implemented by overriding the 'setUp' and 'tearDown' methods respectively.
-
-    If it is necessary to override the __init__ method, the base class
-    __init__ method must always be called. It is important that subclasses
-    should not change the signature of their __init__ method, since instances
-    of the classes are instantiated automatically by parts of the framework
-    in order to be run.
-    """
-
-    # This attribute determines which exception will be raised when
-    # the instance's assertion methods fail; test methods raising this
-    # exception will be deemed to have 'failed' rather than 'errored'
-
-    failureException = AssertionError
-
-    # This attribute sets the maximum length of a diff in failure messages
-    # by assert methods using difflib. It is looked up as an instance attribute
-    # so can be configured by individual tests if required.
-
-    maxDiff = 80 * 8
-
-    # This attribute determines whether long messages (including repr of
-    # objects used in assert methods) will be printed on failure in *addition*
-    # to any explicit message passed.
-
-    longMessage = True
-
-    # Attribute used by TestSuite for classSetUp
-
-    _classSetupFailed = False
-
-    def __init__(self, methodName='runTest'):
-        """Create an instance of the class that will use the named test
-           method when executed. Raises a ValueError if the instance does
-           not have a method with the specified name.
-        """
-        self._testMethodName = methodName
-        self._resultForDoCleanups = None
-        try:
-            testMethod = getattr(self, methodName)
-        except AttributeError:
-            raise ValueError("no such test method in %s: %s" %
-                             (self.__class__, methodName))
-        self._testMethodDoc = testMethod.__doc__
-        self._cleanups = []
-
-        # Map types to custom assertEqual functions that will compare
-        # 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')
-        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:
-            typeobj: The data type to call this function on when both values
-                    are of the same type in assertEqual().
-            function: The callable taking two arguments and an optional
-                    msg= argument that raises self.failureException with a
-                    useful error message when the two arguments are not equal.
-        """
-        self._type_equality_funcs[typeobj] = function
-
-    def addCleanup(self, function, *args, **kwargs):
-        """Add a function, with arguments, to be called when the test is
-        completed. Functions added are called on a LIFO basis and are
-        called after tearDown on test failure or success.
-
-        Cleanup items are called even if setUp fails (unlike tearDown)."""
-        self._cleanups.append((function, args, kwargs))
-
-    def setUp(self):
-        "Hook method for setting up the test fixture before exercising it."
-
-    @classmethod
-    def setUpClass(cls):
-        "Hook method for setting up class fixture before running tests in the class."
-
-    @classmethod
-    def tearDownClass(cls):
-        "Hook method for deconstructing the class fixture after running all tests in the class."
-
-    def tearDown(self):
-        "Hook method for deconstructing the test fixture after testing it."
-
-    def countTestCases(self):
-        return 1
-
-    def defaultTestResult(self):
-        return result.TestResult()
-
-    def shortDescription(self):
-        """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 specified test method's docstring.
-        """
-        doc = self._testMethodDoc
-        return doc and doc.split("\n")[0].strip() or None
-
-    def id(self):
-        return "%s.%s" % (strclass(self.__class__), self._testMethodName)
-
-    def __eq__(self, other):
-        if not isinstance(self, type(other)):
-            return NotImplemented
-
-        return self._testMethodName == other._testMethodName
-
-    def __ne__(self, other):
-        return not self == other
-
-    def __hash__(self):
-        return hash((type(self), self._testMethodName))
-
-    def __str__(self):
-        return "%s (%s)" % (self._testMethodName, strclass(self.__class__))
-
-    def __repr__(self):
-        return "<%s testMethod=%s>" % \
-               (strclass(self.__class__), self._testMethodName)
-
-    def _addSkip(self, result, reason):
-        addSkip = getattr(result, 'addSkip', None)
-        if addSkip is not None:
-            addSkip(self, reason)
-        else:
-            warnings.warn(
-                "Use of a TestResult without an addSkip method is deprecated",
-                DeprecationWarning,
-                2)
-            result.addSuccess(self)
-
-    def run(self, result=None):
-        orig_result = result
-        if result is None:
-            result = self.defaultTestResult()
-            startTestRun = getattr(result, 'startTestRun', None)
-            if startTestRun is not None:
-                startTestRun()
-
-        self._resultForDoCleanups = result
-        result.startTest(self)
-
-        testMethod = getattr(self, self._testMethodName)
-
-        if (getattr(self.__class__, "__unittest_skip__", False) or
-                getattr(testMethod, "__unittest_skip__", False)):
-            # If the class or method was skipped.
-            try:
-                skip_why = (
-                    getattr(
-                        self.__class__,
-                        '__unittest_skip_why__',
-                        '') or getattr(
-                        testMethod,
-                        '__unittest_skip_why__',
-                        ''))
-                self._addSkip(result, skip_why)
-            finally:
-                result.stopTest(self)
-            return
-        try:
-            success = False
-            try:
-                self.setUp()
-            except SkipTest as e:
-                self._addSkip(result, str(e))
-            except Exception:
-                result.addError(self, sys.exc_info())
-            else:
-                success = self.runMethod(testMethod, result)
-
-                try:
-                    self.tearDown()
-                except Exception:
-                    result.addCleanupError(self, sys.exc_info())
-                    success = False
-
-                self.dumpSessionInfo()
-
-            cleanUpSuccess = self.doCleanups()
-            success = success and cleanUpSuccess
-            if success:
-                result.addSuccess(self)
-        finally:
-            result.stopTest(self)
-            if orig_result is None:
-                stopTestRun = getattr(result, 'stopTestRun', None)
-                if stopTestRun is not None:
-                    stopTestRun()
-
-    def runMethod(self, testMethod, result):
-        """Runs the test method and catches any exception that might be thrown.
-
-        This is factored out of TestCase.run() to ensure that any exception
-        thrown during the test goes out of scope before tearDown.  Otherwise, an
-        exception could hold references to Python objects that are bound to
-        SB objects and prevent them from being deleted in time.
-        """
-        try:
-            testMethod()
-        except self.failureException:
-            result.addFailure(self, sys.exc_info())
-        except _ExpectedFailure as e:
-            addExpectedFailure = getattr(result, 'addExpectedFailure', None)
-            if addExpectedFailure is not None:
-                addExpectedFailure(self, e.exc_info, e.bugnumber)
-            else:
-                warnings.warn(
-                    "Use of a TestResult without an addExpectedFailure method is deprecated",
-                    DeprecationWarning)
-                result.addSuccess(self)
-        except _UnexpectedSuccess as x:
-            addUnexpectedSuccess = getattr(
-                result, 'addUnexpectedSuccess', None)
-            if addUnexpectedSuccess is not None:
-                addUnexpectedSuccess(self, x.bugnumber)
-            else:
-                warnings.warn(
-                    "Use of a TestResult without an addUnexpectedSuccess method is deprecated",
-                    DeprecationWarning)
-                result.addFailure(self, sys.exc_info())
-        except SkipTest as e:
-            self._addSkip(result, str(e))
-        except Exception:
-            result.addError(self, sys.exc_info())
-        else:
-            return True
-        return False
-
-    def doCleanups(self):
-        """Execute all cleanup functions. Normally called for you after
-        tearDown."""
-        result = self._resultForDoCleanups
-        ok = True
-        while self._cleanups:
-            function, args, kwargs = self._cleanups.pop(-1)
-            try:
-                function(*args, **kwargs)
-            except Exception:
-                ok = False
-                result.addError(self, sys.exc_info())
-        return ok
-
-    def __call__(self, *args, **kwds):
-        return self.run(*args, **kwds)
-
-    def debug(self):
-        """Run the test without collecting errors in a TestResult"""
-        self.setUp()
-        getattr(self, self._testMethodName)()
-        self.tearDown()
-        while self._cleanups:
-            function, args, kwargs = self._cleanups.pop(-1)
-            function(*args, **kwargs)
-
-    def skipTest(self, reason):
-        """Skip this test."""
-        raise SkipTest(reason)
-
-    def fail(self, msg=None):
-        """Fail immediately, with the given message."""
-        raise self.failureException(msg)
-
-    def assertFalse(self, expr, msg=None):
-        "Fail the test if the expression is true."
-        if expr:
-            msg = self._formatMessage(msg, "%s is not False" % safe_repr(expr))
-            raise self.failureException(msg)
-
-    def assertTrue(self, expr, msg=None):
-        """Fail the test unless the expression is true."""
-        if not expr:
-            msg = self._formatMessage(msg, "%s is not True" % safe_repr(expr))
-            raise self.failureException(msg)
-
-    def _formatMessage(self, msg, standardMsg):
-        """Honour the longMessage attribute when generating failure messages.
-        If longMessage is False this means:
-        * Use only an explicit message if it is provided
-        * Otherwise use the standard message for the assert
-
-        If longMessage is True:
-        * Use the standard message
-        * If an explicit message is provided, plus ' : ' and the explicit message
-        """
-        if not self.longMessage:
-            return msg or standardMsg
-        if msg is None:
-            return standardMsg
-        try:
-            return '%s : %s' % (standardMsg, msg)
-        except UnicodeDecodeError:
-            return '%s : %s' % (safe_str(standardMsg), safe_str(msg))
-
-    def assertRaises(self, excClass, callableObj=None, *args, **kwargs):
-        """Fail unless an exception of class excClass is thrown
-           by callableObj when invoked with arguments args and keyword
-           arguments kwargs. If a different type of exception is
-           thrown, it will not be caught, and the test case will be
-           deemed to have suffered an error, exactly as for an
-           unexpected exception.
-
-           If called with callableObj omitted or None, will return a
-           context object used like this::
-
-                with self.assertRaises(SomeException):
-                    do_something()
-
-           The context manager keeps a reference to the exception as
-           the 'exception' attribute. This allows you to inspect the
-           exception after the assertion::
-
-               with self.assertRaises(SomeException) as cm:
-                   do_something()
-               the_exception = cm.exception
-               self.assertEqual(the_exception.error_code, 3)
-        """
-        if callableObj is None:
-            return _AssertRaisesContext(excClass, self)
-        try:
-            callableObj(*args, **kwargs)
-        except excClass:
-            return
-
-        if hasattr(excClass, '__name__'):
-            excName = excClass.__name__
-        else:
-            excName = str(excClass)
-        raise self.failureException("%s not raised" % excName)
-
-    def _getAssertEqualityFunc(self, first, second):
-        """Get a detailed comparison function for the types of the two args.
-
-        Returns: A callable accepting (first, second, msg=None) that will
-        raise a failure exception if first != second with a useful human
-        readable error message for those types.
-        """
-        #
-        # NOTE(gregory.p.smith): I considered isinstance(first, type(second))
-        # and vice versa.  I opted for the conservative approach in case
-        # subclasses are not intended to be compared in detail to their super
-        # class instances using a type equality func.  This means testing
-        # subtypes won't automagically use the detailed comparison.  Callers
-        # should use their type specific assertSpamEqual method to compare
-        # subclasses if the detailed comparison is desired and appropriate.
-        # See the discussion in http://bugs.python.org/issue2578.
-        #
-        if isinstance(first, type(second)):
-            asserter = self._type_equality_funcs.get(type(first))
-            if asserter is not None:
-                return asserter
-
-        return self._baseAssertEqual
-
-    def _baseAssertEqual(self, first, second, msg=None):
-        """The default assertEqual implementation, not type specific."""
-        if not first == second:
-            standardMsg = '%s != %s' % (safe_repr(first), safe_repr(second))
-            msg = self._formatMessage(msg, standardMsg)
-            raise self.failureException(msg)
-
-    def assertEqual(self, first, second, msg=None):
-        """Fail if the two objects are unequal as determined by the '=='
-           operator.
-        """
-        assertion_func = self._getAssertEqualityFunc(first, second)
-        assertion_func(first, second, msg=msg)
-
-    def assertNotEqual(self, first, second, msg=None):
-        """Fail if the two objects are equal as determined by the '=='
-           operator.
-        """
-        if not first != second:
-            msg = self._formatMessage(msg, '%s == %s' % (safe_repr(first),
-                                                         safe_repr(second)))
-            raise self.failureException(msg)
-
-    def assertAlmostEqual(
-            self,
-            first,
-            second,
-            places=None,
-            msg=None,
-            delta=None):
-        """Fail if the two objects are unequal as determined by their
-           difference rounded to the given number of decimal places
-           (default 7) and comparing to zero, or by comparing that the
-           between the two objects is more than the given delta.
-
-           Note that decimal places (from zero) are usually not the same
-           as significant digits (measured from the most signficant digit).
-
-           If the two objects compare equal then they will automatically
-           compare almost equal.
-        """
-        if first == second:
-            # shortcut
-            return
-        if delta is not None and places is not None:
-            raise TypeError("specify delta or places not both")
-
-        if delta is not None:
-            if abs(first - second) <= delta:
-                return
-
-            standardMsg = '%s != %s within %s delta' % (safe_repr(first),
-                                                        safe_repr(second),
-                                                        safe_repr(delta))
-        else:
-            if places is None:
-                places = 7
-
-            if round(abs(second - first), places) == 0:
-                return
-
-            standardMsg = '%s != %s within %r places' % (safe_repr(first),
-                                                         safe_repr(second),
-                                                         places)
-        msg = self._formatMessage(msg, standardMsg)
-        raise self.failureException(msg)
-
-    def assertNotAlmostEqual(
-            self,
-            first,
-            second,
-            places=None,
-            msg=None,
-            delta=None):
-        """Fail if the two objects are equal as determined by their
-           difference rounded to the given number of decimal places
-           (default 7) and comparing to zero, or by comparing that the
-           between the two objects is less than the given delta.
-
-           Note that decimal places (from zero) are usually not the same
-           as significant digits (measured from the most signficant digit).
-
-           Objects that are equal automatically fail.
-        """
-        if delta is not None and places is not None:
-            raise TypeError("specify delta or places not both")
-        if delta is not None:
-            if not (first == second) and abs(first - second) > delta:
-                return
-            standardMsg = '%s == %s within %s delta' % (safe_repr(first),
-                                                        safe_repr(second),
-                                                        safe_repr(delta))
-        else:
-            if places is None:
-                places = 7
-            if not (first == second) and round(
-                    abs(second - first), places) != 0:
-                return
-            standardMsg = '%s == %s within %r places' % (safe_repr(first),
-                                                         safe_repr(second),
-                                                         places)
-
-        msg = self._formatMessage(msg, standardMsg)
-        raise self.failureException(msg)
-
-    # Synonyms for assertion methods
-
-    # The plurals are undocumented.  Keep them that way to discourage use.
-    # Do not add more.  Do not remove.
-    # Going through a deprecation cycle on these would annoy many people.
-    assertEquals = assertEqual
-    assertNotEquals = assertNotEqual
-    assertAlmostEquals = assertAlmostEqual
-    assertNotAlmostEquals = assertNotAlmostEqual
-    assert_ = assertTrue
-
-    # These fail* assertion method names are pending deprecation and will
-    # be a DeprecationWarning in 3.2; http://bugs.python.org/issue2578
-    def _deprecate(original_func):
-        def deprecated_func(*args, **kwargs):
-            warnings.warn(
-                ('Please use %s instead.' % original_func.__name__),
-                PendingDeprecationWarning, 2)
-            return original_func(*args, **kwargs)
-        return deprecated_func
-
-    failUnlessEqual = _deprecate(assertEqual)
-    failIfEqual = _deprecate(assertNotEqual)
-    failUnlessAlmostEqual = _deprecate(assertAlmostEqual)
-    failIfAlmostEqual = _deprecate(assertNotAlmostEqual)
-    failUnless = _deprecate(assertTrue)
-    failUnlessRaises = _deprecate(assertRaises)
-    failIf = _deprecate(assertFalse)
-
-    def assertSequenceEqual(self, seq1, seq2,
-                            msg=None, seq_type=None, max_diff=80 * 8):
-        """An equality assertion for ordered sequences (like lists and tuples).
-
-        For the purposes of this function, a valid ordered sequence type is one
-        which can be indexed, has a length, and has an equality operator.
-
-        Args:
-            seq1: The first sequence to compare.
-            seq2: The second sequence to compare.
-            seq_type: The expected datatype of the sequences, or None if no
-                    datatype should be enforced.
-            msg: Optional message to use on failure instead of a list of
-                    differences.
-            max_diff: Maximum size off the diff, larger diffs are not shown
-        """
-        if seq_type is not None:
-            seq_type_name = seq_type.__name__
-            if not isinstance(seq1, seq_type):
-                raise self.failureException('First sequence is not a %s: %s'
-                                            % (seq_type_name, safe_repr(seq1)))
-            if not isinstance(seq2, seq_type):
-                raise self.failureException('Second sequence is not a %s: %s'
-                                            % (seq_type_name, safe_repr(seq2)))
-        else:
-            seq_type_name = "sequence"
-
-        differing = None
-        try:
-            len1 = len(seq1)
-        except (TypeError, NotImplementedError):
-            differing = 'First %s has no length.    Non-sequence?' % (
-                seq_type_name)
-
-        if differing is None:
-            try:
-                len2 = len(seq2)
-            except (TypeError, NotImplementedError):
-                differing = 'Second %s has no length.    Non-sequence?' % (
-                    seq_type_name)
-
-        if differing is None:
-            if seq1 == seq2:
-                return
-
-            seq1_repr = repr(seq1)
-            seq2_repr = repr(seq2)
-            if len(seq1_repr) > 30:
-                seq1_repr = seq1_repr[:30] + '...'
-            if len(seq2_repr) > 30:
-                seq2_repr = seq2_repr[:30] + '...'
-            elements = (seq_type_name.capitalize(), seq1_repr, seq2_repr)
-            differing = '%ss differ: %s != %s\n' % elements
-
-            for i in range(min(len1, len2)):
-                try:
-                    item1 = seq1[i]
-                except (TypeError, IndexError, NotImplementedError):
-                    differing += ('\nUnable to index element %d of first %s\n' %
-                                  (i, seq_type_name))
-                    break
-
-                try:
-                    item2 = seq2[i]
-                except (TypeError, IndexError, NotImplementedError):
-                    differing += ('\nUnable to index element %d of second %s\n' %
-                                  (i, seq_type_name))
-                    break
-
-                if item1 != item2:
-                    differing += ('\nFirst differing element %d:\n%s\n%s\n' %
-                                  (i, item1, item2))
-                    break
-            else:
-                if (len1 == len2 and seq_type is None and
-                        not isinstance(seq1, type(seq2))):
-                    # The sequences are the same, but have differing types.
-                    return
-
-            if len1 > len2:
-                differing += ('\nFirst %s contains %d additional '
-                              'elements.\n' % (seq_type_name, len1 - len2))
-                try:
-                    differing += ('First extra element %d:\n%s\n' %
-                                  (len2, seq1[len2]))
-                except (TypeError, IndexError, NotImplementedError):
-                    differing += ('Unable to index element %d '
-                                  'of first %s\n' % (len2, seq_type_name))
-            elif len1 < len2:
-                differing += ('\nSecond %s contains %d additional '
-                              'elements.\n' % (seq_type_name, len2 - len1))
-                try:
-                    differing += ('First extra element %d:\n%s\n' %
-                                  (len1, seq2[len1]))
-                except (TypeError, IndexError, NotImplementedError):
-                    differing += ('Unable to index element %d '
-                                  'of second %s\n' % (len1, seq_type_name))
-        standardMsg = differing
-        diffMsg = '\n' + '\n'.join(
-            difflib.ndiff(pprint.pformat(seq1).splitlines(),
-                          pprint.pformat(seq2).splitlines()))
-
-        standardMsg = self._truncateMessage(standardMsg, diffMsg)
-        msg = self._formatMessage(msg, standardMsg)
-        self.fail(msg)
-
-    def _truncateMessage(self, message, diff):
-        max_diff = self.maxDiff
-        if max_diff is None or len(diff) <= max_diff:
-            return message + diff
-        return message + (DIFF_OMITTED % len(diff))
-
-    def assertListEqual(self, list1, list2, msg=None):
-        """A list-specific equality assertion.
-
-        Args:
-            list1: The first list to compare.
-            list2: The second list to compare.
-            msg: Optional message to use on failure instead of a list of
-                    differences.
-
-        """
-        self.assertSequenceEqual(list1, list2, msg, seq_type=list)
-
-    def assertTupleEqual(self, tuple1, tuple2, msg=None):
-        """A tuple-specific equality assertion.
-
-        Args:
-            tuple1: The first tuple to compare.
-            tuple2: The second tuple to compare.
-            msg: Optional message to use on failure instead of a list of
-                    differences.
-        """
-        self.assertSequenceEqual(tuple1, tuple2, msg, seq_type=tuple)
-
-    def assertSetEqual(self, set1, set2, msg=None):
-        """A set-specific equality assertion.
-
-        Args:
-            set1: The first set to compare.
-            set2: The second set to compare.
-            msg: Optional message to use on failure instead of a list of
-                    differences.
-
-        assertSetEqual uses ducktyping to support
-        different types of sets, and is optimized for sets specifically
-        (parameters must support a difference method).
-        """
-        try:
-            difference1 = set1.difference(set2)
-        except TypeError as e:
-            self.fail('invalid type when attempting set difference: %s' % e)
-        except AttributeError as e:
-            self.fail('first argument does not support set difference: %s' % e)
-
-        try:
-            difference2 = set2.difference(set1)
-        except TypeError as e:
-            self.fail('invalid type when attempting set difference: %s' % e)
-        except AttributeError as e:
-            self.fail(
-                'second argument does not support set difference: %s' %
-                e)
-
-        if not (difference1 or difference2):
-            return
-
-        lines = []
-        if difference1:
-            lines.append('Items in the first set but not the second:')
-            for item in difference1:
-                lines.append(repr(item))
-        if difference2:
-            lines.append('Items in the second set but not the first:')
-            for item in difference2:
-                lines.append(repr(item))
-
-        standardMsg = '\n'.join(lines)
-        self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertIn(self, member, container, msg=None):
-        """Just like self.assertTrue(a in b), but with a nicer default message."""
-        if member not in container:
-            standardMsg = '%s not found in %s' % (safe_repr(member),
-                                                  safe_repr(container))
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertNotIn(self, member, container, msg=None):
-        """Just like self.assertTrue(a not in b), but with a nicer default message."""
-        if member in container:
-            standardMsg = '%s unexpectedly found in %s' % (
-                safe_repr(member), safe_repr(container))
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertIs(self, expr1, expr2, msg=None):
-        """Just like self.assertTrue(a is b), but with a nicer default message."""
-        if expr1 is not expr2:
-            standardMsg = '%s is not %s' % (safe_repr(expr1), safe_repr(expr2))
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertIsNot(self, expr1, expr2, msg=None):
-        """Just like self.assertTrue(a is not b), but with a nicer default message."""
-        if expr1 is expr2:
-            standardMsg = 'unexpectedly identical: %s' % (safe_repr(expr1),)
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertDictEqual(self, d1, d2, msg=None):
-        self.assert_(
-            isinstance(
-                d1,
-                dict),
-            'First argument is not a dictionary')
-        self.assert_(
-            isinstance(
-                d2,
-                dict),
-            'Second argument is not a dictionary')
-
-        if d1 != d2:
-            standardMsg = '%s != %s' % (
-                safe_repr(d1, True), safe_repr(d2, True))
-            diff = ('\n' + '\n'.join(difflib.ndiff(
-                           pprint.pformat(d1).splitlines(),
-                           pprint.pformat(d2).splitlines())))
-            standardMsg = self._truncateMessage(standardMsg, diff)
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertDictContainsSubset(self, expected, actual, msg=None):
-        """Checks whether actual is a superset of expected."""
-        missing = []
-        mismatched = []
-        for key, value in expected.iteritems():
-            if key not in actual:
-                missing.append(key)
-            elif value != actual[key]:
-                mismatched.append('%s, expected: %s, actual: %s' %
-                                  (safe_repr(key), safe_repr(value),
-                                   safe_repr(actual[key])))
-
-        if not (missing or mismatched):
-            return
-
-        standardMsg = ''
-        if missing:
-            standardMsg = 'Missing: %s' % ','.join(safe_repr(m) for m in
-                                                   missing)
-        if mismatched:
-            if standardMsg:
-                standardMsg += '; '
-            standardMsg += 'Mismatched values: %s' % ','.join(mismatched)
-
-        self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertItemsEqual(self, expected_seq, actual_seq, msg=None):
-        """An unordered sequence specific comparison. It asserts that
-        expected_seq and actual_seq contain the same elements. It is
-        the equivalent of::
-
-            self.assertEqual(sorted(expected_seq), sorted(actual_seq))
-
-        Raises with an error message listing which elements of expected_seq
-        are missing from actual_seq and vice versa if any.
-
-        Asserts that each element has the same count in both sequences.
-        Example:
-            - [0, 1, 1] and [1, 0, 1] compare equal.
-            - [0, 0, 1] and [0, 1] compare unequal.
-        """
-        try:
-            expected = sorted(expected_seq)
-            actual = sorted(actual_seq)
-        except TypeError:
-            # Unsortable items (example: set(), complex(), ...)
-            expected = list(expected_seq)
-            actual = list(actual_seq)
-            missing, unexpected = unorderable_list_difference(
-                expected, actual, ignore_duplicate=False
-            )
-        else:
-            return self.assertSequenceEqual(expected, actual, msg=msg)
-
-        errors = []
-        if missing:
-            errors.append('Expected, but missing:\n    %s' %
-                          safe_repr(missing))
-        if unexpected:
-            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, str), (
-            'First argument is not a string'))
-        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)
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertLess(self, a, b, msg=None):
-        """Just like self.assertTrue(a < b), but with a nicer default message."""
-        if not a < b:
-            standardMsg = '%s not less than %s' % (safe_repr(a), safe_repr(b))
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertLessEqual(self, a, b, msg=None):
-        """Just like self.assertTrue(a <= b), but with a nicer default message."""
-        if not a <= b:
-            standardMsg = '%s not less than or equal to %s' % (
-                safe_repr(a), safe_repr(b))
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertGreater(self, a, b, msg=None):
-        """Just like self.assertTrue(a > b), but with a nicer default message."""
-        if not a > b:
-            standardMsg = '%s not greater than %s' % (
-                safe_repr(a), safe_repr(b))
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertGreaterEqual(self, a, b, msg=None):
-        """Just like self.assertTrue(a >= b), but with a nicer default message."""
-        if not a >= b:
-            standardMsg = '%s not greater than or equal to %s' % (
-                safe_repr(a), safe_repr(b))
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertIsNone(self, obj, msg=None):
-        """Same as self.assertTrue(obj is None), with a nicer default message."""
-        if obj is not None:
-            standardMsg = '%s is not None' % (safe_repr(obj),)
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertIsNotNone(self, obj, msg=None):
-        """Included for symmetry with assertIsNone."""
-        if obj is None:
-            standardMsg = 'unexpectedly None'
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertIsInstance(self, obj, cls, msg=None):
-        """Same as self.assertTrue(isinstance(obj, cls)), with a nicer
-        default message."""
-        if not isinstance(obj, cls):
-            standardMsg = '%s is not an instance of %r' % (safe_repr(obj), cls)
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertNotIsInstance(self, obj, cls, msg=None):
-        """Included for symmetry with assertIsInstance."""
-        if isinstance(obj, cls):
-            standardMsg = '%s is an instance of %r' % (safe_repr(obj), cls)
-            self.fail(self._formatMessage(msg, standardMsg))
-
-    def assertRaisesRegexp(self, expected_exception, expected_regexp,
-                           callable_obj=None, *args, **kwargs):
-        """Asserts that the message in a raised exception matches a regexp.
-
-        Args:
-            expected_exception: Exception class expected to be raised.
-            expected_regexp: Regexp (re pattern object or string) expected
-                    to be found in error message.
-            callable_obj: Function to be called.
-            args: Extra args.
-            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, 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, 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, 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)
-            raise self.failureException(msg)
-
-
-class FunctionTestCase(TestCase):
-    """A test case that wraps a test function.
-
-    This is useful for slipping pre-existing test functions into the
-    unittest framework. Optionally, set-up and tidy-up functions can be
-    supplied. As with TestCase, the tidy-up ('tearDown') function will
-    always be called if the set-up ('setUp') function ran successfully.
-    """
-
-    def __init__(self, testFunc, setUp=None, tearDown=None, description=None):
-        super(FunctionTestCase, self).__init__()
-        self._setUpFunc = setUp
-        self._tearDownFunc = tearDown
-        self._testFunc = testFunc
-        self._description = description
-
-    def setUp(self):
-        if self._setUpFunc is not None:
-            self._setUpFunc()
-
-    def tearDown(self):
-        if self._tearDownFunc is not None:
-            self._tearDownFunc()
-
-    def runTest(self):
-        self._testFunc()
-
-    def id(self):
-        return self._testFunc.__name__
-
-    def __eq__(self, other):
-        if not isinstance(other, self.__class__):
-            return NotImplemented
-
-        return self._setUpFunc == other._setUpFunc and \
-            self._tearDownFunc == other._tearDownFunc and \
-            self._testFunc == other._testFunc and \
-            self._description == other._description
-
-    def __ne__(self, other):
-        return not self == other
-
-    def __hash__(self):
-        return hash((type(self), self._setUpFunc, self._tearDownFunc,
-                     self._testFunc, self._description))
-
-    def __str__(self):
-        return "%s (%s)" % (strclass(self.__class__),
-                            self._testFunc.__name__)
-
-    def __repr__(self):
-        return "<%s testFunc=%s>" % (strclass(self.__class__),
-                                     self._testFunc)
-
-    def shortDescription(self):
-        if self._description is not None:
-            return self._description
-        doc = self._testFunc.__doc__
-        return doc and doc.split("\n")[0].strip() or None
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/collector.py b/lldb/third_party/Python/module/unittest2/unittest2/collector.py
deleted file mode 100644
index b9013e8..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/collector.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import os
-import sys
-from unittest2.loader import defaultTestLoader
-
-
-def collector():
-    # import __main__ triggers code re-execution
-    __main__ = sys.modules['__main__']
-    setupDir = os.path.abspath(os.path.dirname(__main__.__file__))
-    return defaultTestLoader.discover(setupDir)
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/compatibility.py b/lldb/third_party/Python/module/unittest2/unittest2/compatibility.py
deleted file mode 100644
index 3adcdc4..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/compatibility.py
+++ /dev/null
@@ -1,67 +0,0 @@
-import os
-import sys
-
-try:
-    from functools import wraps
-except ImportError:
-    # only needed for Python 2.4
-    def wraps(_):
-        def _wraps(func):
-            return func
-        return _wraps
-
-__unittest = True
-
-
-def _relpath_nt(path, start=os.path.curdir):
-    """Return a relative version of a path"""
-
-    if not path:
-        raise ValueError("no path specified")
-    start_list = os.path.abspath(start).split(os.path.sep)
-    path_list = os.path.abspath(path).split(os.path.sep)
-    if start_list[0].lower() != path_list[0].lower():
-        unc_path, rest = os.path.splitunc(path)
-        unc_start, rest = os.path.splitunc(start)
-        if bool(unc_path) ^ bool(unc_start):
-            raise ValueError("Cannot mix UNC and non-UNC paths (%s and %s)"
-                             % (path, start))
-        else:
-            raise ValueError("path is on drive %s, start on drive %s"
-                             % (path_list[0], start_list[0]))
-    # Work out how much of the filepath is shared by start and path.
-    for i in range(min(len(start_list), len(path_list))):
-        if start_list[i].lower() != path_list[i].lower():
-            break
-    else:
-        i += 1
-
-    rel_list = [os.path.pardir] * (len(start_list) - i) + path_list[i:]
-    if not rel_list:
-        return os.path.curdir
-    return os.path.join(*rel_list)
-
-# default to posixpath definition
-
-
-def _relpath_posix(path, start=os.path.curdir):
-    """Return a relative version of a path"""
-
-    if not path:
-        raise ValueError("no path specified")
-
-    start_list = os.path.abspath(start).split(os.path.sep)
-    path_list = os.path.abspath(path).split(os.path.sep)
-
-    # Work out how much of the filepath is shared by start and path.
-    i = len(os.path.commonprefix([start_list, path_list]))
-
-    rel_list = [os.path.pardir] * (len(start_list) - i) + path_list[i:]
-    if not rel_list:
-        return os.path.curdir
-    return os.path.join(*rel_list)
-
-if os.path is sys.modules.get('ntpath'):
-    relpath = _relpath_nt
-else:
-    relpath = _relpath_posix
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/loader.py b/lldb/third_party/Python/module/unittest2/unittest2/loader.py
deleted file mode 100644
index 87edddc..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/loader.py
+++ /dev/null
@@ -1,339 +0,0 @@
-"""Loading unittests."""
-
-import functools
-import os
-import re
-import sys
-import traceback
-import types
-import unittest
-
-from fnmatch import fnmatch
-
-from unittest2 import case, suite, cmp_
-
-try:
-    from os.path import relpath
-except ImportError:
-    from unittest2.compatibility import relpath
-
-__unittest = True
-
-# what about .pyc or .pyo (etc)
-# we would need to avoid loading the same tests multiple times
-# from '.py', '.pyc' *and* '.pyo'
-VALID_MODULE_NAME = re.compile(r'[_a-z]\w*\.py$', re.IGNORECASE)
-
-
-def _make_failed_import_test(name, suiteClass):
-    message = 'Failed to import test module: %s' % name
-    if hasattr(traceback, 'format_exc'):
-        # Python 2.3 compatibility
-        # format_exc returns two frames of discover.py as well
-        message += '\n%s' % traceback.format_exc()
-    return _make_failed_test('ModuleImportFailure', name, ImportError(message),
-                             suiteClass)
-
-
-def _make_failed_load_tests(name, exception, suiteClass):
-    return _make_failed_test('LoadTestsFailure', name, exception, suiteClass)
-
-
-def _make_failed_test(classname, methodname, exception, suiteClass):
-    def testFailure(self):
-        raise exception
-    attrs = {methodname: testFailure}
-    TestClass = type(classname, (case.TestCase,), attrs)
-    return suiteClass((TestClass(methodname),))
-
-
-class TestLoader(unittest.TestLoader):
-    """
-    This class is responsible for loading tests according to various criteria
-    and returning them wrapped in a TestSuite
-    """
-
-    def __init__(self):
-        self.testMethodPrefix = 'test'
-        self.sortTestMethodsUsing = cmp_
-        self.suiteClass = suite.TestSuite
-        self._top_level_dir = None
-
-    def loadTestsFromTestCase(self, testCaseClass):
-        """Return a suite of all tests cases contained in testCaseClass"""
-        if issubclass(testCaseClass, suite.TestSuite):
-            raise TypeError("Test cases should not be derived from TestSuite."
-                            " Maybe you meant to derive from TestCase?")
-        testCaseNames = self.getTestCaseNames(testCaseClass)
-        if not testCaseNames and hasattr(testCaseClass, 'runTest'):
-            testCaseNames = ['runTest']
-        loaded_suite = self.suiteClass(map(testCaseClass, testCaseNames))
-        return loaded_suite
-
-    def loadTestsFromModule(self, module, use_load_tests=True):
-        """Return a suite of all tests cases contained in the given module"""
-        tests = []
-        for name in dir(module):
-            obj = getattr(module, name)
-            if isinstance(obj, type) and issubclass(obj, unittest.TestCase):
-                tests.append(self.loadTestsFromTestCase(obj))
-
-        load_tests = getattr(module, 'load_tests', None)
-        tests = self.suiteClass(tests)
-        if use_load_tests and load_tests is not None:
-            try:
-                return load_tests(self, tests, None)
-            except Exception as e:
-                return _make_failed_load_tests(module.__name__, e,
-                                               self.suiteClass)
-        return tests
-
-    def loadTestsFromName(self, name, module=None):
-        """Return a suite of all tests cases given a string specifier.
-
-        The name may resolve either to a module, a test case class, a
-        test method within a test case class, or a callable object which
-        returns a TestCase or TestSuite instance.
-
-        The method optionally resolves the names relative to a given module.
-        """
-        parts = name.split('.')
-        if module is None:
-            parts_copy = parts[:]
-            while parts_copy:
-                try:
-                    module = __import__('.'.join(parts_copy))
-                    break
-                except ImportError:
-                    del parts_copy[-1]
-                    if not parts_copy:
-                        raise
-            parts = parts[1:]
-        obj = module
-        for part in parts:
-            parent, obj = obj, getattr(obj, part)
-
-        if isinstance(obj, types.ModuleType):
-            return self.loadTestsFromModule(obj)
-        elif isinstance(obj, type) and issubclass(obj, unittest.TestCase):
-            return self.loadTestsFromTestCase(obj)
-        elif (isinstance(obj, (types.MethodType, types.FunctionType)) and
-              isinstance(parent, type) and
-              issubclass(parent, case.TestCase)):
-            return self.suiteClass([parent(obj.__name__)])
-        elif isinstance(obj, unittest.TestSuite):
-            return obj
-        elif hasattr(obj, '__call__'):
-            test = obj()
-            if isinstance(test, unittest.TestSuite):
-                return test
-            elif isinstance(test, unittest.TestCase):
-                return self.suiteClass([test])
-            else:
-                raise TypeError("calling %s returned %s, not a test" %
-                                (obj, test))
-        else:
-            raise TypeError("don't know how to make test from: %s" % obj)
-
-    def loadTestsFromNames(self, names, module=None):
-        """Return a suite of all tests cases found using the given sequence
-        of string specifiers. See 'loadTestsFromName()'.
-        """
-        suites = [self.loadTestsFromName(name, module) for name in names]
-        return self.suiteClass(suites)
-
-    def getTestCaseNames(self, testCaseClass):
-        """Return a sorted sequence of method names found within testCaseClass
-        """
-        def isTestMethod(attrname, testCaseClass=testCaseClass,
-                         prefix=self.testMethodPrefix):
-            return attrname.startswith(prefix) and \
-                hasattr(getattr(testCaseClass, attrname), '__call__')
-        testFnNames = list(filter(isTestMethod, dir(testCaseClass)))
-        if self.sortTestMethodsUsing:
-            testFnNames.sort(
-                key=functools.cmp_to_key(
-                    self.sortTestMethodsUsing))
-        return testFnNames
-
-    def discover(self, start_dir, pattern='test*.py', top_level_dir=None):
-        """Find and return all test modules from the specified start
-        directory, recursing into subdirectories to find them. Only test files
-        that match the pattern will be loaded. (Using shell style pattern
-        matching.)
-
-        All test modules must be importable from the top level of the project.
-        If the start directory is not the top level directory then the top
-        level directory must be specified separately.
-
-        If a test package name (directory with '__init__.py') matches the
-        pattern then the package will be checked for a 'load_tests' function. If
-        this exists then it will be called with loader, tests, pattern.
-
-        If load_tests exists then discovery does  *not* recurse into the package,
-        load_tests is responsible for loading all tests in the package.
-
-        The pattern is deliberately not stored as a loader attribute so that
-        packages can continue discovery themselves. top_level_dir is stored so
-        load_tests does not need to pass this argument in to loader.discover().
-        """
-        set_implicit_top = False
-        if top_level_dir is None and self._top_level_dir is not None:
-            # make top_level_dir optional if called from load_tests in a
-            # package
-            top_level_dir = self._top_level_dir
-        elif top_level_dir is None:
-            set_implicit_top = True
-            top_level_dir = start_dir
-
-        top_level_dir = os.path.abspath(top_level_dir)
-
-        if top_level_dir not in sys.path:
-            # all test modules must be importable from the top level directory
-            # should we *unconditionally* put the start directory in first
-            # in sys.path to minimise likelihood of conflicts between installed
-            # modules and development versions?
-            sys.path.insert(0, top_level_dir)
-        self._top_level_dir = top_level_dir
-
-        is_not_importable = False
-        if os.path.isdir(os.path.abspath(start_dir)):
-            start_dir = os.path.abspath(start_dir)
-            if start_dir != top_level_dir:
-                is_not_importable = not os.path.isfile(
-                    os.path.join(start_dir, '__init__.py'))
-        else:
-            # support for discovery from dotted module names
-            try:
-                __import__(start_dir)
-            except ImportError:
-                is_not_importable = True
-            else:
-                the_module = sys.modules[start_dir]
-                top_part = start_dir.split('.')[0]
-                start_dir = os.path.abspath(
-                    os.path.dirname((the_module.__file__)))
-                if set_implicit_top:
-                    self._top_level_dir = os.path.abspath(os.path.dirname(
-                        os.path.dirname(sys.modules[top_part].__file__)))
-                    sys.path.remove(top_level_dir)
-
-        if is_not_importable:
-            raise ImportError(
-                'Start directory is not importable: %r' %
-                start_dir)
-
-        tests = list(self._find_tests(start_dir, pattern))
-        return self.suiteClass(tests)
-
-    def _get_name_from_path(self, path):
-        path = os.path.splitext(os.path.normpath(path))[0]
-
-        _relpath = relpath(path, self._top_level_dir)
-        assert not os.path.isabs(_relpath), "Path must be within the project"
-        assert not _relpath.startswith('..'), "Path must be within the project"
-
-        name = _relpath.replace(os.path.sep, '.')
-        return name
-
-    def _get_module_from_name(self, name):
-        __import__(name)
-        return sys.modules[name]
-
-    def _match_path(self, path, full_path, pattern):
-        # override this method to use alternative matching strategy
-        return fnmatch(path, pattern)
-
-    def _find_tests(self, start_dir, pattern):
-        """Used by discovery. Yields test suites it loads."""
-        paths = os.listdir(start_dir)
-
-        for path in paths:
-            full_path = os.path.join(start_dir, path)
-            if os.path.isfile(full_path):
-                if not VALID_MODULE_NAME.match(path):
-                    # valid Python identifiers only
-                    continue
-                if not self._match_path(path, full_path, pattern):
-                    continue
-                # if the test file matches, load it
-                name = self._get_name_from_path(full_path)
-                try:
-                    module = self._get_module_from_name(name)
-                except:
-                    yield _make_failed_import_test(name, self.suiteClass)
-                else:
-                    mod_file = os.path.abspath(
-                        getattr(module, '__file__', full_path))
-                    realpath = os.path.splitext(mod_file)[0]
-                    fullpath_noext = os.path.splitext(full_path)[0]
-                    if realpath.lower() != fullpath_noext.lower():
-                        module_dir = os.path.dirname(realpath)
-                        mod_name = os.path.splitext(
-                            os.path.basename(full_path))[0]
-                        expected_dir = os.path.dirname(full_path)
-                        msg = (
-                            "%r module incorrectly imported from %r. Expected %r. "
-                            "Is this module globally installed?")
-                        raise ImportError(msg %
-                                          (mod_name, module_dir, expected_dir))
-                    yield self.loadTestsFromModule(module)
-            elif os.path.isdir(full_path):
-                if not os.path.isfile(os.path.join(full_path, '__init__.py')):
-                    continue
-
-                load_tests = None
-                tests = None
-                if fnmatch(path, pattern):
-                    # only check load_tests if the package directory itself
-                    # matches the filter
-                    name = self._get_name_from_path(full_path)
-                    package = self._get_module_from_name(name)
-                    load_tests = getattr(package, 'load_tests', None)
-                    tests = self.loadTestsFromModule(
-                        package, use_load_tests=False)
-
-                if load_tests is None:
-                    if tests is not None:
-                        # tests loaded from package file
-                        yield tests
-                    # recurse into the package
-                    for test in self._find_tests(full_path, pattern):
-                        yield test
-                else:
-                    try:
-                        yield load_tests(self, tests, pattern)
-                    except Exception as e:
-                        yield _make_failed_load_tests(package.__name__, e,
-                                                      self.suiteClass)
-
-defaultTestLoader = TestLoader()
-
-
-def _makeLoader(prefix, sortUsing, suiteClass=None):
-    loader = TestLoader()
-    loader.sortTestMethodsUsing = sortUsing
-    loader.testMethodPrefix = prefix
-    if suiteClass:
-        loader.suiteClass = suiteClass
-    return loader
-
-
-def getTestCaseNames(testCaseClass, prefix, sortUsing=cmp_):
-    return _makeLoader(prefix, sortUsing).getTestCaseNames(testCaseClass)
-
-
-def makeSuite(testCaseClass, prefix='test', sortUsing=cmp_,
-              suiteClass=suite.TestSuite):
-    return _makeLoader(
-        prefix,
-        sortUsing,
-        suiteClass).loadTestsFromTestCase(testCaseClass)
-
-
-def findTestCases(module, prefix='test', sortUsing=cmp_,
-                  suiteClass=suite.TestSuite):
-    return _makeLoader(
-        prefix,
-        sortUsing,
-        suiteClass).loadTestsFromModule(module)
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/main.py b/lldb/third_party/Python/module/unittest2/unittest2/main.py
deleted file mode 100644
index 0d3c5b8..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/main.py
+++ /dev/null
@@ -1,257 +0,0 @@
-"""Unittest main program"""
-
-import sys
-import os
-import types
-
-from unittest2 import loader, runner
-try:
-    from unittest2.signals import installHandler
-except ImportError:
-    installHandler = None
-
-__unittest = True
-
-FAILFAST = "  -f, --failfast   Stop on first failure\n"
-CATCHBREAK = "  -c, --catch      Catch control-C and display results\n"
-BUFFEROUTPUT = "  -b, --buffer     Buffer stdout and stderr during test runs\n"
-
-USAGE_AS_MAIN = """\
-Usage: %(progName)s [options] [tests]
-
-Options:
-  -h, --help       Show this message
-  -v, --verbose    Verbose output
-  -q, --quiet      Minimal output
-%(failfast)s%(catchbreak)s%(buffer)s
-Examples:
-  %(progName)s test_module                       - run tests from test_module
-  %(progName)s test_module.TestClass             - run tests from
-                                                   test_module.TestClass
-  %(progName)s test_module.TestClass.test_method - run specified test method
-
-[tests] can be a list of any number of test modules, classes and test
-methods.
-
-Alternative Usage: %(progName)s discover [options]
-
-Options:
-  -v, --verbose    Verbose output
-%(failfast)s%(catchbreak)s%(buffer)s  -s directory     Directory to start discovery ('.' default)
-  -p pattern       Pattern to match test files ('test*.py' default)
-  -t directory     Top level directory of project (default to
-                   start directory)
-
-For test discovery all test modules must be importable from the top
-level directory of the project.
-"""
-
-USAGE_FROM_MODULE = """\
-Usage: %(progName)s [options] [test] [...]
-
-Options:
-  -h, --help       Show this message
-  -v, --verbose    Verbose output
-  -q, --quiet      Minimal output
-%(failfast)s%(catchbreak)s%(buffer)s
-Examples:
-  %(progName)s                               - run default set of tests
-  %(progName)s MyTestSuite                   - run suite 'MyTestSuite'
-  %(progName)s MyTestCase.testSomething      - run MyTestCase.testSomething
-  %(progName)s MyTestCase                    - run all 'test*' test methods
-                                               in MyTestCase
-"""
-
-
-class TestProgram(object):
-    """A command-line program that runs a set of tests; this is primarily
-       for making test modules conveniently executable.
-    """
-    USAGE = USAGE_FROM_MODULE
-
-    # 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, 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
-
-        self.exit = exit
-        self.verbosity = verbosity
-        self.failfast = failfast
-        self.catchbreak = catchbreak
-        self.buffer = buffer
-        self.defaultTest = defaultTest
-        self.testRunner = testRunner
-        self.testLoader = testLoader
-        self.progName = os.path.basename(argv[0])
-        self.parseArgs(argv)
-        self.runTests()
-
-    def usageExit(self, msg=None):
-        if msg:
-            print(msg)
-        usage = {'progName': self.progName, 'catchbreak': '', 'failfast': '',
-                 'buffer': ''}
-        if self.failfast:
-            usage['failfast'] = FAILFAST
-        if self.catchbreak and installHandler is not None:
-            usage['catchbreak'] = CATCHBREAK
-        if self.buffer:
-            usage['buffer'] = BUFFEROUTPUT
-        print(self.USAGE % usage)
-        sys.exit(2)
-
-    def parseArgs(self, argv):
-        if len(argv) > 1 and argv[1].lower() == 'discover':
-            self._do_discovery(argv[2:])
-            return
-
-        import getopt
-        long_opts = ['help', 'verbose', 'quiet', 'failfast', 'catch', 'buffer']
-        try:
-            options, args = getopt.getopt(argv[1:], 'hHvqfcb', long_opts)
-            for opt, value in options:
-                if opt in ('-h', '-H', '--help'):
-                    self.usageExit()
-                if opt in ('-q', '--quiet'):
-                    self.verbosity = 0
-                if opt in ('-v', '--verbose'):
-                    self.verbosity = 2
-                if opt in ('-f', '--failfast'):
-                    if self.failfast is None:
-                        self.failfast = True
-                    # Should this raise an exception if -f is not valid?
-                if opt in ('-c', '--catch'):
-                    if self.catchbreak is None and installHandler is not None:
-                        self.catchbreak = True
-                    # Should this raise an exception if -c is not valid?
-                if opt in ('-b', '--buffer'):
-                    if self.buffer is None:
-                        self.buffer = True
-                    # Should this raise an exception if -b is not valid?
-            if len(args) == 0 and self.defaultTest is None:
-                # createTests will load tests from self.module
-                self.testNames = None
-            elif len(args) > 0:
-                self.testNames = args
-                if __name__ == '__main__':
-                    # to support python -m unittest ...
-                    self.module = None
-            else:
-                self.testNames = (self.defaultTest,)
-            self.createTests()
-        except getopt.error as msg:
-            self.usageExit(msg)
-
-    def createTests(self):
-        if self.testNames is None:
-            self.test = self.testLoader.loadTestsFromModule(self.module)
-        else:
-            self.test = self.testLoader.loadTestsFromNames(self.testNames,
-                                                           self.module)
-
-    def _do_discovery(self, argv, Loader=loader.TestLoader):
-        # handle command line args for test discovery
-        self.progName = '%s discover' % self.progName
-        import optparse
-        parser = optparse.OptionParser()
-        parser.prog = self.progName
-        parser.add_option('-v', '--verbose', dest='verbose', default=False,
-                          help='Verbose output', action='store_true')
-        if self.failfast:
-            parser.add_option(
-                '-f',
-                '--failfast',
-                dest='failfast',
-                default=False,
-                help='Stop on first fail or error',
-                action='store_true')
-        if self.catchbreak and installHandler is not None:
-            parser.add_option(
-                '-c',
-                '--catch',
-                dest='catchbreak',
-                default=False,
-                help='Catch ctrl-C and display results so far',
-                action='store_true')
-        if self.buffer:
-            parser.add_option('-b', '--buffer', dest='buffer', default=False,
-                              help='Buffer stdout and stderr during tests',
-                              action='store_true')
-        parser.add_option('-s', '--start-directory', dest='start', default='.',
-                          help="Directory to start discovery ('.' default)")
-        parser.add_option(
-            '-p',
-            '--pattern',
-            dest='pattern',
-            default='test*.py',
-            help="Pattern to match tests ('test*.py' default)")
-        parser.add_option(
-            '-t',
-            '--top-level-directory',
-            dest='top',
-            default=None,
-            help='Top level directory of project (defaults to start directory)')
-
-        options, args = parser.parse_args(argv)
-        if len(args) > 3:
-            self.usageExit()
-
-        for name, value in zip(('start', 'pattern', 'top'), args):
-            setattr(options, name, value)
-
-        # only set options from the parsing here
-        # if they weren't set explicitly in the constructor
-        if self.failfast is None:
-            self.failfast = options.failfast
-        if self.catchbreak is None and installHandler is not None:
-            self.catchbreak = options.catchbreak
-        if self.buffer is None:
-            self.buffer = options.buffer
-
-        if options.verbose:
-            self.verbosity = 2
-
-        start_dir = options.start
-        pattern = options.pattern
-        top_level_dir = options.top
-
-        loader = Loader()
-        self.test = loader.discover(start_dir, pattern, top_level_dir)
-
-    def runTests(self):
-        if self.catchbreak:
-            installHandler()
-        if self.testRunner is None:
-            self.testRunner = runner.TextTestRunner
-        if isinstance(self.testRunner, (type, types.ClassType)):
-            try:
-                testRunner = self.testRunner(verbosity=self.verbosity,
-                                             failfast=self.failfast,
-                                             buffer=self.buffer)
-            except TypeError:
-                # didn't accept the verbosity, buffer or failfast arguments
-                testRunner = self.testRunner()
-        else:
-            # it is assumed to be a TestRunner instance
-            testRunner = self.testRunner
-        self.result = testRunner.run(self.test)
-        if self.exit:
-            sys.exit(not self.result.wasSuccessful())
-
-main = TestProgram
-
-
-def main_():
-    TestProgram.USAGE = USAGE_AS_MAIN
-    main(module=None)
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/result.py b/lldb/third_party/Python/module/unittest2/unittest2/result.py
deleted file mode 100644
index 97eb4fa..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/result.py
+++ /dev/null
@@ -1,197 +0,0 @@
-"""Test result object"""
-
-import use_lldb_suite
-
-import io
-import sys
-import traceback
-import unittest
-
-from unittest2 import util
-from unittest2.compatibility import wraps
-
-__unittest = True
-
-
-def failfast(method):
-    @wraps(method)
-    def inner(self, *args, **kw):
-        if getattr(self, 'failfast', False):
-            self.stop()
-        return method(self, *args, **kw)
-    return inner
-
-
-STDOUT_LINE = '\nStdout:\n%s'
-STDERR_LINE = '\nStderr:\n%s'
-
-
-class TestResult(unittest.TestResult):
-    """Holder for test result information.
-
-    Test results are automatically managed by the TestCase and TestSuite
-    classes, and do not need to be explicitly manipulated by writers of tests.
-
-    Each instance holds the total number of tests run, and collections of
-    failures and errors that occurred among those test runs. The collections
-    contain tuples of (testcase, exceptioninfo), where exceptioninfo is the
-    formatted traceback of the error that occurred.
-    """
-    _previousTestClass = None
-    _moduleSetUpFailed = False
-
-    def __init__(self):
-        self.failfast = False
-        self.failures = []
-        self.passes = []
-        self.errors = []
-        self.cleanup_errors = []
-        self.testsRun = 0
-        self.skipped = []
-        self.expectedFailures = []
-        self.unexpectedSuccesses = []
-        self.shouldStop = False
-        self.buffer = False
-        self._stdout_buffer = None
-        self._stderr_buffer = None
-        self._original_stdout = sys.stdout
-        self._original_stderr = sys.stderr
-        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 = 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.
-        """
-
-    def stopTest(self, test):
-        """Called when the given test has been run"""
-        if self.buffer:
-            if self._mirrorOutput:
-                output = sys.stdout.getvalue()
-                error = sys.stderr.getvalue()
-                if output:
-                    if not output.endswith('\n'):
-                        output += '\n'
-                    self._original_stdout.write(STDOUT_LINE % output)
-                if error:
-                    if not error.endswith('\n'):
-                        error += '\n'
-                    self._original_stderr.write(STDERR_LINE % error)
-
-            sys.stdout = self._original_stdout
-            sys.stderr = self._original_stderr
-            self._stdout_buffer.seek(0)
-            self._stdout_buffer.truncate()
-            self._stderr_buffer.seek(0)
-            self._stderr_buffer.truncate()
-        self._mirrorOutput = False
-
-    def stopTestRun(self):
-        """Called once after all tests are executed.
-
-        See stopTest for a method called after each test.
-        """
-
-    @failfast
-    def addError(self, test, err):
-        """Called when an error has occurred. 'err' is a tuple of values as
-        returned by sys.exc_info().
-        """
-        self.errors.append((test, self._exc_info_to_string(err, test)))
-        self._mirrorOutput = True
-
-    def addCleanupError(self, test, err):
-        """Called when an error has occurred during cleanup. 'err' is a tuple of
-        values as returned by sys.exc_info().
-        """
-        self.cleanup_errors.append((test, self._exc_info_to_string(err, test)))
-        self._mirrorOutput = True
-
-    @failfast
-    def addFailure(self, test, err):
-        """Called when an error has occurred. 'err' is a tuple of values as
-        returned by sys.exc_info()."""
-        self.failures.append((test, self._exc_info_to_string(err, test)))
-        self._mirrorOutput = True
-
-    def addSuccess(self, test):
-        "Called when a test has completed successfully"
-        self.passes.append(test)
-        pass
-
-    def addSkip(self, test, reason):
-        """Called when a test is skipped."""
-        self.skipped.append((test, reason))
-
-    def addExpectedFailure(self, test, err, bugnumber):
-        """Called when an expected failure/error occured."""
-        self.expectedFailures.append(
-            (test, self._exc_info_to_string(err, test)))
-
-    @failfast
-    def addUnexpectedSuccess(self, test, bugnumber):
-        """Called when a test was expected to fail, but succeed."""
-        self.unexpectedSuccesses.append(test)
-
-    def wasSuccessful(self):
-        "Tells whether or not this result was a success"
-        return (len(self.failures) +
-                len(self.errors) +
-                len(self.unexpectedSuccesses) == 0)
-
-    def stop(self):
-        "Indicates that the tests should be aborted"
-        self.shouldStop = True
-
-    def _exc_info_to_string(self, err, test):
-        """Converts a sys.exc_info()-style tuple of values into a string."""
-        exctype, value, tb = err
-        # Skip test runner traceback levels
-        while tb and self._is_relevant_tb_level(tb):
-            tb = tb.tb_next
-        if exctype is test.failureException:
-            # Skip assert*() traceback levels
-            length = self._count_relevant_tb_levels(tb)
-            msgLines = traceback.format_exception(exctype, value, tb, length)
-        else:
-            msgLines = traceback.format_exception(exctype, value, tb)
-
-        if self.buffer:
-            output = sys.stdout.getvalue()
-            error = sys.stderr.getvalue()
-            if output:
-                if not output.endswith('\n'):
-                    output += '\n'
-                msgLines.append(STDOUT_LINE % output)
-            if error:
-                if not error.endswith('\n'):
-                    error += '\n'
-                msgLines.append(STDERR_LINE % error)
-        return ''.join(msgLines)
-
-    def _is_relevant_tb_level(self, tb):
-        return '__unittest' in tb.tb_frame.f_globals
-
-    def _count_relevant_tb_levels(self, tb):
-        length = 0
-        while tb and not self._is_relevant_tb_level(tb):
-            length += 1
-            tb = tb.tb_next
-        return length
-
-    def __repr__(self):
-        return "<%s run=%i errors=%i failures=%i>" % \
-               (util.strclass(self.__class__), self.testsRun, len(self.errors),
-                len(self.failures))
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/runner.py b/lldb/third_party/Python/module/unittest2/unittest2/runner.py
deleted file mode 100644
index 93fc104..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/runner.py
+++ /dev/null
@@ -1,206 +0,0 @@
-"""Running tests"""
-
-import sys
-import time
-import unittest
-import progress
-
-from unittest2 import result
-
-try:
-    from unittest2.signals import registerResult
-except ImportError:
-    def registerResult(_):
-        pass
-
-__unittest = True
-
-
-class _WritelnDecorator(object):
-    """Used to decorate file-like objects with a handy 'writeln' method"""
-
-    def __init__(self, stream):
-        self.stream = stream
-
-    def __getattr__(self, attr):
-        if attr in ('stream', '__getstate__'):
-            raise AttributeError(attr)
-        return getattr(self.stream, attr)
-
-    def writeln(self, arg=None):
-        if arg:
-            self.write(arg)
-        self.write('\n')  # text-mode streams translate to \r\n if needed
-
-
-class TextTestResult(result.TestResult):
-    """A test result class that can print formatted text results to a stream.
-
-    Used by TextTestRunner.
-    """
-    separator1 = '=' * 70
-    separator2 = '-' * 70
-
-    def __init__(self, stream, descriptions, verbosity):
-        super(TextTestResult, self).__init__()
-        self.stream = stream
-        self.showAll = verbosity > 1
-        self.dots = verbosity == 1
-        self.descriptions = descriptions
-        self.progressbar = None
-
-        if self.dots:
-            self.stream.writeln(
-                ".=success F=fail E=error s=skipped x=expected-fail u=unexpected-success")
-            self.stream.writeln("")
-            self.stream.flush()
-
-    def getDescription(self, test):
-        doc_first_line = test.shortDescription()
-        if self.descriptions and doc_first_line:
-            return '\n'.join((str(test), doc_first_line))
-        else:
-            return str(test)
-
-    def startTest(self, test):
-        super(TextTestResult, self).startTest(test)
-        if self.showAll:
-            self.stream.write(self.getDescription(test))
-            self.stream.write(" ... ")
-            self.stream.flush()
-
-    def newTestResult(self, test, result_short, result_long):
-        if self.showAll:
-            self.stream.writeln(result_long)
-        elif self.progressbar:
-            self.progressbar.__add__(1)
-            self.progressbar.add_event(result_short)
-            self.progressbar.show_progress()
-        elif self.dots:
-            self.stream.write(result_short)
-            self.stream.flush()
-
-    def addSuccess(self, test):
-        super(TextTestResult, self).addSuccess(test)
-        if self.progressbar:
-            self.newTestResult(test, "ok", "ok")
-        else:
-            self.newTestResult(test, ".", "ok")
-
-    def addError(self, test, err):
-        super(TextTestResult, self).addError(test, err)
-        self.newTestResult(test, "E", "ERROR")
-
-    def addFailure(self, test, err):
-        super(TextTestResult, self).addFailure(test, err)
-        self.newTestResult(test, "F", "FAILURE")
-
-    def addSkip(self, test, reason):
-        super(TextTestResult, self).addSkip(test, reason)
-        self.newTestResult(test, "s", "skipped %r" % (reason,))
-
-    def addExpectedFailure(self, test, err, bugnumber):
-        super(TextTestResult, self).addExpectedFailure(test, err, bugnumber)
-        self.newTestResult(test, "x", "expected failure")
-
-    def addUnexpectedSuccess(self, test, bugnumber):
-        super(TextTestResult, self).addUnexpectedSuccess(test, bugnumber)
-        self.newTestResult(test, "u", "unexpected success")
-
-    def printErrors(self):
-        if self.progressbar:
-            self.progressbar.complete()
-            self.progressbar.show_progress()
-        if self.dots or self.showAll:
-            self.stream.writeln()
-        self.printErrorList('ERROR', self.errors)
-        self.printErrorList('FAIL', self.failures)
-
-    def printErrorList(self, flavour, errors):
-        for test, err in errors:
-            self.stream.writeln(self.separator1)
-            self.stream.writeln("%s: %s" %
-                                (flavour, self.getDescription(test)))
-            self.stream.writeln(self.separator2)
-            self.stream.writeln("%s" % err)
-
-    def stopTestRun(self):
-        super(TextTestResult, self).stopTestRun()
-        self.printErrors()
-
-
-class TextTestRunner(unittest.TextTestRunner):
-    """A test runner class that displays results in textual form.
-
-    It prints out the names of tests as they are run, errors as they
-    occur, and a summary of the results at the end of the test run.
-    """
-    resultclass = TextTestResult
-
-    def __init__(self, stream=sys.stderr, descriptions=True, verbosity=1,
-                 failfast=False, buffer=False, resultclass=None):
-        self.stream = _WritelnDecorator(stream)
-        self.descriptions = descriptions
-        self.verbosity = verbosity
-        self.failfast = failfast
-        self.buffer = buffer
-        if resultclass is not None:
-            self.resultclass = resultclass
-
-    def _makeResult(self):
-        return self.resultclass(self.stream, self.descriptions, self.verbosity)
-
-    def run(self, test):
-        "Run the given test case or test suite."
-        result = self._makeResult()
-        result.failfast = self.failfast
-        result.buffer = self.buffer
-        registerResult(result)
-
-        startTime = time.time()
-        startTestRun = getattr(result, 'startTestRun', None)
-        if startTestRun is not None:
-            startTestRun()
-        try:
-            test(result)
-        finally:
-            stopTestRun = getattr(result, 'stopTestRun', None)
-            if stopTestRun is not None:
-                stopTestRun()
-            else:
-                result.printErrors()
-        stopTime = time.time()
-        timeTaken = stopTime - startTime
-        if hasattr(result, 'separator2'):
-            self.stream.writeln(result.separator2)
-        run = result.testsRun
-        self.stream.writeln("Ran %d test%s in %.3fs" %
-                            (run, run != 1 and "s" or "", timeTaken))
-        self.stream.writeln()
-
-        expectedFails = unexpectedSuccesses = skipped = passed = failed = errored = 0
-        try:
-            results = map(len, (result.expectedFailures,
-                                result.unexpectedSuccesses,
-                                result.skipped,
-                                result.passes,
-                                result.failures,
-                                result.errors))
-            expectedFails, unexpectedSuccesses, skipped, passed, failed, errored = results
-        except AttributeError:
-            pass
-        infos = []
-        infos.append("%d passes" % passed)
-        infos.append("%d failures" % failed)
-        infos.append("%d errors" % errored)
-        infos.append("%d skipped" % skipped)
-        infos.append("%d expected failures" % expectedFails)
-        infos.append("%d unexpected successes" % unexpectedSuccesses)
-        self.stream.write("RESULT: ")
-        if not result.wasSuccessful():
-            self.stream.write("FAILED")
-        else:
-            self.stream.write("PASSED")
-
-        self.stream.writeln(" (%s)" % (", ".join(infos),))
-        return result
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/signals.py b/lldb/third_party/Python/module/unittest2/unittest2/signals.py
deleted file mode 100644
index dc0dc3d..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/signals.py
+++ /dev/null
@@ -1,63 +0,0 @@
-import signal
-import weakref
-
-from unittest2.compatibility import wraps
-
-__unittest = True
-
-
-class _InterruptHandler(object):
-
-    def __init__(self, default_handler):
-        self.called = False
-        self.default_handler = default_handler
-
-    def __call__(self, signum, frame):
-        installed_handler = signal.getsignal(signal.SIGINT)
-        if installed_handler is not self:
-            # if we aren't the installed handler, then delegate immediately
-            # to the default handler
-            self.default_handler(signum, frame)
-
-        if self.called:
-            self.default_handler(signum, frame)
-        self.called = True
-        for result in _results.keys():
-            result.stop()
-
-_results = weakref.WeakKeyDictionary()
-
-
-def registerResult(result):
-    _results[result] = 1
-
-
-def removeResult(result):
-    return bool(_results.pop(result, None))
-
-_interrupt_handler = None
-
-
-def installHandler():
-    global _interrupt_handler
-    if _interrupt_handler is None:
-        default_handler = signal.getsignal(signal.SIGINT)
-        _interrupt_handler = _InterruptHandler(default_handler)
-        signal.signal(signal.SIGINT, _interrupt_handler)
-
-
-def removeHandler(method=None):
-    if method is not None:
-        @wraps(method)
-        def inner(*args, **kwargs):
-            initial = signal.getsignal(signal.SIGINT)
-            removeHandler()
-            try:
-                return method(*args, **kwargs)
-            finally:
-                signal.signal(signal.SIGINT, initial)
-        return inner
-
-    global _interrupt_handler
-    if _interrupt_handler is not None:
-        signal.signal(signal.SIGINT, _interrupt_handler.default_handler)
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/suite.py b/lldb/third_party/Python/module/unittest2/unittest2/suite.py
deleted file mode 100644
index f255444..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/suite.py
+++ /dev/null
@@ -1,286 +0,0 @@
-"""TestSuite"""
-
-import sys
-import unittest
-from unittest2 import case, util
-
-__unittest = True
-
-
-class BaseTestSuite(unittest.TestSuite):
-    """A simple test suite that doesn't provide class or module shared fixtures.
-    """
-
-    def __init__(self, tests=()):
-        self._tests = []
-        self.addTests(tests)
-
-    def __repr__(self):
-        return "<%s tests=%s>" % (util.strclass(self.__class__), list(self))
-
-    def __eq__(self, other):
-        if not isinstance(other, self.__class__):
-            return NotImplemented
-        return list(self) == list(other)
-
-    def __ne__(self, other):
-        return not self == other
-
-    # Can't guarantee hash invariant, so flag as unhashable
-    __hash__ = None
-
-    def __iter__(self):
-        return iter(self._tests)
-
-    def countTestCases(self):
-        cases = 0
-        for test in self:
-            cases += test.countTestCases()
-        return cases
-
-    def addTest(self, test):
-        # sanity checks
-        if not hasattr(test, '__call__'):
-            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, 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
-            test(result)
-        return result
-
-    def __call__(self, *args, **kwds):
-        return self.run(*args, **kwds)
-
-    def debug(self):
-        """Run the tests without collecting errors in a TestResult"""
-        for test in self:
-            test.debug()
-
-
-class TestSuite(BaseTestSuite):
-    """A test suite is a composite test consisting of a number of TestCases.
-
-    For use, create an instance of TestSuite, then add test case instances.
-    When all tests have been added, the suite can be passed to a test
-    runner, such as TextTestRunner. It will run the individual test cases
-    in the order in which they were added, aggregating the results. When
-    subclassing, do not forget to call the base class constructor.
-    """
-
-    def run(self, result):
-        self._wrapped_run(result)
-        self._tearDownPreviousClass(None, result)
-        self._handleModuleTearDown(result)
-        return result
-
-    def debug(self):
-        """Run the tests without collecting errors in a TestResult"""
-        debug = _DebugResult()
-        self._wrapped_run(debug, True)
-        self._tearDownPreviousClass(None, debug)
-        self._handleModuleTearDown(debug)
-
-    ################################
-    # private methods
-    def _wrapped_run(self, result, debug=False):
-        for test in self:
-            if result.shouldStop:
-                break
-
-            if _isnotsuite(test):
-                self._tearDownPreviousClass(test, result)
-                self._handleModuleFixture(test, result)
-                self._handleClassSetUp(test, result)
-                result._previousTestClass = test.__class__
-
-                if (getattr(test.__class__, '_classSetupFailed', False) or
-                        getattr(result, '_moduleSetUpFailed', False)):
-                    continue
-
-            if hasattr(test, '_wrapped_run'):
-                test._wrapped_run(result, debug)
-            elif not debug:
-                test(result)
-            else:
-                test.debug()
-
-    def _handleClassSetUp(self, test, result):
-        previousClass = getattr(result, '_previousTestClass', None)
-        currentClass = test.__class__
-        if currentClass == previousClass:
-            return
-        if result._moduleSetUpFailed:
-            return
-        if getattr(currentClass, "__unittest_skip__", False):
-            return
-
-        try:
-            currentClass._classSetupFailed = False
-        except TypeError:
-            # test may actually be a function
-            # so its class will be a builtin-type
-            pass
-
-        setUpClass = getattr(currentClass, 'setUpClass', None)
-        if setUpClass is not None:
-            try:
-                setUpClass()
-            except Exception as e:
-                if isinstance(result, _DebugResult):
-                    raise
-                currentClass._classSetupFailed = True
-                className = util.strclass(currentClass)
-                errorName = 'setUpClass (%s)' % className
-                self._addClassOrModuleLevelException(result, e, errorName)
-
-    def _get_previous_module(self, result):
-        previousModule = None
-        previousClass = getattr(result, '_previousTestClass', None)
-        if previousClass is not None:
-            previousModule = previousClass.__module__
-        return previousModule
-
-    def _handleModuleFixture(self, test, result):
-        previousModule = self._get_previous_module(result)
-        currentModule = test.__class__.__module__
-        if currentModule == previousModule:
-            return
-
-        self._handleModuleTearDown(result)
-
-        result._moduleSetUpFailed = False
-        try:
-            module = sys.modules[currentModule]
-        except KeyError:
-            return
-        setUpModule = getattr(module, 'setUpModule', None)
-        if setUpModule is not None:
-            try:
-                setUpModule()
-            except Exception as e:
-                if isinstance(result, _DebugResult):
-                    raise
-                result._moduleSetUpFailed = True
-                errorName = 'setUpModule (%s)' % currentModule
-                self._addClassOrModuleLevelException(result, e, errorName)
-
-    def _addClassOrModuleLevelException(self, result, exception, errorName):
-        error = _ErrorHolder(errorName)
-        addSkip = getattr(result, 'addSkip', None)
-        if addSkip is not None and isinstance(exception, case.SkipTest):
-            addSkip(error, str(exception))
-        else:
-            result.addError(error, sys.exc_info())
-
-    def _handleModuleTearDown(self, result):
-        previousModule = self._get_previous_module(result)
-        if previousModule is None:
-            return
-        if result._moduleSetUpFailed:
-            return
-
-        try:
-            module = sys.modules[previousModule]
-        except KeyError:
-            return
-
-        tearDownModule = getattr(module, 'tearDownModule', None)
-        if tearDownModule is not None:
-            try:
-                tearDownModule()
-            except Exception as e:
-                if isinstance(result, _DebugResult):
-                    raise
-                errorName = 'tearDownModule (%s)' % previousModule
-                self._addClassOrModuleLevelException(result, e, errorName)
-
-    def _tearDownPreviousClass(self, test, result):
-        previousClass = getattr(result, '_previousTestClass', None)
-        currentClass = test.__class__
-        if currentClass == previousClass:
-            return
-        if getattr(previousClass, '_classSetupFailed', False):
-            return
-        if getattr(result, '_moduleSetUpFailed', False):
-            return
-        if getattr(previousClass, "__unittest_skip__", False):
-            return
-
-        tearDownClass = getattr(previousClass, 'tearDownClass', None)
-        if tearDownClass is not None:
-            try:
-                tearDownClass()
-            except Exception as e:
-                if isinstance(result, _DebugResult):
-                    raise
-                className = util.strclass(previousClass)
-                errorName = 'tearDownClass (%s)' % className
-                self._addClassOrModuleLevelException(result, e, errorName)
-
-
-class _ErrorHolder(object):
-    """
-    Placeholder for a TestCase inside a result. As far as a TestResult
-    is concerned, this looks exactly like a unit test. Used to insert
-    arbitrary errors into a test suite run.
-    """
-    # Inspired by the ErrorHolder from Twisted:
-    # http://twistedmatrix.com/trac/browser/trunk/twisted/trial/runner.py
-
-    # attribute used by TestResult._exc_info_to_string
-    failureException = None
-
-    def __init__(self, description):
-        self.description = description
-
-    def id(self):
-        return self.description
-
-    def shortDescription(self):
-        return None
-
-    def __repr__(self):
-        return "<ErrorHolder description=%r>" % (self.description,)
-
-    def __str__(self):
-        return self.id()
-
-    def run(self, result):
-        # could call result.addError(...) - but this test-like object
-        # shouldn't be run anyway
-        pass
-
-    def __call__(self, result):
-        return self.run(result)
-
-    def countTestCases(self):
-        return 0
-
-
-def _isnotsuite(test):
-    "A crude way to tell apart testcases and suites with duck-typing"
-    try:
-        iter(test)
-    except TypeError:
-        return True
-    return False
-
-
-class _DebugResult(object):
-    "Used by the TestSuite to hold previous class when running in debug."
-    _previousTestClass = None
-    _moduleSetUpFailed = False
-    shouldStop = False
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/__init__.py b/lldb/third_party/Python/module/unittest2/unittest2/test/__init__.py
deleted file mode 100644
index 792d600..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-#
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/dummy.py b/lldb/third_party/Python/module/unittest2/unittest2/test/dummy.py
deleted file mode 100644
index e69de29..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/dummy.py
+++ /dev/null
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/support.py b/lldb/third_party/Python/module/unittest2/unittest2/test/support.py
deleted file mode 100644
index 5c9bcf2..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/support.py
+++ /dev/null
@@ -1,189 +0,0 @@
-import sys
-import warnings
-
-import unittest2
-
-
-def resultFactory(*_):
-    return unittest2.TestResult()
-
-
-class OldTestResult(object):
-    """An object honouring TestResult before startTestRun/stopTestRun."""
-
-    def __init__(self, *_):
-        self.failures = []
-        self.errors = []
-        self.testsRun = 0
-        self.shouldStop = False
-
-    def startTest(self, test):
-        pass
-
-    def stopTest(self, test):
-        pass
-
-    def addError(self, test, err):
-        self.errors.append((test, err))
-
-    def addFailure(self, test, err):
-        self.failures.append((test, err))
-
-    def addSuccess(self, test):
-        pass
-
-    def wasSuccessful(self):
-        return True
-
-    def printErrors(self):
-        pass
-
-
-class LoggingResult(unittest2.TestResult):
-
-    def __init__(self, log):
-        self._events = log
-        super(LoggingResult, self).__init__()
-
-    def startTest(self, test):
-        self._events.append('startTest')
-        super(LoggingResult, self).startTest(test)
-
-    def startTestRun(self):
-        self._events.append('startTestRun')
-        super(LoggingResult, self).startTestRun()
-
-    def stopTest(self, test):
-        self._events.append('stopTest')
-        super(LoggingResult, self).stopTest(test)
-
-    def stopTestRun(self):
-        self._events.append('stopTestRun')
-        super(LoggingResult, self).stopTestRun()
-
-    def addFailure(self, *args):
-        self._events.append('addFailure')
-        super(LoggingResult, self).addFailure(*args)
-
-    def addSuccess(self, *args):
-        self._events.append('addSuccess')
-        super(LoggingResult, self).addSuccess(*args)
-
-    def addError(self, *args):
-        self._events.append('addError')
-        super(LoggingResult, self).addError(*args)
-
-    def addSkip(self, *args):
-        self._events.append('addSkip')
-        super(LoggingResult, self).addSkip(*args)
-
-    def addExpectedFailure(self, *args):
-        self._events.append('addExpectedFailure')
-        super(LoggingResult, self).addExpectedFailure(*args)
-
-    def addUnexpectedSuccess(self, *args):
-        self._events.append('addUnexpectedSuccess')
-        super(LoggingResult, self).addUnexpectedSuccess(*args)
-
-
-class EqualityMixin(object):
-    """Used as a mixin for TestCase"""
-
-    # Check for a valid __eq__ implementation
-    def test_eq(self):
-        for obj_1, obj_2 in self.eq_pairs:
-            self.assertEqual(obj_1, obj_2)
-            self.assertEqual(obj_2, obj_1)
-
-    # Check for a valid __ne__ implementation
-    def test_ne(self):
-        for obj_1, obj_2 in self.ne_pairs:
-            self.assertNotEqual(obj_1, obj_2)
-            self.assertNotEqual(obj_2, obj_1)
-
-
-class HashingMixin(object):
-    """Used as a mixin for TestCase"""
-
-    # Check for a valid __hash__ implementation
-    def test_hash(self):
-        for obj_1, obj_2 in self.eq_pairs:
-            try:
-                if not hash(obj_1) == hash(obj_2):
-                    self.fail("%r and %r do not hash equal" % (obj_1, obj_2))
-            except KeyboardInterrupt:
-                raise
-            except Exception as e:
-                self.fail("Problem hashing %r and %r: %s" % (obj_1, obj_2, e))
-
-        for obj_1, obj_2 in self.ne_pairs:
-            try:
-                if hash(obj_1) == hash(obj_2):
-                    self.fail("%s and %s hash equal, but shouldn't" %
-                              (obj_1, obj_2))
-            except KeyboardInterrupt:
-                raise
-            except Exception as e:
-                self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e))
-
-
-# copied from Python 2.6
-try:
-    from warnings import catch_warnings
-except ImportError:
-    class catch_warnings(object):
-
-        def __init__(self, record=False, module=None):
-            self._record = record
-            self._module = sys.modules['warnings']
-            self._entered = False
-
-        def __repr__(self):
-            args = []
-            if self._record:
-                args.append("record=True")
-            name = type(self).__name__
-            return "%s(%s)" % (name, ", ".join(args))
-
-        def __enter__(self):
-            if self._entered:
-                raise RuntimeError("Cannot enter %r twice" % self)
-            self._entered = True
-            self._filters = self._module.filters
-            self._module.filters = self._filters[:]
-            self._showwarning = self._module.showwarning
-            if self._record:
-                log = []
-
-                def showwarning(*args, **kwargs):
-                    log.append(WarningMessage(*args, **kwargs))
-                self._module.showwarning = showwarning
-                return log
-            else:
-                return None
-
-        def __exit__(self, *exc_info):
-            if not self._entered:
-                raise RuntimeError(
-                    "Cannot exit %r without entering first" %
-                    self)
-            self._module.filters = self._filters
-            self._module.showwarning = self._showwarning
-
-    class WarningMessage(object):
-        _WARNING_DETAILS = (
-            "message",
-            "category",
-            "filename",
-            "lineno",
-            "file",
-            "line")
-
-        def __init__(self, message, category, filename, lineno, file=None,
-                     line=None):
-            local_values = locals()
-            for attr in self._WARNING_DETAILS:
-                setattr(self, attr, local_values[attr])
-            self._category_name = None
-            if category.__name__:
-                self._category_name = category.__name__
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_assertions.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_assertions.py
deleted file mode 100644
index c96aaaf..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_assertions.py
+++ /dev/null
@@ -1,269 +0,0 @@
-import datetime
-
-import unittest2
-
-
-class Test_Assertions(unittest2.TestCase):
-
-    def test_AlmostEqual(self):
-        self.assertAlmostEqual(1.00000001, 1.0)
-        self.assertNotAlmostEqual(1.0000001, 1.0)
-        self.assertRaises(self.failureException,
-                          self.assertAlmostEqual, 1.0000001, 1.0)
-        self.assertRaises(self.failureException,
-                          self.assertNotAlmostEqual, 1.00000001, 1.0)
-
-        self.assertAlmostEqual(1.1, 1.0, places=0)
-        self.assertRaises(self.failureException,
-                          self.assertAlmostEqual, 1.1, 1.0, places=1)
-
-        self.assertAlmostEqual(0, .1 + .1j, places=0)
-        self.assertNotAlmostEqual(0, .1 + .1j, places=1)
-        self.assertRaises(self.failureException,
-                          self.assertAlmostEqual, 0, .1 + .1j, places=1)
-        self.assertRaises(self.failureException,
-                          self.assertNotAlmostEqual, 0, .1 + .1j, places=0)
-
-        try:
-            self.assertAlmostEqual(float('inf'), float('inf'))
-            self.assertRaises(self.failureException, self.assertNotAlmostEqual,
-                              float('inf'), float('inf'))
-        except ValueError:
-            # float('inf') is invalid on Windows in Python 2.4 / 2.5
-            x = object()
-            self.assertAlmostEqual(x, x)
-            self.assertRaises(self.failureException, self.assertNotAlmostEqual,
-                              x, x)
-
-    def test_AmostEqualWithDelta(self):
-        self.assertAlmostEqual(1.1, 1.0, delta=0.5)
-        self.assertAlmostEqual(1.0, 1.1, delta=0.5)
-        self.assertNotAlmostEqual(1.1, 1.0, delta=0.05)
-        self.assertNotAlmostEqual(1.0, 1.1, delta=0.05)
-
-        self.assertRaises(self.failureException, self.assertAlmostEqual,
-                          1.1, 1.0, delta=0.05)
-        self.assertRaises(self.failureException, self.assertNotAlmostEqual,
-                          1.1, 1.0, delta=0.5)
-
-        self.assertRaises(TypeError, self.assertAlmostEqual,
-                          1.1, 1.0, places=2, delta=2)
-        self.assertRaises(TypeError, self.assertNotAlmostEqual,
-                          1.1, 1.0, places=2, delta=2)
-
-        first = datetime.datetime.now()
-        second = first + datetime.timedelta(seconds=10)
-        self.assertAlmostEqual(first, second,
-                               delta=datetime.timedelta(seconds=20))
-        self.assertNotAlmostEqual(first, second,
-                                  delta=datetime.timedelta(seconds=5))
-
-    def testAssertNotRegexpMatches(self):
-        self.assertNotRegexpMatches('Ala ma kota', r'r+')
-        try:
-            self.assertNotRegexpMatches('Ala ma kota', r'k.t', 'Message')
-        except self.failureException as e:
-            self.assertIn("'kot'", e.args[0])
-            self.assertIn('Message', e.args[0])
-        else:
-            self.fail('assertNotRegexpMatches should have failed.')
-
-
-class TestLongMessage(unittest2.TestCase):
-    """Test that the individual asserts honour longMessage.
-    This actually tests all the message behaviour for
-    asserts that use longMessage."""
-
-    def setUp(self):
-        class TestableTestFalse(unittest2.TestCase):
-            longMessage = False
-            failureException = self.failureException
-
-            def testTest(self):
-                pass
-
-        class TestableTestTrue(unittest2.TestCase):
-            longMessage = True
-            failureException = self.failureException
-
-            def testTest(self):
-                pass
-
-        self.testableTrue = TestableTestTrue('testTest')
-        self.testableFalse = TestableTestFalse('testTest')
-
-    def testDefault(self):
-        self.assertTrue(unittest2.TestCase.longMessage)
-
-    def test_formatMsg(self):
-        self.assertEquals(
-            self.testableFalse._formatMessage(
-                None, "foo"), "foo")
-        self.assertEquals(
-            self.testableFalse._formatMessage(
-                "foo", "bar"), "foo")
-
-        self.assertEquals(self.testableTrue._formatMessage(None, "foo"), "foo")
-        self.assertEquals(
-            self.testableTrue._formatMessage(
-                "foo", "bar"), "bar : foo")
-
-        # This blows up if _formatMessage uses string concatenation
-        self.testableTrue._formatMessage(object(), 'foo')
-
-    def assertMessages(self, methodName, args, errors):
-        def getMethod(i):
-            useTestableFalse = i < 2
-            if useTestableFalse:
-                test = self.testableFalse
-            else:
-                test = self.testableTrue
-            return getattr(test, methodName)
-
-        for i, expected_regexp in enumerate(errors):
-            testMethod = getMethod(i)
-            kwargs = {}
-            withMsg = i % 2
-            if withMsg:
-                kwargs = {"msg": "oops"}
-
-            self.assertRaisesRegexp(self.failureException,
-                                    expected_regexp,
-                                    lambda: testMethod(*args, **kwargs))
-
-    def testAssertTrue(self):
-        self.assertMessages('assertTrue', (False,),
-                            ["^False is not True$", "^oops$", "^False is not True$",
-                             "^False is not True : oops$"])
-
-    def testAssertFalse(self):
-        self.assertMessages('assertFalse', (True,),
-                            ["^True is not False$", "^oops$", "^True is not False$",
-                             "^True is not False : oops$"])
-
-    def testNotEqual(self):
-        self.assertMessages('assertNotEqual', (1, 1),
-                            ["^1 == 1$", "^oops$", "^1 == 1$",
-                             "^1 == 1 : oops$"])
-
-    def testAlmostEqual(self):
-        self.assertMessages('assertAlmostEqual',
-                            (1,
-                             2),
-                            ["^1 != 2 within 7 places$",
-                             "^oops$",
-                             "^1 != 2 within 7 places$",
-                             "^1 != 2 within 7 places : oops$"])
-
-    def testNotAlmostEqual(self):
-        self.assertMessages('assertNotAlmostEqual',
-                            (1,
-                             1),
-                            ["^1 == 1 within 7 places$",
-                             "^oops$",
-                             "^1 == 1 within 7 places$",
-                             "^1 == 1 within 7 places : oops$"])
-
-    def test_baseAssertEqual(self):
-        self.assertMessages(
-            '_baseAssertEqual', (1, 2), [
-                "^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"])
-
-    def testAssertSequenceEqual(self):
-        # Error messages are multiline so not testing on full message
-        # assertTupleEqual and assertListEqual delegate to this method
-        self.assertMessages('assertSequenceEqual', ([], [None]),
-                            ["\+ \[None\]$", "^oops$", r"\+ \[None\]$",
-                             r"\+ \[None\] : oops$"])
-
-    def testAssertSetEqual(self):
-        self.assertMessages('assertSetEqual', (set(), set([None])),
-                            ["None$", "^oops$", "None$",
-                             "None : oops$"])
-
-    def testAssertIn(self):
-        self.assertMessages('assertIn', (None, []),
-                            ['^None not found in \[\]$', "^oops$",
-                             '^None not found in \[\]$',
-                             '^None not found in \[\] : oops$'])
-
-    def testAssertNotIn(self):
-        self.assertMessages('assertNotIn', (None, [None]),
-                            ['^None unexpectedly found in \[None\]$', "^oops$",
-                             '^None unexpectedly found in \[None\]$',
-                             '^None unexpectedly found in \[None\] : oops$'])
-
-    def testAssertDictEqual(self):
-        self.assertMessages('assertDictEqual', ({}, {'key': 'value'}),
-                            [r"\+ \{'key': 'value'\}$", "^oops$",
-                             "\+ \{'key': 'value'\}$",
-                             "\+ \{'key': 'value'\} : oops$"])
-
-    def testAssertDictContainsSubset(self):
-        self.assertMessages('assertDictContainsSubset', ({'key': 'value'}, {}),
-                            ["^Missing: 'key'$", "^oops$",
-                             "^Missing: 'key'$",
-                             "^Missing: 'key' : oops$"])
-
-    def testAssertItemsEqual(self):
-        self.assertMessages('assertItemsEqual', ([], [None]),
-                            [r"\[None\]$", "^oops$",
-                             r"\[None\]$",
-                             r"\[None\] : oops$"])
-
-    def testAssertMultiLineEqual(self):
-        self.assertMessages('assertMultiLineEqual', ("", "foo"),
-                            [r"\+ foo$", "^oops$",
-                             r"\+ foo$",
-                             r"\+ foo : oops$"])
-
-    def testAssertLess(self):
-        self.assertMessages('assertLess', (2, 1),
-                            ["^2 not less than 1$", "^oops$",
-                             "^2 not less than 1$", "^2 not less than 1 : oops$"])
-
-    def testAssertLessEqual(self):
-        self.assertMessages('assertLessEqual', (2, 1),
-                            ["^2 not less than or equal to 1$", "^oops$",
-                             "^2 not less than or equal to 1$",
-                             "^2 not less than or equal to 1 : oops$"])
-
-    def testAssertGreater(self):
-        self.assertMessages('assertGreater', (1, 2),
-                            ["^1 not greater than 2$", "^oops$",
-                             "^1 not greater than 2$",
-                             "^1 not greater than 2 : oops$"])
-
-    def testAssertGreaterEqual(self):
-        self.assertMessages('assertGreaterEqual', (1, 2),
-                            ["^1 not greater than or equal to 2$", "^oops$",
-                             "^1 not greater than or equal to 2$",
-                             "^1 not greater than or equal to 2 : oops$"])
-
-    def testAssertIsNone(self):
-        self.assertMessages('assertIsNone', ('not None',),
-                            ["^'not None' is not None$", "^oops$",
-                             "^'not None' is not None$",
-                             "^'not None' is not None : oops$"])
-
-    def testAssertIsNotNone(self):
-        self.assertMessages('assertIsNotNone', (None,),
-                            ["^unexpectedly None$", "^oops$",
-                             "^unexpectedly None$",
-                             "^unexpectedly None : oops$"])
-
-    def testAssertIs(self):
-        self.assertMessages('assertIs', (None, 'foo'),
-                            ["^None is not 'foo'$", "^oops$",
-                             "^None is not 'foo'$",
-                             "^None is not 'foo' : oops$"])
-
-    def testAssertIsNot(self):
-        self.assertMessages('assertIsNot', (None, None),
-                            ["^unexpectedly identical: None$", "^oops$",
-                             "^unexpectedly identical: None$",
-                             "^unexpectedly identical: None : oops$"])
-
-
-if __name__ == '__main__':
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_break.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_break.py
deleted file mode 100644
index 390718d..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_break.py
+++ /dev/null
@@ -1,258 +0,0 @@
-import gc
-import os
-import weakref
-
-from cStringIO import StringIO
-
-try:
-    import signal
-except ImportError:
-    signal = None
-
-import unittest2
-
-
-class TestBreak(unittest2.TestCase):
-
-    def setUp(self):
-        self._default_handler = signal.getsignal(signal.SIGINT)
-
-    def tearDown(self):
-        signal.signal(signal.SIGINT, self._default_handler)
-        unittest2.signals._results = weakref.WeakKeyDictionary()
-        unittest2.signals._interrupt_handler = None
-
-    def testInstallHandler(self):
-        default_handler = signal.getsignal(signal.SIGINT)
-        unittest2.installHandler()
-        self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)
-
-        try:
-            pid = os.getpid()
-            os.kill(pid, signal.SIGINT)
-        except KeyboardInterrupt:
-            self.fail("KeyboardInterrupt not handled")
-
-        self.assertTrue(unittest2.signals._interrupt_handler.called)
-
-    def testRegisterResult(self):
-        result = unittest2.TestResult()
-        unittest2.registerResult(result)
-
-        for ref in unittest2.signals._results:
-            if ref is result:
-                break
-            elif ref is not result:
-                self.fail("odd object in result set")
-        else:
-            self.fail("result not found")
-
-    def testInterruptCaught(self):
-        default_handler = signal.getsignal(signal.SIGINT)
-
-        result = unittest2.TestResult()
-        unittest2.installHandler()
-        unittest2.registerResult(result)
-
-        self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)
-
-        def test(result):
-            pid = os.getpid()
-            os.kill(pid, signal.SIGINT)
-            result.breakCaught = True
-            self.assertTrue(result.shouldStop)
-
-        try:
-            test(result)
-        except KeyboardInterrupt:
-            self.fail("KeyboardInterrupt not handled")
-        self.assertTrue(result.breakCaught)
-
-    def testSecondInterrupt(self):
-        result = unittest2.TestResult()
-        unittest2.installHandler()
-        unittest2.registerResult(result)
-
-        def test(result):
-            pid = os.getpid()
-            os.kill(pid, signal.SIGINT)
-            result.breakCaught = True
-            self.assertTrue(result.shouldStop)
-            os.kill(pid, signal.SIGINT)
-            self.fail("Second KeyboardInterrupt not raised")
-
-        try:
-            test(result)
-        except KeyboardInterrupt:
-            pass
-        else:
-            self.fail("Second KeyboardInterrupt not raised")
-        self.assertTrue(result.breakCaught)
-
-    def testTwoResults(self):
-        unittest2.installHandler()
-
-        result = unittest2.TestResult()
-        unittest2.registerResult(result)
-        new_handler = signal.getsignal(signal.SIGINT)
-
-        result2 = unittest2.TestResult()
-        unittest2.registerResult(result2)
-        self.assertEqual(signal.getsignal(signal.SIGINT), new_handler)
-
-        result3 = unittest2.TestResult()
-
-        def test(result):
-            pid = os.getpid()
-            os.kill(pid, signal.SIGINT)
-
-        try:
-            test(result)
-        except KeyboardInterrupt:
-            self.fail("KeyboardInterrupt not handled")
-
-        self.assertTrue(result.shouldStop)
-        self.assertTrue(result2.shouldStop)
-        self.assertFalse(result3.shouldStop)
-
-    def testHandlerReplacedButCalled(self):
-        # If our handler has been replaced (is no longer installed) but is
-        # called by the *new* handler, then it isn't safe to delay the
-        # SIGINT and we should immediately delegate to the default handler
-        unittest2.installHandler()
-
-        handler = signal.getsignal(signal.SIGINT)
-
-        def new_handler(frame, signum):
-            handler(frame, signum)
-        signal.signal(signal.SIGINT, new_handler)
-
-        try:
-            pid = os.getpid()
-            os.kill(pid, signal.SIGINT)
-        except KeyboardInterrupt:
-            pass
-        else:
-            self.fail("replaced but delegated handler doesn't raise interrupt")
-
-    def testRunner(self):
-        # Creating a TextTestRunner with the appropriate argument should
-        # register the TextTestResult it creates
-        runner = unittest2.TextTestRunner(stream=StringIO())
-
-        result = runner.run(unittest2.TestSuite())
-        self.assertIn(result, unittest2.signals._results)
-
-    def testWeakReferences(self):
-        # Calling registerResult on a result should not keep it alive
-        result = unittest2.TestResult()
-        unittest2.registerResult(result)
-
-        ref = weakref.ref(result)
-        del result
-
-        # For non-reference counting implementations
-        gc.collect()
-        gc.collect()
-        self.assertIsNone(ref())
-
-    def testRemoveResult(self):
-        result = unittest2.TestResult()
-        unittest2.registerResult(result)
-
-        unittest2.installHandler()
-        self.assertTrue(unittest2.removeResult(result))
-
-        # Should this raise an error instead?
-        self.assertFalse(unittest2.removeResult(unittest2.TestResult()))
-
-        try:
-            pid = os.getpid()
-            os.kill(pid, signal.SIGINT)
-        except KeyboardInterrupt:
-            pass
-
-        self.assertFalse(result.shouldStop)
-
-    def testMainInstallsHandler(self):
-        failfast = object()
-        test = object()
-        verbosity = object()
-        result = object()
-        default_handler = signal.getsignal(signal.SIGINT)
-
-        class FakeRunner(object):
-            initArgs = []
-            runArgs = []
-
-            def __init__(self, *args, **kwargs):
-                self.initArgs.append((args, kwargs))
-
-            def run(self, test):
-                self.runArgs.append(test)
-                return result
-
-        class Program(unittest2.TestProgram):
-
-            def __init__(self, catchbreak):
-                self.exit = False
-                self.verbosity = verbosity
-                self.failfast = failfast
-                self.catchbreak = catchbreak
-                self.testRunner = FakeRunner
-                self.test = test
-                self.result = None
-
-        p = Program(False)
-        p.runTests()
-
-        self.assertEqual(FakeRunner.initArgs, [((), {'verbosity': verbosity,
-                                                     'failfast': failfast,
-                                                     'buffer': None})])
-        self.assertEqual(FakeRunner.runArgs, [test])
-        self.assertEqual(p.result, result)
-
-        self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
-
-        FakeRunner.initArgs = []
-        FakeRunner.runArgs = []
-        p = Program(True)
-        p.runTests()
-
-        self.assertEqual(FakeRunner.initArgs, [((), {'verbosity': verbosity,
-                                                     'failfast': failfast,
-                                                     'buffer': None})])
-        self.assertEqual(FakeRunner.runArgs, [test])
-        self.assertEqual(p.result, result)
-
-        self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)
-
-    def testRemoveHandler(self):
-        default_handler = signal.getsignal(signal.SIGINT)
-        unittest2.installHandler()
-        unittest2.removeHandler()
-        self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
-
-        # check that calling removeHandler multiple times has no ill-effect
-        unittest2.removeHandler()
-        self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
-
-    def testRemoveHandlerAsDecorator(self):
-        default_handler = signal.getsignal(signal.SIGINT)
-        unittest2.installHandler()
-
-        @unittest2.removeHandler
-        def test():
-            self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
-
-        test()
-        self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)
-
-
-# Should also skip some tests on Jython
-skipper = unittest2.skipUnless(hasattr(os, 'kill') and signal is not None,
-                               "test uses os.kill(...) and the signal module")
-TestBreak = skipper(TestBreak)
-
-if __name__ == '__main__':
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_case.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_case.py
deleted file mode 100644
index 795fa39..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_case.py
+++ /dev/null
@@ -1,1244 +0,0 @@
-import difflib
-import pprint
-import re
-
-from copy import deepcopy
-
-import unittest2
-
-from unittest2.test.support import (
-    OldTestResult, EqualityMixin, HashingMixin, LoggingResult
-)
-
-
-class MyException(Exception):
-    pass
-
-
-class Test(object):
-    "Keep these TestCase classes out of the main namespace"
-
-    class Foo(unittest2.TestCase):
-
-        def runTest(self): pass
-
-        def test1(self): pass
-
-    class Bar(Foo):
-
-        def test2(self): pass
-
-    class LoggingTestCase(unittest2.TestCase):
-        """A test case which logs its calls."""
-
-        def __init__(self, events):
-            super(Test.LoggingTestCase, self).__init__('test')
-            self.events = events
-
-        def setUp(self):
-            self.events.append('setUp')
-
-        def test(self):
-            self.events.append('test')
-
-        def tearDown(self):
-            self.events.append('tearDown')
-
-
-class TestCleanUp(unittest2.TestCase):
-
-    def testCleanUp(self):
-        class TestableTest(unittest2.TestCase):
-
-            def testNothing(self):
-                pass
-
-        test = TestableTest('testNothing')
-        self.assertEqual(test._cleanups, [])
-
-        cleanups = []
-
-        def cleanup1(*args, **kwargs):
-            cleanups.append((1, args, kwargs))
-
-        def cleanup2(*args, **kwargs):
-            cleanups.append((2, args, kwargs))
-
-        test.addCleanup(cleanup1, 1, 2, 3, four='hello', five='goodbye')
-        test.addCleanup(cleanup2)
-
-        self.assertEqual(
-            test._cleanups, [
-                (cleanup1, (1, 2, 3), dict(
-                    four='hello', five='goodbye')), (cleanup2, (), {})])
-
-        result = test.doCleanups()
-        self.assertTrue(result)
-
-        self.assertEqual(
-            cleanups, [
-                (2, (), {}), (1, (1, 2, 3), dict(
-                    four='hello', five='goodbye'))])
-
-    def testCleanUpWithErrors(self):
-        class TestableTest(unittest2.TestCase):
-
-            def testNothing(self):
-                pass
-
-        class MockResult(object):
-            errors = []
-
-            def addError(self, test, exc_info):
-                self.errors.append((test, exc_info))
-
-        result = MockResult()
-        test = TestableTest('testNothing')
-        test._resultForDoCleanups = result
-
-        exc1 = Exception('foo')
-        exc2 = Exception('bar')
-
-        def cleanup1():
-            raise exc1
-
-        def cleanup2():
-            raise exc2
-
-        test.addCleanup(cleanup1)
-        test.addCleanup(cleanup2)
-
-        self.assertFalse(test.doCleanups())
-
-        (test1, (Type1, instance1, _)), (test2,
-                                         (Type2, instance2, _)) = reversed(MockResult.errors)
-        self.assertEqual((test1, Type1, instance1), (test, Exception, exc1))
-        self.assertEqual((test2, Type2, instance2), (test, Exception, exc2))
-
-    def testCleanupInRun(self):
-        blowUp = False
-        ordering = []
-
-        class TestableTest(unittest2.TestCase):
-
-            def setUp(self):
-                ordering.append('setUp')
-                if blowUp:
-                    raise Exception('foo')
-
-            def testNothing(self):
-                ordering.append('test')
-
-            def tearDown(self):
-                ordering.append('tearDown')
-
-        test = TestableTest('testNothing')
-
-        def cleanup1():
-            ordering.append('cleanup1')
-
-        def cleanup2():
-            ordering.append('cleanup2')
-        test.addCleanup(cleanup1)
-        test.addCleanup(cleanup2)
-
-        def success(some_test):
-            self.assertEqual(some_test, test)
-            ordering.append('success')
-
-        result = unittest2.TestResult()
-        result.addSuccess = success
-
-        test.run(result)
-        self.assertEqual(ordering, ['setUp', 'test', 'tearDown',
-                                    'cleanup2', 'cleanup1', 'success'])
-
-        blowUp = True
-        ordering = []
-        test = TestableTest('testNothing')
-        test.addCleanup(cleanup1)
-        test.run(result)
-        self.assertEqual(ordering, ['setUp', 'cleanup1'])
-
-    def testTestCaseDebugExecutesCleanups(self):
-        ordering = []
-
-        class TestableTest(unittest2.TestCase):
-
-            def setUp(self):
-                ordering.append('setUp')
-                self.addCleanup(cleanup1)
-
-            def testNothing(self):
-                ordering.append('test')
-
-            def tearDown(self):
-                ordering.append('tearDown')
-
-        test = TestableTest('testNothing')
-
-        def cleanup1():
-            ordering.append('cleanup1')
-            test.addCleanup(cleanup2)
-
-        def cleanup2():
-            ordering.append('cleanup2')
-
-        test.debug()
-        self.assertEqual(
-            ordering, [
-                'setUp', 'test', 'tearDown', 'cleanup1', 'cleanup2'])
-
-
-class Test_TestCase(unittest2.TestCase, EqualityMixin, HashingMixin):
-
-    # Set up attributes used by inherited tests
-    ################################################################
-
-    # Used by HashingMixin.test_hash and EqualityMixin.test_eq
-    eq_pairs = [(Test.Foo('test1'), Test.Foo('test1'))]
-
-    # Used by EqualityMixin.test_ne
-    ne_pairs = [(Test.Foo('test1'), Test.Foo('runTest')),
-                (Test.Foo('test1'), Test.Bar('test1')),
-                (Test.Foo('test1'), Test.Bar('test2'))]
-
-    ################################################################
-    # /Set up attributes used by inherited tests
-
-    # "class TestCase([methodName])"
-    # ...
-    # "Each instance of TestCase will run a single test method: the
-    # method named methodName."
-    # ...
-    # "methodName defaults to "runTest"."
-    #
-    # Make sure it really is optional, and that it defaults to the proper
-    # thing.
-    def test_init__no_test_name(self):
-        class Test(unittest2.TestCase):
-
-            def runTest(self): raise MyException()
-
-            def test(self): pass
-
-        self.assertEqual(Test().id()[-13:], '.Test.runTest')
-
-    # "class TestCase([methodName])"
-    # ...
-    # "Each instance of TestCase will run a single test method: the
-    # method named methodName."
-    def test_init__test_name__valid(self):
-        class Test(unittest2.TestCase):
-
-            def runTest(self): raise MyException()
-
-            def test(self): pass
-
-        self.assertEqual(Test('test').id()[-10:], '.Test.test')
-
-    # "class unittest2.TestCase([methodName])"
-    # ...
-    # "Each instance of TestCase will run a single test method: the
-    # method named methodName."
-    def test_init__test_name__invalid(self):
-        class Test(unittest2.TestCase):
-
-            def runTest(self): raise MyException()
-
-            def test(self): pass
-
-        try:
-            Test('testfoo')
-        except ValueError:
-            pass
-        else:
-            self.fail("Failed to raise ValueError")
-
-    # "Return the number of tests represented by the this test object. For
-    # TestCase instances, this will always be 1"
-    def test_countTestCases(self):
-        class Foo(unittest2.TestCase):
-
-            def test(self): pass
-
-        self.assertEqual(Foo('test').countTestCases(), 1)
-
-    # "Return the default type of test result object to be used to run this
-    # test. For TestCase instances, this will always be
-    # unittest2.TestResult;  subclasses of TestCase should
-    # override this as necessary."
-    def test_defaultTestResult(self):
-        class Foo(unittest2.TestCase):
-
-            def runTest(self):
-                pass
-
-        result = Foo().defaultTestResult()
-        self.assertEqual(type(result), unittest2.TestResult)
-
-    # "When a setUp() method is defined, the test runner will run that method
-    # prior to each test. Likewise, if a tearDown() method is defined, the
-    # test runner will invoke that method after each test. In the example,
-    # setUp() was used to create a fresh sequence for each test."
-    #
-    # Make sure the proper call order is maintained, even if setUp() raises
-    # an exception.
-    def test_run_call_order__error_in_setUp(self):
-        events = []
-        result = LoggingResult(events)
-
-        class Foo(Test.LoggingTestCase):
-
-            def setUp(self):
-                super(Foo, self).setUp()
-                raise RuntimeError('raised by Foo.setUp')
-
-        Foo(events).run(result)
-        expected = ['startTest', 'setUp', 'addError', 'stopTest']
-        self.assertEqual(events, expected)
-
-    # "With a temporary result stopTestRun is called when setUp errors.
-    def test_run_call_order__error_in_setUp_default_result(self):
-        events = []
-
-        class Foo(Test.LoggingTestCase):
-
-            def defaultTestResult(self):
-                return LoggingResult(self.events)
-
-            def setUp(self):
-                super(Foo, self).setUp()
-                raise RuntimeError('raised by Foo.setUp')
-
-        Foo(events).run()
-        expected = ['startTestRun', 'startTest', 'setUp', 'addError',
-                    'stopTest', 'stopTestRun']
-        self.assertEqual(events, expected)
-
-    # "When a setUp() method is defined, the test runner will run that method
-    # prior to each test. Likewise, if a tearDown() method is defined, the
-    # test runner will invoke that method after each test. In the example,
-    # setUp() was used to create a fresh sequence for each test."
-    #
-    # Make sure the proper call order is maintained, even if the test raises
-    # an error (as opposed to a failure).
-    def test_run_call_order__error_in_test(self):
-        events = []
-        result = LoggingResult(events)
-
-        class Foo(Test.LoggingTestCase):
-
-            def test(self):
-                super(Foo, self).test()
-                raise RuntimeError('raised by Foo.test')
-
-        expected = ['startTest', 'setUp', 'test', 'addError', 'tearDown',
-                    'stopTest']
-        Foo(events).run(result)
-        self.assertEqual(events, expected)
-
-    # "With a default result, an error in the test still results in stopTestRun
-    # being called."
-    def test_run_call_order__error_in_test_default_result(self):
-        events = []
-
-        class Foo(Test.LoggingTestCase):
-
-            def defaultTestResult(self):
-                return LoggingResult(self.events)
-
-            def test(self):
-                super(Foo, self).test()
-                raise RuntimeError('raised by Foo.test')
-
-        expected = ['startTestRun', 'startTest', 'setUp', 'test', 'addError',
-                    'tearDown', 'stopTest', 'stopTestRun']
-        Foo(events).run()
-        self.assertEqual(events, expected)
-
-    # "When a setUp() method is defined, the test runner will run that method
-    # prior to each test. Likewise, if a tearDown() method is defined, the
-    # test runner will invoke that method after each test. In the example,
-    # setUp() was used to create a fresh sequence for each test."
-    #
-    # Make sure the proper call order is maintained, even if the test signals
-    # a failure (as opposed to an error).
-    def test_run_call_order__failure_in_test(self):
-        events = []
-        result = LoggingResult(events)
-
-        class Foo(Test.LoggingTestCase):
-
-            def test(self):
-                super(Foo, self).test()
-                self.fail('raised by Foo.test')
-
-        expected = ['startTest', 'setUp', 'test', 'addFailure', 'tearDown',
-                    'stopTest']
-        Foo(events).run(result)
-        self.assertEqual(events, expected)
-
-    # "When a test fails with a default result stopTestRun is still called."
-    def test_run_call_order__failure_in_test_default_result(self):
-
-        class Foo(Test.LoggingTestCase):
-
-            def defaultTestResult(self):
-                return LoggingResult(self.events)
-
-            def test(self):
-                super(Foo, self).test()
-                self.fail('raised by Foo.test')
-
-        expected = ['startTestRun', 'startTest', 'setUp', 'test', 'addFailure',
-                    'tearDown', 'stopTest', 'stopTestRun']
-        events = []
-        Foo(events).run()
-        self.assertEqual(events, expected)
-
-    # "When a setUp() method is defined, the test runner will run that method
-    # prior to each test. Likewise, if a tearDown() method is defined, the
-    # test runner will invoke that method after each test. In the example,
-    # setUp() was used to create a fresh sequence for each test."
-    #
-    # Make sure the proper call order is maintained, even if tearDown() raises
-    # an exception.
-    def test_run_call_order__error_in_tearDown(self):
-        events = []
-        result = LoggingResult(events)
-
-        class Foo(Test.LoggingTestCase):
-
-            def tearDown(self):
-                super(Foo, self).tearDown()
-                raise RuntimeError('raised by Foo.tearDown')
-
-        Foo(events).run(result)
-        expected = ['startTest', 'setUp', 'test', 'tearDown', 'addError',
-                    'stopTest']
-        self.assertEqual(events, expected)
-
-    # "When tearDown errors with a default result stopTestRun is still called."
-    def test_run_call_order__error_in_tearDown_default_result(self):
-
-        class Foo(Test.LoggingTestCase):
-
-            def defaultTestResult(self):
-                return LoggingResult(self.events)
-
-            def tearDown(self):
-                super(Foo, self).tearDown()
-                raise RuntimeError('raised by Foo.tearDown')
-
-        events = []
-        Foo(events).run()
-        expected = ['startTestRun', 'startTest', 'setUp', 'test', 'tearDown',
-                    'addError', 'stopTest', 'stopTestRun']
-        self.assertEqual(events, expected)
-
-    # "TestCase.run() still works when the defaultTestResult is a TestResult
-    # that does not support startTestRun and stopTestRun.
-    def test_run_call_order_default_result(self):
-
-        class Foo(unittest2.TestCase):
-
-            def defaultTestResult(self):
-                return OldTestResult()
-
-            def test(self):
-                pass
-
-        Foo('test').run()
-
-    # "This class attribute gives the exception raised by the test() method.
-    # If a test framework needs to use a specialized exception, possibly to
-    # carry additional information, it must subclass this exception in
-    # order to ``play fair'' with the framework.  The initial value of this
-    # attribute is AssertionError"
-    def test_failureException__default(self):
-        class Foo(unittest2.TestCase):
-
-            def test(self):
-                pass
-
-        self.assertTrue(Foo('test').failureException is AssertionError)
-
-    # "This class attribute gives the exception raised by the test() method.
-    # If a test framework needs to use a specialized exception, possibly to
-    # carry additional information, it must subclass this exception in
-    # order to ``play fair'' with the framework."
-    #
-    # Make sure TestCase.run() respects the designated failureException
-    def test_failureException__subclassing__explicit_raise(self):
-        events = []
-        result = LoggingResult(events)
-
-        class Foo(unittest2.TestCase):
-
-            def test(self):
-                raise RuntimeError()
-
-            failureException = RuntimeError
-
-        self.assertTrue(Foo('test').failureException is RuntimeError)
-
-        Foo('test').run(result)
-        expected = ['startTest', 'addFailure', 'stopTest']
-        self.assertEqual(events, expected)
-
-    # "This class attribute gives the exception raised by the test() method.
-    # If a test framework needs to use a specialized exception, possibly to
-    # carry additional information, it must subclass this exception in
-    # order to ``play fair'' with the framework."
-    #
-    # Make sure TestCase.run() respects the designated failureException
-    def test_failureException__subclassing__implicit_raise(self):
-        events = []
-        result = LoggingResult(events)
-
-        class Foo(unittest2.TestCase):
-
-            def test(self):
-                self.fail("foo")
-
-            failureException = RuntimeError
-
-        self.assertTrue(Foo('test').failureException is RuntimeError)
-
-        Foo('test').run(result)
-        expected = ['startTest', 'addFailure', 'stopTest']
-        self.assertEqual(events, expected)
-
-    # "The default implementation does nothing."
-    def test_setUp(self):
-        class Foo(unittest2.TestCase):
-
-            def runTest(self):
-                pass
-
-        # ... and nothing should happen
-        Foo().setUp()
-
-    # "The default implementation does nothing."
-    def test_tearDown(self):
-        class Foo(unittest2.TestCase):
-
-            def runTest(self):
-                pass
-
-        # ... and nothing should happen
-        Foo().tearDown()
-
-    # "Return a string identifying the specific test case."
-    #
-    # 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):
-        class Foo(unittest2.TestCase):
-
-            def runTest(self):
-                pass
-
-        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 = []
-
-        class Foo(unittest2.TestCase):
-
-            def test(self):
-                events.append('test')
-
-            def defaultTestResult(self):
-                return LoggingResult(events)
-
-        # Make run() find a result object on its own
-        Foo('test').run()
-
-        expected = ['startTestRun', 'startTest', 'test', 'addSuccess',
-                    'stopTest', 'stopTestRun']
-        self.assertEqual(events, expected)
-
-    def testShortDescriptionWithoutDocstring(self):
-        self.assertIsNone(self.shortDescription())
-
-    def testShortDescriptionWithOneLineDocstring(self):
-        """Tests shortDescription() for a method with a docstring."""
-        self.assertEqual(
-            self.shortDescription(),
-            'Tests shortDescription() for a method with a docstring.')
-
-    def testShortDescriptionWithMultiLineDocstring(self):
-        """Tests shortDescription() for a method with a longer docstring.
-
-        This method ensures that only the first line of a docstring is
-        returned used in the short description, no matter how long the
-        whole thing is.
-        """
-        self.assertEqual(
-            self.shortDescription(),
-            'Tests shortDescription() for a method with a longer '
-            'docstring.')
-
-    def testAddTypeEqualityFunc(self):
-        class SadSnake(object):
-            """Dummy class for test_addTypeEqualityFunc."""
-        s1, s2 = SadSnake(), SadSnake()
-        self.assertNotEqual(s1, s2)
-
-        def AllSnakesCreatedEqual(a, b, msg=None):
-            return type(a) is type(b) is SadSnake
-        self.addTypeEqualityFunc(SadSnake, AllSnakesCreatedEqual)
-        self.assertEqual(s1, s2)
-        # No this doesn't clean up and remove the SadSnake equality func
-        # from this TestCase instance but since its a local nothing else
-        # will ever notice that.
-
-    def testAssertIs(self):
-        thing = object()
-        self.assertIs(thing, thing)
-        self.assertRaises(
-            self.failureException,
-            self.assertIs,
-            thing,
-            object())
-
-    def testAssertIsNot(self):
-        thing = object()
-        self.assertIsNot(thing, object())
-        self.assertRaises(
-            self.failureException,
-            self.assertIsNot,
-            thing,
-            thing)
-
-    def testAssertIsInstance(self):
-        thing = []
-        self.assertIsInstance(thing, list)
-        self.assertRaises(self.failureException, self.assertIsInstance,
-                          thing, dict)
-
-    def testAssertNotIsInstance(self):
-        thing = []
-        self.assertNotIsInstance(thing, dict)
-        self.assertRaises(self.failureException, self.assertNotIsInstance,
-                          thing, list)
-
-    def testAssertIn(self):
-        animals = {'monkey': 'banana', 'cow': 'grass', 'seal': 'fish'}
-
-        self.assertIn('a', 'abc')
-        self.assertIn(2, [1, 2, 3])
-        self.assertIn('monkey', animals)
-
-        self.assertNotIn('d', 'abc')
-        self.assertNotIn(0, [1, 2, 3])
-        self.assertNotIn('otter', animals)
-
-        self.assertRaises(self.failureException, self.assertIn, 'x', 'abc')
-        self.assertRaises(self.failureException, self.assertIn, 4, [1, 2, 3])
-        self.assertRaises(self.failureException, self.assertIn, 'elephant',
-                          animals)
-
-        self.assertRaises(self.failureException, self.assertNotIn, 'c', 'abc')
-        self.assertRaises(
-            self.failureException, self.assertNotIn, 1, [
-                1, 2, 3])
-        self.assertRaises(self.failureException, self.assertNotIn, 'cow',
-                          animals)
-
-    def testAssertDictContainsSubset(self):
-        self.assertDictContainsSubset({}, {})
-        self.assertDictContainsSubset({}, {'a': 1})
-        self.assertDictContainsSubset({'a': 1}, {'a': 1})
-        self.assertDictContainsSubset({'a': 1}, {'a': 1, 'b': 2})
-        self.assertDictContainsSubset({'a': 1, 'b': 2}, {'a': 1, 'b': 2})
-
-        self.assertRaises(unittest2.TestCase.failureException,
-                          self.assertDictContainsSubset, {'a': 2}, {'a': 1},
-                          '.*Mismatched values:.*')
-
-        self.assertRaises(unittest2.TestCase.failureException,
-                          self.assertDictContainsSubset, {'c': 1}, {'a': 1},
-                          '.*Missing:.*')
-
-        self.assertRaises(unittest2.TestCase.failureException,
-                          self.assertDictContainsSubset, {'a': 1, 'c': 1},
-                          {'a': 1}, '.*Missing:.*')
-
-        self.assertRaises(unittest2.TestCase.failureException,
-                          self.assertDictContainsSubset, {'a': 1, 'c': 1},
-                          {'a': 1}, '.*Missing:.*Mismatched values:.*')
-
-        self.assertRaises(self.failureException,
-                          self.assertDictContainsSubset, {1: "one"}, {})
-
-    def testAssertEqual(self):
-        equal_pairs = [
-            ((), ()),
-            ({}, {}),
-            ([], []),
-            (set(), set()),
-            (frozenset(), frozenset())]
-        for a, b in equal_pairs:
-            # This mess of try excepts is to test the assertEqual behavior
-            # itself.
-            try:
-                self.assertEqual(a, b)
-            except self.failureException:
-                self.fail('assertEqual(%r, %r) failed' % (a, b))
-            try:
-                self.assertEqual(a, b, msg='foo')
-            except self.failureException:
-                self.fail('assertEqual(%r, %r) with msg= failed' % (a, b))
-            try:
-                self.assertEqual(a, b, 'foo')
-            except self.failureException:
-                self.fail('assertEqual(%r, %r) with third parameter failed' %
-                          (a, b))
-
-        unequal_pairs = [
-            ((), []),
-            ({}, set()),
-            (set([4, 1]), frozenset([4, 2])),
-            (frozenset([4, 5]), set([2, 3])),
-            (set([3, 4]), set([5, 4]))]
-        for a, b in unequal_pairs:
-            self.assertRaises(self.failureException, self.assertEqual, a, b)
-            self.assertRaises(self.failureException, self.assertEqual, a, b,
-                              'foo')
-            self.assertRaises(self.failureException, self.assertEqual, a, b,
-                              msg='foo')
-
-    def testEquality(self):
-        self.assertListEqual([], [])
-        self.assertTupleEqual((), ())
-        self.assertSequenceEqual([], ())
-
-        a = [0, 'a', []]
-        b = []
-        self.assertRaises(unittest2.TestCase.failureException,
-                          self.assertListEqual, a, b)
-        self.assertRaises(unittest2.TestCase.failureException,
-                          self.assertListEqual, tuple(a), tuple(b))
-        self.assertRaises(unittest2.TestCase.failureException,
-                          self.assertSequenceEqual, a, tuple(b))
-
-        b.extend(a)
-        self.assertListEqual(a, b)
-        self.assertTupleEqual(tuple(a), tuple(b))
-        self.assertSequenceEqual(a, tuple(b))
-        self.assertSequenceEqual(tuple(a), b)
-
-        self.assertRaises(self.failureException, self.assertListEqual,
-                          a, tuple(b))
-        self.assertRaises(self.failureException, self.assertTupleEqual,
-                          tuple(a), b)
-        self.assertRaises(self.failureException, self.assertListEqual, None, b)
-        self.assertRaises(self.failureException, self.assertTupleEqual, None,
-                          tuple(b))
-        self.assertRaises(self.failureException, self.assertSequenceEqual,
-                          None, tuple(b))
-        self.assertRaises(self.failureException, self.assertListEqual, 1, 1)
-        self.assertRaises(self.failureException, self.assertTupleEqual, 1, 1)
-        self.assertRaises(self.failureException, self.assertSequenceEqual,
-                          1, 1)
-
-        self.assertDictEqual({}, {})
-
-        c = {'x': 1}
-        d = {}
-        self.assertRaises(unittest2.TestCase.failureException,
-                          self.assertDictEqual, c, d)
-
-        d.update(c)
-        self.assertDictEqual(c, d)
-
-        d['x'] = 0
-        self.assertRaises(unittest2.TestCase.failureException,
-                          self.assertDictEqual, c, d, 'These are unequal')
-
-        self.assertRaises(self.failureException, self.assertDictEqual, None, d)
-        self.assertRaises(self.failureException, self.assertDictEqual, [], d)
-        self.assertRaises(self.failureException, self.assertDictEqual, 1, 1)
-
-    def testAssertItemsEqual(self):
-        self.assertItemsEqual([1, 2, 3], [3, 2, 1])
-        self.assertItemsEqual(['foo', 'bar', 'baz'], ['bar', 'baz', 'foo'])
-        self.assertRaises(self.failureException, self.assertItemsEqual,
-                          [10], [10, 11])
-        self.assertRaises(self.failureException, self.assertItemsEqual,
-                          [10, 11], [10])
-        self.assertRaises(self.failureException, self.assertItemsEqual,
-                          [10, 11, 10], [10, 11])
-
-        # Test that sequences of unhashable objects can be tested for sameness:
-        self.assertItemsEqual([[1, 2], [3, 4]], [[3, 4], [1, 2]])
-
-        self.assertItemsEqual([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}])
-        self.assertRaises(self.failureException, self.assertItemsEqual,
-                          [[1]], [[2]])
-
-        # Test unsortable objects
-        self.assertItemsEqual([2j, None], [None, 2j])
-        self.assertRaises(self.failureException, self.assertItemsEqual,
-                          [2j, None], [None, 3j])
-
-    def testAssertSetEqual(self):
-        set1 = set()
-        set2 = set()
-        self.assertSetEqual(set1, set2)
-
-        self.assertRaises(
-            self.failureException,
-            self.assertSetEqual,
-            None,
-            set2)
-        self.assertRaises(self.failureException, self.assertSetEqual, [], set2)
-        self.assertRaises(
-            self.failureException,
-            self.assertSetEqual,
-            set1,
-            None)
-        self.assertRaises(self.failureException, self.assertSetEqual, set1, [])
-
-        set1 = set(['a'])
-        set2 = set()
-        self.assertRaises(
-            self.failureException,
-            self.assertSetEqual,
-            set1,
-            set2)
-
-        set1 = set(['a'])
-        set2 = set(['a'])
-        self.assertSetEqual(set1, set2)
-
-        set1 = set(['a'])
-        set2 = set(['a', 'b'])
-        self.assertRaises(
-            self.failureException,
-            self.assertSetEqual,
-            set1,
-            set2)
-
-        set1 = set(['a'])
-        set2 = frozenset(['a', 'b'])
-        self.assertRaises(
-            self.failureException,
-            self.assertSetEqual,
-            set1,
-            set2)
-
-        set1 = set(['a', 'b'])
-        set2 = frozenset(['a', 'b'])
-        self.assertSetEqual(set1, set2)
-
-        set1 = set()
-        set2 = "foo"
-        self.assertRaises(
-            self.failureException,
-            self.assertSetEqual,
-            set1,
-            set2)
-        self.assertRaises(
-            self.failureException,
-            self.assertSetEqual,
-            set2,
-            set1)
-
-        # make sure any string formatting is tuple-safe
-        set1 = set([(0, 1), (2, 3)])
-        set2 = set([(4, 5)])
-        self.assertRaises(
-            self.failureException,
-            self.assertSetEqual,
-            set1,
-            set2)
-
-    def testInequality(self):
-        # Try ints
-        self.assertGreater(2, 1)
-        self.assertGreaterEqual(2, 1)
-        self.assertGreaterEqual(1, 1)
-        self.assertLess(1, 2)
-        self.assertLessEqual(1, 2)
-        self.assertLessEqual(1, 1)
-        self.assertRaises(self.failureException, self.assertGreater, 1, 2)
-        self.assertRaises(self.failureException, self.assertGreater, 1, 1)
-        self.assertRaises(self.failureException, self.assertGreaterEqual, 1, 2)
-        self.assertRaises(self.failureException, self.assertLess, 2, 1)
-        self.assertRaises(self.failureException, self.assertLess, 1, 1)
-        self.assertRaises(self.failureException, self.assertLessEqual, 2, 1)
-
-        # Try Floats
-        self.assertGreater(1.1, 1.0)
-        self.assertGreaterEqual(1.1, 1.0)
-        self.assertGreaterEqual(1.0, 1.0)
-        self.assertLess(1.0, 1.1)
-        self.assertLessEqual(1.0, 1.1)
-        self.assertLessEqual(1.0, 1.0)
-        self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.1)
-        self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.0)
-        self.assertRaises(
-            self.failureException,
-            self.assertGreaterEqual,
-            1.0,
-            1.1)
-        self.assertRaises(self.failureException, self.assertLess, 1.1, 1.0)
-        self.assertRaises(self.failureException, self.assertLess, 1.0, 1.0)
-        self.assertRaises(
-            self.failureException,
-            self.assertLessEqual,
-            1.1,
-            1.0)
-
-        # Try Strings
-        self.assertGreater('bug', 'ant')
-        self.assertGreaterEqual('bug', 'ant')
-        self.assertGreaterEqual('ant', 'ant')
-        self.assertLess('ant', 'bug')
-        self.assertLessEqual('ant', 'bug')
-        self.assertLessEqual('ant', 'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertGreater,
-            'ant',
-            'bug')
-        self.assertRaises(
-            self.failureException,
-            self.assertGreater,
-            'ant',
-            'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertGreaterEqual,
-            'ant',
-            'bug')
-        self.assertRaises(self.failureException, self.assertLess, 'bug', 'ant')
-        self.assertRaises(self.failureException, self.assertLess, 'ant', 'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertLessEqual,
-            'bug',
-            'ant')
-
-        # Try Unicode
-        self.assertGreater(u'bug', u'ant')
-        self.assertGreaterEqual(u'bug', u'ant')
-        self.assertGreaterEqual(u'ant', u'ant')
-        self.assertLess(u'ant', u'bug')
-        self.assertLessEqual(u'ant', u'bug')
-        self.assertLessEqual(u'ant', u'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertGreater,
-            u'ant',
-            u'bug')
-        self.assertRaises(
-            self.failureException,
-            self.assertGreater,
-            u'ant',
-            u'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertGreaterEqual,
-            u'ant',
-            u'bug')
-        self.assertRaises(
-            self.failureException,
-            self.assertLess,
-            u'bug',
-            u'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertLess,
-            u'ant',
-            u'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertLessEqual,
-            u'bug',
-            u'ant')
-
-        # Try Mixed String/Unicode
-        self.assertGreater('bug', u'ant')
-        self.assertGreater(u'bug', 'ant')
-        self.assertGreaterEqual('bug', u'ant')
-        self.assertGreaterEqual(u'bug', 'ant')
-        self.assertGreaterEqual('ant', u'ant')
-        self.assertGreaterEqual(u'ant', 'ant')
-        self.assertLess('ant', u'bug')
-        self.assertLess(u'ant', 'bug')
-        self.assertLessEqual('ant', u'bug')
-        self.assertLessEqual(u'ant', 'bug')
-        self.assertLessEqual('ant', u'ant')
-        self.assertLessEqual(u'ant', 'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertGreater,
-            'ant',
-            u'bug')
-        self.assertRaises(
-            self.failureException,
-            self.assertGreater,
-            u'ant',
-            'bug')
-        self.assertRaises(
-            self.failureException,
-            self.assertGreater,
-            'ant',
-            u'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertGreater,
-            u'ant',
-            'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertGreaterEqual,
-            'ant',
-            u'bug')
-        self.assertRaises(
-            self.failureException,
-            self.assertGreaterEqual,
-            u'ant',
-            'bug')
-        self.assertRaises(
-            self.failureException,
-            self.assertLess,
-            'bug',
-            u'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertLess,
-            u'bug',
-            'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertLess,
-            'ant',
-            u'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertLess,
-            u'ant',
-            'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertLessEqual,
-            'bug',
-            u'ant')
-        self.assertRaises(
-            self.failureException,
-            self.assertLessEqual,
-            u'bug',
-            'ant')
-
-    def testAssertMultiLineEqual(self):
-        sample_text = """\
-http://www.python.org/doc/2.3/lib/module-unittest.html
-test case
-    A test case is the smallest unit of testing. [...]
-"""
-        revised_sample_text = """\
-http://www.python.org/doc/2.4.1/lib/module-unittest.html
-test case
-    A test case is the smallest unit of testing. [...] You may provide your
-    own implementation that does not subclass from TestCase, of course.
-"""
-        sample_text_error = """\
-- http://www.python.org/doc/2.3/lib/module-unittest.html
-?                             ^
-+ http://www.python.org/doc/2.4.1/lib/module-unittest.html
-?                             ^^^
-  test case
--     A test case is the smallest unit of testing. [...]
-+     A test case is the smallest unit of testing. [...] You may provide your
-?                                                       +++++++++++++++++++++
-+     own implementation that does not subclass from TestCase, of course.
-"""
-        self.maxDiff = None
-        for type_changer in (lambda x: x, lambda x: x.decode('utf8')):
-            try:
-                self.assertMultiLineEqual(type_changer(sample_text),
-                                          type_changer(revised_sample_text))
-            except self.failureException as e:
-                # need to remove the first line of the error message
-                error = str(e).encode('utf8').split('\n', 1)[1]
-
-                # assertMultiLineEqual is hooked up as the default for
-                # unicode strings - so we can't use it for this check
-                self.assertTrue(sample_text_error == error)
-
-    def testAssertSequenceEqualMaxDiff(self):
-        self.assertEqual(self.maxDiff, 80 * 8)
-        seq1 = 'a' + 'x' * 80**2
-        seq2 = 'b' + 'x' * 80**2
-        diff = '\n'.join(difflib.ndiff(pprint.pformat(seq1).splitlines(),
-                                       pprint.pformat(seq2).splitlines()))
-        # the +1 is the leading \n added by assertSequenceEqual
-        omitted = unittest2.case.DIFF_OMITTED % (len(diff) + 1,)
-
-        self.maxDiff = len(diff) // 2
-        try:
-            self.assertSequenceEqual(seq1, seq2)
-        except self.failureException as e:
-            msg = e.args[0]
-        else:
-            self.fail('assertSequenceEqual did not fail.')
-        self.assertTrue(len(msg) < len(diff))
-        self.assertIn(omitted, msg)
-
-        self.maxDiff = len(diff) * 2
-        try:
-            self.assertSequenceEqual(seq1, seq2)
-        except self.failureException as e:
-            msg = e.args[0]
-        else:
-            self.fail('assertSequenceEqual did not fail.')
-        self.assertTrue(len(msg) > len(diff))
-        self.assertNotIn(omitted, msg)
-
-        self.maxDiff = None
-        try:
-            self.assertSequenceEqual(seq1, seq2)
-        except self.failureException as e:
-            msg = e.args[0]
-        else:
-            self.fail('assertSequenceEqual did not fail.')
-        self.assertTrue(len(msg) > len(diff))
-        self.assertNotIn(omitted, msg)
-
-    def testTruncateMessage(self):
-        self.maxDiff = 1
-        message = self._truncateMessage('foo', 'bar')
-        omitted = unittest2.case.DIFF_OMITTED % len('bar')
-        self.assertEqual(message, 'foo' + omitted)
-
-        self.maxDiff = None
-        message = self._truncateMessage('foo', 'bar')
-        self.assertEqual(message, 'foobar')
-
-        self.maxDiff = 4
-        message = self._truncateMessage('foo', 'bar')
-        self.assertEqual(message, 'foobar')
-
-    def testAssertDictEqualTruncates(self):
-        test = unittest2.TestCase('assertEqual')
-
-        def truncate(msg, diff):
-            return 'foo'
-        test._truncateMessage = truncate
-        try:
-            test.assertDictEqual({}, {1: 0})
-        except self.failureException as e:
-            self.assertEqual(str(e), 'foo')
-        else:
-            self.fail('assertDictEqual did not fail')
-
-    def testAssertMultiLineEqualTruncates(self):
-        test = unittest2.TestCase('assertEqual')
-
-        def truncate(msg, diff):
-            return 'foo'
-        test._truncateMessage = truncate
-        try:
-            test.assertMultiLineEqual('foo', 'bar')
-        except self.failureException as e:
-            self.assertEqual(str(e), 'foo')
-        else:
-            self.fail('assertMultiLineEqual did not fail')
-
-    def testAssertIsNone(self):
-        self.assertIsNone(None)
-        self.assertRaises(self.failureException, self.assertIsNone, False)
-        self.assertIsNotNone('DjZoPloGears on Rails')
-        self.assertRaises(self.failureException, self.assertIsNotNone, None)
-
-    def testAssertRegexpMatches(self):
-        self.assertRegexpMatches('asdfabasdf', r'ab+')
-        self.assertRaises(self.failureException, self.assertRegexpMatches,
-                          'saaas', r'aaaa')
-
-    def testAssertRaisesRegexp(self):
-        class ExceptionMock(Exception):
-            pass
-
-        def Stub():
-            raise ExceptionMock('We expect')
-
-        self.assertRaisesRegexp(ExceptionMock, re.compile('expect$'), Stub)
-        self.assertRaisesRegexp(ExceptionMock, 'expect$', Stub)
-        self.assertRaisesRegexp(ExceptionMock, u'expect$', Stub)
-
-    def testAssertNotRaisesRegexp(self):
-        self.assertRaisesRegexp(
-            self.failureException, '^Exception not raised$',
-            self.assertRaisesRegexp, Exception, re.compile('x'),
-            lambda: None)
-        self.assertRaisesRegexp(
-            self.failureException, '^Exception not raised$',
-            self.assertRaisesRegexp, Exception, 'x',
-            lambda: None)
-        self.assertRaisesRegexp(
-            self.failureException, '^Exception not raised$',
-            self.assertRaisesRegexp, Exception, u'x',
-            lambda: None)
-
-    def testAssertRaisesRegexpMismatch(self):
-        def Stub():
-            raise Exception('Unexpected')
-
-        self.assertRaisesRegexp(
-            self.failureException,
-            r'"\^Expected\$" does not match "Unexpected"',
-            self.assertRaisesRegexp, Exception, '^Expected$',
-            Stub)
-        self.assertRaisesRegexp(
-            self.failureException,
-            r'"\^Expected\$" does not match "Unexpected"',
-            self.assertRaisesRegexp, Exception, u'^Expected$',
-            Stub)
-        self.assertRaisesRegexp(
-            self.failureException,
-            r'"\^Expected\$" does not match "Unexpected"',
-            self.assertRaisesRegexp, Exception,
-            re.compile('^Expected$'), Stub)
-
-    def testSynonymAssertMethodNames(self):
-        """Test undocumented method name synonyms.
-
-        Please do not use these methods names in your own code.
-
-        This test confirms their continued existence and functionality
-        in order to avoid breaking existing code.
-        """
-        self.assertNotEquals(3, 5)
-        self.assertEquals(3, 3)
-        self.assertAlmostEquals(2.0, 2.0)
-        self.assertNotAlmostEquals(3.0, 5.0)
-        self.assert_(True)
-
-    def testDeepcopy(self):
-        # Issue: 5660
-        class TestableTest(unittest2.TestCase):
-
-            def testNothing(self):
-                pass
-
-        test = TestableTest('testNothing')
-
-        # This shouldn't blow up
-        deepcopy(test)
-
-
-if __name__ == "__main__":
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_discovery.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_discovery.py
deleted file mode 100644
index 70bc588..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_discovery.py
+++ /dev/null
@@ -1,392 +0,0 @@
-import os
-import re
-import sys
-
-import unittest2
-
-
-class TestDiscovery(unittest2.TestCase):
-
-    # Heavily mocked tests so I can avoid hitting the filesystem
-    def test_get_name_from_path(self):
-        loader = unittest2.TestLoader()
-
-        loader._top_level_dir = '/foo'
-        name = loader._get_name_from_path('/foo/bar/baz.py')
-        self.assertEqual(name, 'bar.baz')
-
-        if not __debug__:
-            # asserts are off
-            return
-
-        self.assertRaises(AssertionError,
-                          loader._get_name_from_path,
-                          '/bar/baz.py')
-
-    def test_find_tests(self):
-        loader = unittest2.TestLoader()
-
-        original_listdir = os.listdir
-
-        def restore_listdir():
-            os.listdir = original_listdir
-        original_isfile = os.path.isfile
-
-        def restore_isfile():
-            os.path.isfile = original_isfile
-        original_isdir = os.path.isdir
-
-        def restore_isdir():
-            os.path.isdir = original_isdir
-
-        path_lists = [['test1.py', 'test2.py', 'not_a_test.py', 'test_dir',
-                       'test.foo', 'test-not-a-module.py', 'another_dir'],
-                      ['test3.py', 'test4.py', ]]
-        os.listdir = lambda path: path_lists.pop(0)
-        self.addCleanup(restore_listdir)
-
-        def isdir(path):
-            return path.endswith('dir')
-        os.path.isdir = isdir
-        self.addCleanup(restore_isdir)
-
-        def isfile(path):
-            # another_dir is not a package and so shouldn't be recursed into
-            return not path.endswith('dir') and not 'another_dir' in path
-        os.path.isfile = isfile
-        self.addCleanup(restore_isfile)
-
-        loader._get_module_from_name = lambda path: path + ' module'
-        loader.loadTestsFromModule = lambda module: module + ' tests'
-
-        top_level = os.path.abspath('/foo')
-        loader._top_level_dir = top_level
-        suite = list(loader._find_tests(top_level, 'test*.py'))
-
-        expected = [name + ' module tests' for name in
-                    ('test1', 'test2')]
-        expected.extend([('test_dir.%s' % name) + ' module tests' for name in
-                         ('test3', 'test4')])
-        self.assertEqual(suite, expected)
-
-    def test_find_tests_with_package(self):
-        loader = unittest2.TestLoader()
-
-        original_listdir = os.listdir
-
-        def restore_listdir():
-            os.listdir = original_listdir
-        original_isfile = os.path.isfile
-
-        def restore_isfile():
-            os.path.isfile = original_isfile
-        original_isdir = os.path.isdir
-
-        def restore_isdir():
-            os.path.isdir = original_isdir
-
-        directories = ['a_directory', 'test_directory', 'test_directory2']
-        path_lists = [directories, [], [], []]
-        os.listdir = lambda path: path_lists.pop(0)
-        self.addCleanup(restore_listdir)
-
-        os.path.isdir = lambda path: True
-        self.addCleanup(restore_isdir)
-
-        os.path.isfile = lambda path: os.path.basename(path) not in directories
-        self.addCleanup(restore_isfile)
-
-        class Module(object):
-            paths = []
-            load_tests_args = []
-
-            def __init__(self, path):
-                self.path = path
-                self.paths.append(path)
-                if os.path.basename(path) == 'test_directory':
-                    def load_tests(loader, tests, pattern):
-                        self.load_tests_args.append((loader, tests, pattern))
-                        return 'load_tests'
-                    self.load_tests = load_tests
-
-            def __eq__(self, other):
-                return self.path == other.path
-
-            # Silence py3k warning
-            __hash__ = None
-
-        loader._get_module_from_name = lambda name: Module(name)
-
-        def loadTestsFromModule(module, use_load_tests):
-            if use_load_tests:
-                raise self.failureException(
-                    'use_load_tests should be False for packages')
-            return module.path + ' module tests'
-        loader.loadTestsFromModule = loadTestsFromModule
-
-        loader._top_level_dir = '/foo'
-        # this time no '.py' on the pattern so that it can match
-        # a test package
-        suite = list(loader._find_tests('/foo', 'test*'))
-
-        # We should have loaded tests from the test_directory package by calling load_tests
-        # and directly from the test_directory2 package
-        self.assertEqual(suite,
-                         ['load_tests', 'test_directory2' + ' module tests'])
-        self.assertEqual(Module.paths, ['test_directory', 'test_directory2'])
-
-        # load_tests should have been called once with loader, tests and
-        # pattern
-        self.assertEqual(
-            Module.load_tests_args, [
-                (loader, 'test_directory' + ' module tests', 'test*')])
-
-    def test_discover(self):
-        loader = unittest2.TestLoader()
-
-        original_isfile = os.path.isfile
-        original_isdir = os.path.isdir
-
-        def restore_isfile():
-            os.path.isfile = original_isfile
-
-        os.path.isfile = lambda path: False
-        self.addCleanup(restore_isfile)
-
-        orig_sys_path = sys.path[:]
-
-        def restore_path():
-            sys.path[:] = orig_sys_path
-        self.addCleanup(restore_path)
-
-        full_path = os.path.abspath(os.path.normpath('/foo'))
-        self.assertRaises(ImportError,
-                          loader.discover,
-                          '/foo/bar', top_level_dir='/foo')
-
-        self.assertEqual(loader._top_level_dir, full_path)
-        self.assertIn(full_path, sys.path)
-
-        os.path.isfile = lambda path: True
-        os.path.isdir = lambda path: True
-
-        def restore_isdir():
-            os.path.isdir = original_isdir
-        self.addCleanup(restore_isdir)
-
-        _find_tests_args = []
-
-        def _find_tests(start_dir, pattern):
-            _find_tests_args.append((start_dir, pattern))
-            return ['tests']
-        loader._find_tests = _find_tests
-        loader.suiteClass = str
-
-        suite = loader.discover('/foo/bar/baz', 'pattern', '/foo/bar')
-
-        top_level_dir = os.path.abspath(os.path.normpath('/foo/bar'))
-        start_dir = os.path.abspath(os.path.normpath('/foo/bar/baz'))
-        self.assertEqual(suite, "['tests']")
-        self.assertEqual(loader._top_level_dir, top_level_dir)
-        self.assertEqual(_find_tests_args, [(start_dir, 'pattern')])
-        self.assertIn(top_level_dir, sys.path)
-
-    def test_discover_with_modules_that_fail_to_import(self):
-        loader = unittest2.TestLoader()
-
-        listdir = os.listdir
-        os.listdir = lambda _: ['test_this_does_not_exist.py']
-        isfile = os.path.isfile
-        os.path.isfile = lambda _: True
-        orig_sys_path = sys.path[:]
-
-        def restore():
-            os.path.isfile = isfile
-            os.listdir = listdir
-            sys.path[:] = orig_sys_path
-        self.addCleanup(restore)
-
-        suite = loader.discover('.')
-        self.assertIn(os.getcwd(), sys.path)
-        self.assertEqual(suite.countTestCases(), 1)
-        test = list(list(suite)[0])[0]  # extract test from suite
-
-        self.assertRaises(ImportError,
-                          lambda: test.test_this_does_not_exist())
-
-    def test_command_line_handling_parseArgs(self):
-        # Haha - take that uninstantiable class
-        program = object.__new__(unittest2.TestProgram)
-
-        args = []
-
-        def do_discovery(argv):
-            args.extend(argv)
-        program._do_discovery = do_discovery
-        program.parseArgs(['something', 'discover'])
-        self.assertEqual(args, [])
-
-        program.parseArgs(['something', 'discover', 'foo', 'bar'])
-        self.assertEqual(args, ['foo', 'bar'])
-
-    def test_command_line_handling_do_discovery_too_many_arguments(self):
-        class Stop(Exception):
-            pass
-
-        def usageExit():
-            raise Stop
-
-        program = object.__new__(unittest2.TestProgram)
-        program.usageExit = usageExit
-
-        self.assertRaises(Stop,
-                          # too many args
-                          lambda: program._do_discovery(['one', 'two', 'three', 'four']))
-
-    def test_command_line_handling_do_discovery_calls_loader(self):
-        program = object.__new__(unittest2.TestProgram)
-
-        class Loader(object):
-            args = []
-
-            def discover(self, start_dir, pattern, top_level_dir):
-                self.args.append((start_dir, pattern, top_level_dir))
-                return 'tests'
-
-        program._do_discovery(['-v'], Loader=Loader)
-        self.assertEqual(program.verbosity, 2)
-        self.assertEqual(program.test, 'tests')
-        self.assertEqual(Loader.args, [('.', 'test*.py', None)])
-
-        Loader.args = []
-        program = object.__new__(unittest2.TestProgram)
-        program._do_discovery(['--verbose'], Loader=Loader)
-        self.assertEqual(program.test, 'tests')
-        self.assertEqual(Loader.args, [('.', 'test*.py', None)])
-
-        Loader.args = []
-        program = object.__new__(unittest2.TestProgram)
-        program._do_discovery([], Loader=Loader)
-        self.assertEqual(program.test, 'tests')
-        self.assertEqual(Loader.args, [('.', 'test*.py', None)])
-
-        Loader.args = []
-        program = object.__new__(unittest2.TestProgram)
-        program._do_discovery(['fish'], Loader=Loader)
-        self.assertEqual(program.test, 'tests')
-        self.assertEqual(Loader.args, [('fish', 'test*.py', None)])
-
-        Loader.args = []
-        program = object.__new__(unittest2.TestProgram)
-        program._do_discovery(['fish', 'eggs'], Loader=Loader)
-        self.assertEqual(program.test, 'tests')
-        self.assertEqual(Loader.args, [('fish', 'eggs', None)])
-
-        Loader.args = []
-        program = object.__new__(unittest2.TestProgram)
-        program._do_discovery(['fish', 'eggs', 'ham'], Loader=Loader)
-        self.assertEqual(program.test, 'tests')
-        self.assertEqual(Loader.args, [('fish', 'eggs', 'ham')])
-
-        Loader.args = []
-        program = object.__new__(unittest2.TestProgram)
-        program._do_discovery(['-s', 'fish'], Loader=Loader)
-        self.assertEqual(program.test, 'tests')
-        self.assertEqual(Loader.args, [('fish', 'test*.py', None)])
-
-        Loader.args = []
-        program = object.__new__(unittest2.TestProgram)
-        program._do_discovery(['-t', 'fish'], Loader=Loader)
-        self.assertEqual(program.test, 'tests')
-        self.assertEqual(Loader.args, [('.', 'test*.py', 'fish')])
-
-        Loader.args = []
-        program = object.__new__(unittest2.TestProgram)
-        program._do_discovery(['-p', 'fish'], Loader=Loader)
-        self.assertEqual(program.test, 'tests')
-        self.assertEqual(Loader.args, [('.', 'fish', None)])
-        self.assertFalse(program.failfast)
-        self.assertFalse(program.catchbreak)
-
-        args = ['-p', 'eggs', '-s', 'fish', '-v', '-f']
-        try:
-            import signal
-        except ImportError:
-            signal = None
-        else:
-            args.append('-c')
-        Loader.args = []
-        program = object.__new__(unittest2.TestProgram)
-        program._do_discovery(args, Loader=Loader)
-        self.assertEqual(program.test, 'tests')
-        self.assertEqual(Loader.args, [('fish', 'eggs', None)])
-        self.assertEqual(program.verbosity, 2)
-        self.assertTrue(program.failfast)
-        if signal is not None:
-            self.assertTrue(program.catchbreak)
-
-    def test_detect_module_clash(self):
-        class Module(object):
-            __file__ = 'bar/foo.py'
-        sys.modules['foo'] = Module
-        full_path = os.path.abspath('foo')
-        original_listdir = os.listdir
-        original_isfile = os.path.isfile
-        original_isdir = os.path.isdir
-
-        def cleanup():
-            os.listdir = original_listdir
-            os.path.isfile = original_isfile
-            os.path.isdir = original_isdir
-            del sys.modules['foo']
-            if full_path in sys.path:
-                sys.path.remove(full_path)
-        self.addCleanup(cleanup)
-
-        def listdir(_):
-            return ['foo.py']
-
-        def isfile(_):
-            return True
-
-        def isdir(_):
-            return True
-        os.listdir = listdir
-        os.path.isfile = isfile
-        os.path.isdir = isdir
-
-        loader = unittest2.TestLoader()
-
-        mod_dir = os.path.abspath('bar')
-        expected_dir = os.path.abspath('foo')
-        msg = re.escape(
-            r"'foo' module incorrectly imported from %r. Expected %r. "
-            "Is this module globally installed?" %
-            (mod_dir, expected_dir))
-        self.assertRaisesRegexp(
-            ImportError, '^%s$' % msg, loader.discover,
-            start_dir='foo', pattern='foo.py'
-        )
-        self.assertEqual(sys.path[0], full_path)
-
-    def test_discovery_from_dotted_path(self):
-        loader = unittest2.TestLoader()
-
-        tests = [self]
-        expectedPath = os.path.abspath(
-            os.path.dirname(unittest2.test.__file__))
-
-        self.wasRun = False
-
-        def _find_tests(start_dir, pattern):
-            self.wasRun = True
-            self.assertEqual(start_dir, expectedPath)
-            return tests
-        loader._find_tests = _find_tests
-        suite = loader.discover('unittest2.test')
-        self.assertTrue(self.wasRun)
-        self.assertEqual(suite._tests, tests)
-
-
-if __name__ == '__main__':
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_functiontestcase.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_functiontestcase.py
deleted file mode 100644
index 9bafb54..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_functiontestcase.py
+++ /dev/null
@@ -1,148 +0,0 @@
-import unittest2
-
-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"
-    def test_countTestCases(self):
-        test = unittest2.FunctionTestCase(lambda: None)
-
-        self.assertEqual(test.countTestCases(), 1)
-
-    # "When a setUp() method is defined, the test runner will run that method
-    # prior to each test. Likewise, if a tearDown() method is defined, the
-    # test runner will invoke that method after each test. In the example,
-    # setUp() was used to create a fresh sequence for each test."
-    #
-    # Make sure the proper call order is maintained, even if setUp() raises
-    # an exception.
-    def test_run_call_order__error_in_setUp(self):
-        events = []
-        result = LoggingResult(events)
-
-        def setUp():
-            events.append('setUp')
-            raise RuntimeError('raised by setUp')
-
-        def test():
-            events.append('test')
-
-        def tearDown():
-            events.append('tearDown')
-
-        expected = ['startTest', 'setUp', 'addError', 'stopTest']
-        unittest2.FunctionTestCase(test, setUp, tearDown).run(result)
-        self.assertEqual(events, expected)
-
-    # "When a setUp() method is defined, the test runner will run that method
-    # prior to each test. Likewise, if a tearDown() method is defined, the
-    # test runner will invoke that method after each test. In the example,
-    # setUp() was used to create a fresh sequence for each test."
-    #
-    # Make sure the proper call order is maintained, even if the test raises
-    # an error (as opposed to a failure).
-    def test_run_call_order__error_in_test(self):
-        events = []
-        result = LoggingResult(events)
-
-        def setUp():
-            events.append('setUp')
-
-        def test():
-            events.append('test')
-            raise RuntimeError('raised by test')
-
-        def tearDown():
-            events.append('tearDown')
-
-        expected = ['startTest', 'setUp', 'test', 'addError', 'tearDown',
-                    'stopTest']
-        unittest2.FunctionTestCase(test, setUp, tearDown).run(result)
-        self.assertEqual(events, expected)
-
-    # "When a setUp() method is defined, the test runner will run that method
-    # prior to each test. Likewise, if a tearDown() method is defined, the
-    # test runner will invoke that method after each test. In the example,
-    # setUp() was used to create a fresh sequence for each test."
-    #
-    # Make sure the proper call order is maintained, even if the test signals
-    # a failure (as opposed to an error).
-    def test_run_call_order__failure_in_test(self):
-        events = []
-        result = LoggingResult(events)
-
-        def setUp():
-            events.append('setUp')
-
-        def test():
-            events.append('test')
-            self.fail('raised by test')
-
-        def tearDown():
-            events.append('tearDown')
-
-        expected = ['startTest', 'setUp', 'test', 'addFailure', 'tearDown',
-                    'stopTest']
-        unittest2.FunctionTestCase(test, setUp, tearDown).run(result)
-        self.assertEqual(events, expected)
-
-    # "When a setUp() method is defined, the test runner will run that method
-    # prior to each test. Likewise, if a tearDown() method is defined, the
-    # test runner will invoke that method after each test. In the example,
-    # setUp() was used to create a fresh sequence for each test."
-    #
-    # Make sure the proper call order is maintained, even if tearDown() raises
-    # an exception.
-    def test_run_call_order__error_in_tearDown(self):
-        events = []
-        result = LoggingResult(events)
-
-        def setUp():
-            events.append('setUp')
-
-        def test():
-            events.append('test')
-
-        def tearDown():
-            events.append('tearDown')
-            raise RuntimeError('raised by tearDown')
-
-        expected = ['startTest', 'setUp', 'test', 'tearDown', 'addError',
-                    'stopTest']
-        unittest2.FunctionTestCase(test, setUp, tearDown).run(result)
-        self.assertEqual(events, expected)
-
-    # "Return a string identifying the specific test case."
-    #
-    # 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(), 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)
-
-    # "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__singleline_docstring(self):
-        desc = "this tests foo"
-        test = unittest2.FunctionTestCase(lambda: None, description=desc)
-
-        self.assertEqual(test.shortDescription(), "this tests foo")
-
-
-if __name__ == '__main__':
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_loader.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_loader.py
deleted file mode 100644
index 45fea56..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_loader.py
+++ /dev/null
@@ -1,1380 +0,0 @@
-import sys
-import types
-
-import unittest2
-
-
-class Test_TestLoader(unittest2.TestCase):
-
-    # Tests for TestLoader.loadTestsFromTestCase
-    ################################################################
-
-    # "Return a suite of all tests cases contained in the TestCase-derived
-    # class testCaseClass"
-    def test_loadTestsFromTestCase(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-            def foo_bar(self): pass
-
-        tests = unittest2.TestSuite([Foo('test_1'), Foo('test_2')])
-
-        loader = unittest2.TestLoader()
-        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)
-
-    # "Return a suite of all tests cases contained in the TestCase-derived
-    # class testCaseClass"
-    #
-    # Make sure it does the right thing even if no tests were found
-    def test_loadTestsFromTestCase__no_matches(self):
-        class Foo(unittest2.TestCase):
-
-            def foo_bar(self): pass
-
-        empty_suite = unittest2.TestSuite()
-
-        loader = unittest2.TestLoader()
-        self.assertEqual(loader.loadTestsFromTestCase(Foo), empty_suite)
-
-    # "Return a suite of all tests cases contained in the TestCase-derived
-    # class testCaseClass"
-    #
-    # What happens if loadTestsFromTestCase() is given an object
-    # that isn't a subclass of TestCase? Specifically, what happens
-    # if testCaseClass is a subclass of TestSuite?
-    #
-    # This is checked for specifically in the code, so we better add a
-    # test for it.
-    def test_loadTestsFromTestCase__TestSuite_subclass(self):
-        class NotATestCase(unittest2.TestSuite):
-            pass
-
-        loader = unittest2.TestLoader()
-        try:
-            loader.loadTestsFromTestCase(NotATestCase)
-        except TypeError:
-            pass
-        else:
-            self.fail('Should raise TypeError')
-
-    # "Return a suite of all tests cases contained in the TestCase-derived
-    # class testCaseClass"
-    #
-    # Make sure loadTestsFromTestCase() picks up the default test method
-    # name (as specified by TestCase), even though the method name does
-    # not match the default TestLoader.testMethodPrefix string
-    def test_loadTestsFromTestCase__default_method_name(self):
-        class Foo(unittest2.TestCase):
-
-            def runTest(self):
-                pass
-
-        loader = unittest2.TestLoader()
-        # This has to be false for the test to succeed
-        self.assertFalse('runTest'.startswith(loader.testMethodPrefix))
-
-        suite = loader.loadTestsFromTestCase(Foo)
-        self.assertIsInstance(suite, loader.suiteClass)
-        self.assertEqual(list(suite), [Foo('runTest')])
-
-    ################################################################
-    # /Tests for TestLoader.loadTestsFromTestCase
-
-    # Tests for TestLoader.loadTestsFromModule
-    ################################################################
-
-    # "This method searches `module` for classes derived from TestCase"
-    def test_loadTestsFromModule__TestCase_subclass(self):
-        m = types.ModuleType('m')
-
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromModule(m)
-        self.assertIsInstance(suite, loader.suiteClass)
-
-        expected = [loader.suiteClass([MyTestCase('test')])]
-        self.assertEqual(list(suite), expected)
-
-    # "This method searches `module` for classes derived from TestCase"
-    #
-    # What happens if no tests are found (no TestCase instances)?
-    def test_loadTestsFromModule__no_TestCase_instances(self):
-        m = types.ModuleType('m')
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromModule(m)
-        self.assertIsInstance(suite, loader.suiteClass)
-        self.assertEqual(list(suite), [])
-
-    # "This method searches `module` for classes derived from TestCase"
-    #
-    # What happens if no tests are found (TestCases instances, but no tests)?
-    def test_loadTestsFromModule__no_TestCase_tests(self):
-        m = types.ModuleType('m')
-
-        class MyTestCase(unittest2.TestCase):
-            pass
-        m.testcase_1 = MyTestCase
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromModule(m)
-        self.assertIsInstance(suite, loader.suiteClass)
-
-        self.assertEqual(list(suite), [loader.suiteClass()])
-
-    # "This method searches `module` for classes derived from TestCase"s
-    #
-    # What happens if loadTestsFromModule() is given something other
-    # than a module?
-    #
-    # XXX Currently, it succeeds anyway. This flexibility
-    # should either be documented or loadTestsFromModule() should
-    # raise a TypeError
-    #
-    # XXX Certain people are using this behaviour. We'll add a test for it
-    def test_loadTestsFromModule__not_a_module(self):
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-
-        class NotAModule(object):
-            test_2 = MyTestCase
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromModule(NotAModule)
-
-        reference = [unittest2.TestSuite([MyTestCase('test')])]
-        self.assertEqual(list(suite), reference)
-
-    # Check that loadTestsFromModule honors (or not) a module
-    # with a load_tests function.
-    def test_loadTestsFromModule__load_tests(self):
-        m = types.ModuleType('m')
-
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        load_tests_args = []
-
-        def load_tests(loader, tests, pattern):
-            self.assertIsInstance(tests, unittest2.TestSuite)
-            load_tests_args.extend((loader, tests, pattern))
-            return tests
-        m.load_tests = load_tests
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromModule(m)
-        self.assertIsInstance(suite, unittest2.TestSuite)
-        self.assertEquals(load_tests_args, [loader, suite, None])
-
-        load_tests_args = []
-        suite = loader.loadTestsFromModule(m, use_load_tests=False)
-        self.assertEquals(load_tests_args, [])
-
-    def test_loadTestsFromModule__faulty_load_tests(self):
-        m = types.ModuleType('m')
-
-        def load_tests(loader, tests, pattern):
-            raise TypeError('some failure')
-        m.load_tests = load_tests
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromModule(m)
-        self.assertIsInstance(suite, unittest2.TestSuite)
-        self.assertEqual(suite.countTestCases(), 1)
-        test = list(suite)[0]
-
-        self.assertRaisesRegexp(TypeError, "some failure", test.m)
-
-    ################################################################
-    # /Tests for TestLoader.loadTestsFromModule()
-
-    # Tests for TestLoader.loadTestsFromName()
-    ################################################################
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    #
-    # Is ValueError raised in response to an empty name?
-    def test_loadTestsFromName__empty_name(self):
-        loader = unittest2.TestLoader()
-
-        try:
-            loader.loadTestsFromName('')
-        except ValueError as e:
-            self.assertEqual(str(e), "Empty module name")
-        else:
-            self.fail("TestLoader.loadTestsFromName failed to raise ValueError")
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    #
-    # What happens when the name contains invalid characters?
-    def test_loadTestsFromName__malformed_name(self):
-        loader = unittest2.TestLoader()
-
-        # XXX Should this raise ValueError or ImportError?
-        try:
-            loader.loadTestsFromName('abc () //')
-        except ValueError:
-            pass
-        except ImportError:
-            pass
-        else:
-            self.fail("TestLoader.loadTestsFromName failed to raise ValueError")
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to a
-    # module"
-    #
-    # What happens when a module by that name can't be found?
-    def test_loadTestsFromName__unknown_module_name(self):
-        loader = unittest2.TestLoader()
-
-        try:
-            loader.loadTestsFromName('sdasfasfasdf')
-        except ImportError as e:
-            self.assertEqual(str(e), "No module named sdasfasfasdf")
-        else:
-            self.fail("TestLoader.loadTestsFromName failed to raise ImportError")
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    #
-    # What happens when the module is found, but the attribute can't?
-    def test_loadTestsFromName__unknown_attr_name(self):
-        loader = unittest2.TestLoader()
-
-        try:
-            loader.loadTestsFromName('unittest2.sdasfasfasdf')
-        except AttributeError as e:
-            self.assertEqual(
-                str(e), "'module' object has no attribute 'sdasfasfasdf'")
-        else:
-            self.fail(
-                "TestLoader.loadTestsFromName failed to raise AttributeError")
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    #
-    # What happens when we provide the module, but the attribute can't be
-    # found?
-    def test_loadTestsFromName__relative_unknown_name(self):
-        loader = unittest2.TestLoader()
-
-        try:
-            loader.loadTestsFromName('sdasfasfasdf', unittest2)
-        except AttributeError as e:
-            self.assertEqual(
-                str(e), "'module' object has no attribute 'sdasfasfasdf'")
-        else:
-            self.fail(
-                "TestLoader.loadTestsFromName failed to raise AttributeError")
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    # ...
-    # "The method optionally resolves name relative to the given module"
-    #
-    # Does loadTestsFromName raise ValueError when passed an empty
-    # name relative to a provided module?
-    #
-    # XXX Should probably raise a ValueError instead of an AttributeError
-    def test_loadTestsFromName__relative_empty_name(self):
-        loader = unittest2.TestLoader()
-
-        try:
-            loader.loadTestsFromName('', unittest2)
-        except AttributeError:
-            pass
-        else:
-            self.fail("Failed to raise AttributeError")
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    # ...
-    # "The method optionally resolves name relative to the given module"
-    #
-    # What happens when an impossible name is given, relative to the provided
-    # `module`?
-    def test_loadTestsFromName__relative_malformed_name(self):
-        loader = unittest2.TestLoader()
-
-        # XXX Should this raise AttributeError or ValueError?
-        try:
-            loader.loadTestsFromName('abc () //', unittest2)
-        except ValueError:
-            pass
-        except AttributeError:
-            pass
-        else:
-            self.fail("TestLoader.loadTestsFromName failed to raise ValueError")
-
-    # "The method optionally resolves name relative to the given module"
-    #
-    # Does loadTestsFromName raise TypeError when the `module` argument
-    # isn't a module object?
-    #
-    # XXX Accepts the not-a-module object, ignorning the object's type
-    # This should raise an exception or the method name should be changed
-    #
-    # XXX Some people are relying on this, so keep it for now
-    def test_loadTestsFromName__relative_not_a_module(self):
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-
-        class NotAModule(object):
-            test_2 = MyTestCase
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromName('test_2', NotAModule)
-
-        reference = [MyTestCase('test')]
-        self.assertEqual(list(suite), reference)
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    #
-    # Does it raise an exception if the name resolves to an invalid
-    # object?
-    def test_loadTestsFromName__relative_bad_object(self):
-        m = types.ModuleType('m')
-        m.testcase_1 = object()
-
-        loader = unittest2.TestLoader()
-        try:
-            loader.loadTestsFromName('testcase_1', m)
-        except TypeError:
-            pass
-        else:
-            self.fail("Should have raised TypeError")
-
-    # "The specifier name is a ``dotted name'' that may
-    # resolve either to ... a test case class"
-    def test_loadTestsFromName__relative_TestCase_subclass(self):
-        m = types.ModuleType('m')
-
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromName('testcase_1', m)
-        self.assertIsInstance(suite, loader.suiteClass)
-        self.assertEqual(list(suite), [MyTestCase('test')])
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    def test_loadTestsFromName__relative_TestSuite(self):
-        m = types.ModuleType('m')
-
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-        m.testsuite = unittest2.TestSuite([MyTestCase('test')])
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromName('testsuite', m)
-        self.assertIsInstance(suite, loader.suiteClass)
-
-        self.assertEqual(list(suite), [MyTestCase('test')])
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to
-    # ... a test method within a test case class"
-    def test_loadTestsFromName__relative_testmethod(self):
-        m = types.ModuleType('m')
-
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromName('testcase_1.test', m)
-        self.assertIsInstance(suite, loader.suiteClass)
-
-        self.assertEqual(list(suite), [MyTestCase('test')])
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    #
-    # Does loadTestsFromName() raise the proper exception when trying to
-    # resolve "a test method within a test case class" that doesn't exist
-    # for the given name (relative to a provided module)?
-    def test_loadTestsFromName__relative_invalid_testmethod(self):
-        m = types.ModuleType('m')
-
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        loader = unittest2.TestLoader()
-        try:
-            loader.loadTestsFromName('testcase_1.testfoo', m)
-        except AttributeError as e:
-            self.assertEqual(
-                str(e), "type object 'MyTestCase' has no attribute 'testfoo'")
-        else:
-            self.fail("Failed to raise AttributeError")
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to
-    # ... a callable object which returns a ... TestSuite instance"
-    def test_loadTestsFromName__callable__TestSuite(self):
-        m = types.ModuleType('m')
-        testcase_1 = unittest2.FunctionTestCase(lambda: None)
-        testcase_2 = unittest2.FunctionTestCase(lambda: None)
-
-        def return_TestSuite():
-            return unittest2.TestSuite([testcase_1, testcase_2])
-        m.return_TestSuite = return_TestSuite
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromName('return_TestSuite', m)
-        self.assertIsInstance(suite, loader.suiteClass)
-        self.assertEqual(list(suite), [testcase_1, testcase_2])
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to
-    # ... a callable object which returns a TestCase ... instance"
-    def test_loadTestsFromName__callable__TestCase_instance(self):
-        m = types.ModuleType('m')
-        testcase_1 = unittest2.FunctionTestCase(lambda: None)
-
-        def return_TestCase():
-            return testcase_1
-        m.return_TestCase = return_TestCase
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromName('return_TestCase', m)
-        self.assertIsInstance(suite, loader.suiteClass)
-        self.assertEqual(list(suite), [testcase_1])
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to
-    # ... a callable object which returns a TestCase ... instance"
-    #*****************************************************************
-    # Override the suiteClass attribute to ensure that the suiteClass
-    #attribute is used
-    def test_loadTestsFromName__callable__TestCase_instance_ProperSuiteClass(
-            self):
-        class SubTestSuite(unittest2.TestSuite):
-            pass
-        m = types.ModuleType('m')
-        testcase_1 = unittest2.FunctionTestCase(lambda: None)
-
-        def return_TestCase():
-            return testcase_1
-        m.return_TestCase = return_TestCase
-
-        loader = unittest2.TestLoader()
-        loader.suiteClass = SubTestSuite
-        suite = loader.loadTestsFromName('return_TestCase', m)
-        self.assertIsInstance(suite, loader.suiteClass)
-        self.assertEqual(list(suite), [testcase_1])
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to
-    # ... a test method within a test case class"
-    #*****************************************************************
-    # Override the suiteClass attribute to ensure that the suiteClass
-    #attribute is used
-    def test_loadTestsFromName__relative_testmethod_ProperSuiteClass(self):
-        class SubTestSuite(unittest2.TestSuite):
-            pass
-        m = types.ModuleType('m')
-
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        loader = unittest2.TestLoader()
-        loader.suiteClass = SubTestSuite
-        suite = loader.loadTestsFromName('testcase_1.test', m)
-        self.assertIsInstance(suite, loader.suiteClass)
-
-        self.assertEqual(list(suite), [MyTestCase('test')])
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to
-    # ... a callable object which returns a TestCase or TestSuite instance"
-    #
-    # What happens if the callable returns something else?
-    def test_loadTestsFromName__callable__wrong_type(self):
-        m = types.ModuleType('m')
-
-        def return_wrong():
-            return 6
-        m.return_wrong = return_wrong
-
-        loader = unittest2.TestLoader()
-        try:
-            loader.loadTestsFromName('return_wrong', m)
-        except TypeError:
-            pass
-        else:
-            self.fail("TestLoader.loadTestsFromName failed to raise TypeError")
-
-    # "The specifier can refer to modules and packages which have not been
-    # imported; they will be imported as a side-effect"
-    def test_loadTestsFromName__module_not_loaded(self):
-        # We're going to try to load this module as a side-effect, so it
-        # better not be loaded before we try.
-        #
-        module_name = 'unittest2.test.dummy'
-        sys.modules.pop(module_name, None)
-
-        loader = unittest2.TestLoader()
-        try:
-            suite = loader.loadTestsFromName(module_name)
-
-            self.assertIsInstance(suite, loader.suiteClass)
-            self.assertEqual(list(suite), [])
-
-            # module should now be loaded, thanks to loadTestsFromName()
-            self.assertIn(module_name, sys.modules)
-        finally:
-            if module_name in sys.modules:
-                del sys.modules[module_name]
-
-    ################################################################
-    # Tests for TestLoader.loadTestsFromName()
-
-    # Tests for TestLoader.loadTestsFromNames()
-    ################################################################
-
-    # "Similar to loadTestsFromName(), but takes a sequence of names rather
-    # than a single name."
-    #
-    # What happens if that sequence of names is empty?
-    def test_loadTestsFromNames__empty_name_list(self):
-        loader = unittest2.TestLoader()
-
-        suite = loader.loadTestsFromNames([])
-        self.assertIsInstance(suite, loader.suiteClass)
-        self.assertEqual(list(suite), [])
-
-    # "Similar to loadTestsFromName(), but takes a sequence of names rather
-    # than a single name."
-    # ...
-    # "The method optionally resolves name relative to the given module"
-    #
-    # What happens if that sequence of names is empty?
-    #
-    # XXX Should this raise a ValueError or just return an empty TestSuite?
-    def test_loadTestsFromNames__relative_empty_name_list(self):
-        loader = unittest2.TestLoader()
-
-        suite = loader.loadTestsFromNames([], unittest2)
-        self.assertIsInstance(suite, loader.suiteClass)
-        self.assertEqual(list(suite), [])
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    #
-    # Is ValueError raised in response to an empty name?
-    def test_loadTestsFromNames__empty_name(self):
-        loader = unittest2.TestLoader()
-
-        try:
-            loader.loadTestsFromNames([''])
-        except ValueError as e:
-            self.assertEqual(str(e), "Empty module name")
-        else:
-            self.fail("TestLoader.loadTestsFromNames failed to raise ValueError")
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    #
-    # What happens when presented with an impossible module name?
-    def test_loadTestsFromNames__malformed_name(self):
-        loader = unittest2.TestLoader()
-
-        # XXX Should this raise ValueError or ImportError?
-        try:
-            loader.loadTestsFromNames(['abc () //'])
-        except ValueError:
-            pass
-        except ImportError:
-            pass
-        else:
-            self.fail("TestLoader.loadTestsFromNames failed to raise ValueError")
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    #
-    # What happens when no module can be found for the given name?
-    def test_loadTestsFromNames__unknown_module_name(self):
-        loader = unittest2.TestLoader()
-
-        try:
-            loader.loadTestsFromNames(['sdasfasfasdf'])
-        except ImportError as e:
-            self.assertEqual(str(e), "No module named sdasfasfasdf")
-        else:
-            self.fail("TestLoader.loadTestsFromNames failed to raise ImportError")
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    #
-    # What happens when the module can be found, but not the attribute?
-    def test_loadTestsFromNames__unknown_attr_name(self):
-        loader = unittest2.TestLoader()
-
-        try:
-            loader.loadTestsFromNames(['unittest2.sdasfasfasdf', 'unittest2'])
-        except AttributeError as e:
-            self.assertEqual(
-                str(e), "'module' object has no attribute 'sdasfasfasdf'")
-        else:
-            self.fail(
-                "TestLoader.loadTestsFromNames failed to raise AttributeError")
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    # ...
-    # "The method optionally resolves name relative to the given module"
-    #
-    # What happens when given an unknown attribute on a specified `module`
-    # argument?
-    def test_loadTestsFromNames__unknown_name_relative_1(self):
-        loader = unittest2.TestLoader()
-
-        try:
-            loader.loadTestsFromNames(['sdasfasfasdf'], unittest2)
-        except AttributeError as e:
-            self.assertEqual(
-                str(e), "'module' object has no attribute 'sdasfasfasdf'")
-        else:
-            self.fail(
-                "TestLoader.loadTestsFromName failed to raise AttributeError")
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    # ...
-    # "The method optionally resolves name relative to the given module"
-    #
-    # Do unknown attributes (relative to a provided module) still raise an
-    # exception even in the presence of valid attribute names?
-    def test_loadTestsFromNames__unknown_name_relative_2(self):
-        loader = unittest2.TestLoader()
-
-        try:
-            loader.loadTestsFromNames(['TestCase', 'sdasfasfasdf'], unittest2)
-        except AttributeError as e:
-            self.assertEqual(
-                str(e), "'module' object has no attribute 'sdasfasfasdf'")
-        else:
-            self.fail(
-                "TestLoader.loadTestsFromName failed to raise AttributeError")
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    # ...
-    # "The method optionally resolves name relative to the given module"
-    #
-    # What happens when faced with the empty string?
-    #
-    # XXX This currently raises AttributeError, though ValueError is probably
-    # more appropriate
-    def test_loadTestsFromNames__relative_empty_name(self):
-        loader = unittest2.TestLoader()
-
-        try:
-            loader.loadTestsFromNames([''], unittest2)
-        except AttributeError:
-            pass
-        else:
-            self.fail("Failed to raise ValueError")
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    # ...
-    # "The method optionally resolves name relative to the given module"
-    #
-    # What happens when presented with an impossible attribute name?
-    def test_loadTestsFromNames__relative_malformed_name(self):
-        loader = unittest2.TestLoader()
-
-        # XXX Should this raise AttributeError or ValueError?
-        try:
-            loader.loadTestsFromNames(['abc () //'], unittest2)
-        except AttributeError:
-            pass
-        except ValueError:
-            pass
-        else:
-            self.fail("TestLoader.loadTestsFromNames failed to raise ValueError")
-
-    # "The method optionally resolves name relative to the given module"
-    #
-    # Does loadTestsFromNames() make sure the provided `module` is in fact
-    # a module?
-    #
-    # XXX This validation is currently not done. This flexibility should
-    # either be documented or a TypeError should be raised.
-    def test_loadTestsFromNames__relative_not_a_module(self):
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-
-        class NotAModule(object):
-            test_2 = MyTestCase
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromNames(['test_2'], NotAModule)
-
-        reference = [unittest2.TestSuite([MyTestCase('test')])]
-        self.assertEqual(list(suite), reference)
-
-    # "The specifier name is a ``dotted name'' that may resolve either to
-    # a module, a test case class, a TestSuite instance, a test method
-    # within a test case class, or a callable object which returns a
-    # TestCase or TestSuite instance."
-    #
-    # Does it raise an exception if the name resolves to an invalid
-    # object?
-    def test_loadTestsFromNames__relative_bad_object(self):
-        m = types.ModuleType('m')
-        m.testcase_1 = object()
-
-        loader = unittest2.TestLoader()
-        try:
-            loader.loadTestsFromNames(['testcase_1'], m)
-        except TypeError:
-            pass
-        else:
-            self.fail("Should have raised TypeError")
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to
-    # ... a test case class"
-    def test_loadTestsFromNames__relative_TestCase_subclass(self):
-        m = types.ModuleType('m')
-
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromNames(['testcase_1'], m)
-        self.assertIsInstance(suite, loader.suiteClass)
-
-        expected = loader.suiteClass([MyTestCase('test')])
-        self.assertEqual(list(suite), [expected])
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to
-    # ... a TestSuite instance"
-    def test_loadTestsFromNames__relative_TestSuite(self):
-        m = types.ModuleType('m')
-
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-        m.testsuite = unittest2.TestSuite([MyTestCase('test')])
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromNames(['testsuite'], m)
-        self.assertIsInstance(suite, loader.suiteClass)
-
-        self.assertEqual(list(suite), [m.testsuite])
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to ... a
-    # test method within a test case class"
-    def test_loadTestsFromNames__relative_testmethod(self):
-        m = types.ModuleType('m')
-
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromNames(['testcase_1.test'], m)
-        self.assertIsInstance(suite, loader.suiteClass)
-
-        ref_suite = unittest2.TestSuite([MyTestCase('test')])
-        self.assertEqual(list(suite), [ref_suite])
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to ... a
-    # test method within a test case class"
-    #
-    # Does the method gracefully handle names that initially look like they
-    # resolve to "a test method within a test case class" but don't?
-    def test_loadTestsFromNames__relative_invalid_testmethod(self):
-        m = types.ModuleType('m')
-
-        class MyTestCase(unittest2.TestCase):
-
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        loader = unittest2.TestLoader()
-        try:
-            loader.loadTestsFromNames(['testcase_1.testfoo'], m)
-        except AttributeError as e:
-            self.assertEqual(
-                str(e), "type object 'MyTestCase' has no attribute 'testfoo'")
-        else:
-            self.fail("Failed to raise AttributeError")
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to
-    # ... a callable object which returns a ... TestSuite instance"
-    def test_loadTestsFromNames__callable__TestSuite(self):
-        m = types.ModuleType('m')
-        testcase_1 = unittest2.FunctionTestCase(lambda: None)
-        testcase_2 = unittest2.FunctionTestCase(lambda: None)
-
-        def return_TestSuite():
-            return unittest2.TestSuite([testcase_1, testcase_2])
-        m.return_TestSuite = return_TestSuite
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromNames(['return_TestSuite'], m)
-        self.assertIsInstance(suite, loader.suiteClass)
-
-        expected = unittest2.TestSuite([testcase_1, testcase_2])
-        self.assertEqual(list(suite), [expected])
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to
-    # ... a callable object which returns a TestCase ... instance"
-    def test_loadTestsFromNames__callable__TestCase_instance(self):
-        m = types.ModuleType('m')
-        testcase_1 = unittest2.FunctionTestCase(lambda: None)
-
-        def return_TestCase():
-            return testcase_1
-        m.return_TestCase = return_TestCase
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromNames(['return_TestCase'], m)
-        self.assertIsInstance(suite, loader.suiteClass)
-
-        ref_suite = unittest2.TestSuite([testcase_1])
-        self.assertEqual(list(suite), [ref_suite])
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to
-    # ... a callable object which returns a TestCase or TestSuite instance"
-    #
-    # Are staticmethods handled correctly?
-    def test_loadTestsFromNames__callable__call_staticmethod(self):
-        m = types.ModuleType('m')
-
-        class Test1(unittest2.TestCase):
-
-            def test(self):
-                pass
-
-        testcase_1 = Test1('test')
-
-        class Foo(unittest2.TestCase):
-
-            @staticmethod
-            def foo():
-                return testcase_1
-        m.Foo = Foo
-
-        loader = unittest2.TestLoader()
-        suite = loader.loadTestsFromNames(['Foo.foo'], m)
-        self.assertIsInstance(suite, loader.suiteClass)
-
-        ref_suite = unittest2.TestSuite([testcase_1])
-        self.assertEqual(list(suite), [ref_suite])
-
-    # "The specifier name is a ``dotted name'' that may resolve ... to
-    # ... a callable object which returns a TestCase or TestSuite instance"
-    #
-    # What happens when the callable returns something else?
-    def test_loadTestsFromNames__callable__wrong_type(self):
-        m = types.ModuleType('m')
-
-        def return_wrong():
-            return 6
-        m.return_wrong = return_wrong
-
-        loader = unittest2.TestLoader()
-        try:
-            loader.loadTestsFromNames(['return_wrong'], m)
-        except TypeError:
-            pass
-        else:
-            self.fail("TestLoader.loadTestsFromNames failed to raise TypeError")
-
-    # "The specifier can refer to modules and packages which have not been
-    # imported; they will be imported as a side-effect"
-    def test_loadTestsFromNames__module_not_loaded(self):
-        # We're going to try to load this module as a side-effect, so it
-        # better not be loaded before we try.
-        #
-        module_name = 'unittest2.test.dummy'
-        sys.modules.pop(module_name, None)
-
-        loader = unittest2.TestLoader()
-        try:
-            suite = loader.loadTestsFromNames([module_name])
-
-            self.assertIsInstance(suite, loader.suiteClass)
-            self.assertEqual(list(suite), [unittest2.TestSuite()])
-
-            # module should now be loaded, thanks to loadTestsFromName()
-            self.assertIn(module_name, sys.modules)
-        finally:
-            if module_name in sys.modules:
-                del sys.modules[module_name]
-
-    ################################################################
-    # /Tests for TestLoader.loadTestsFromNames()
-
-    # Tests for TestLoader.getTestCaseNames()
-    ################################################################
-
-    # "Return a sorted sequence of method names found within testCaseClass"
-    #
-    # Test.foobar is defined to make sure getTestCaseNames() respects
-    # loader.testMethodPrefix
-    def test_getTestCaseNames(self):
-        class Test(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-            def foobar(self): pass
-
-        loader = unittest2.TestLoader()
-
-        self.assertEqual(loader.getTestCaseNames(Test), ['test_1', 'test_2'])
-
-    # "Return a sorted sequence of method names found within testCaseClass"
-    #
-    # Does getTestCaseNames() behave appropriately if no tests are found?
-    def test_getTestCaseNames__no_tests(self):
-        class Test(unittest2.TestCase):
-
-            def foobar(self): pass
-
-        loader = unittest2.TestLoader()
-
-        self.assertEqual(loader.getTestCaseNames(Test), [])
-
-    # "Return a sorted sequence of method names found within testCaseClass"
-    #
-    # Are not-TestCases handled gracefully?
-    #
-    # XXX This should raise a TypeError, not return a list
-    #
-    # XXX It's too late in the 2.5 release cycle to fix this, but it should
-    # probably be revisited for 2.6
-    def test_getTestCaseNames__not_a_TestCase(self):
-        class BadCase(int):
-
-            def test_foo(self):
-                pass
-
-        loader = unittest2.TestLoader()
-        names = loader.getTestCaseNames(BadCase)
-
-        self.assertEqual(names, ['test_foo'])
-
-    # "Return a sorted sequence of method names found within testCaseClass"
-    #
-    # Make sure inherited names are handled.
-    #
-    # TestP.foobar is defined to make sure getTestCaseNames() respects
-    # loader.testMethodPrefix
-    def test_getTestCaseNames__inheritance(self):
-        class TestP(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-            def foobar(self): pass
-
-        class TestC(TestP):
-
-            def test_1(self): pass
-
-            def test_3(self): pass
-
-        loader = unittest2.TestLoader()
-
-        names = ['test_1', 'test_2', 'test_3']
-        self.assertEqual(loader.getTestCaseNames(TestC), names)
-
-    ################################################################
-    # /Tests for TestLoader.getTestCaseNames()
-
-    # Tests for TestLoader.testMethodPrefix
-    ################################################################
-
-    # "String giving the prefix of method names which will be interpreted as
-    # test methods"
-    #
-    # Implicit in the documentation is that testMethodPrefix is respected by
-    # all loadTestsFrom* methods.
-    def test_testMethodPrefix__loadTestsFromTestCase(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-            def foo_bar(self): pass
-
-        tests_1 = unittest2.TestSuite([Foo('foo_bar')])
-        tests_2 = unittest2.TestSuite([Foo('test_1'), Foo('test_2')])
-
-        loader = unittest2.TestLoader()
-        loader.testMethodPrefix = 'foo'
-        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests_1)
-
-        loader.testMethodPrefix = 'test'
-        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests_2)
-
-    # "String giving the prefix of method names which will be interpreted as
-    # test methods"
-    #
-    # Implicit in the documentation is that testMethodPrefix is respected by
-    # all loadTestsFrom* methods.
-    def test_testMethodPrefix__loadTestsFromModule(self):
-        m = types.ModuleType('m')
-
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-            def foo_bar(self): pass
-        m.Foo = Foo
-
-        tests_1 = [unittest2.TestSuite([Foo('foo_bar')])]
-        tests_2 = [unittest2.TestSuite([Foo('test_1'), Foo('test_2')])]
-
-        loader = unittest2.TestLoader()
-        loader.testMethodPrefix = 'foo'
-        self.assertEqual(list(loader.loadTestsFromModule(m)), tests_1)
-
-        loader.testMethodPrefix = 'test'
-        self.assertEqual(list(loader.loadTestsFromModule(m)), tests_2)
-
-    # "String giving the prefix of method names which will be interpreted as
-    # test methods"
-    #
-    # Implicit in the documentation is that testMethodPrefix is respected by
-    # all loadTestsFrom* methods.
-    def test_testMethodPrefix__loadTestsFromName(self):
-        m = types.ModuleType('m')
-
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-            def foo_bar(self): pass
-        m.Foo = Foo
-
-        tests_1 = unittest2.TestSuite([Foo('foo_bar')])
-        tests_2 = unittest2.TestSuite([Foo('test_1'), Foo('test_2')])
-
-        loader = unittest2.TestLoader()
-        loader.testMethodPrefix = 'foo'
-        self.assertEqual(loader.loadTestsFromName('Foo', m), tests_1)
-
-        loader.testMethodPrefix = 'test'
-        self.assertEqual(loader.loadTestsFromName('Foo', m), tests_2)
-
-    # "String giving the prefix of method names which will be interpreted as
-    # test methods"
-    #
-    # Implicit in the documentation is that testMethodPrefix is respected by
-    # all loadTestsFrom* methods.
-    def test_testMethodPrefix__loadTestsFromNames(self):
-        m = types.ModuleType('m')
-
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-            def foo_bar(self): pass
-        m.Foo = Foo
-
-        tests_1 = unittest2.TestSuite([unittest2.TestSuite([Foo('foo_bar')])])
-        tests_2 = unittest2.TestSuite([Foo('test_1'), Foo('test_2')])
-        tests_2 = unittest2.TestSuite([tests_2])
-
-        loader = unittest2.TestLoader()
-        loader.testMethodPrefix = 'foo'
-        self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests_1)
-
-        loader.testMethodPrefix = 'test'
-        self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests_2)
-
-    # "The default value is 'test'"
-    def test_testMethodPrefix__default_value(self):
-        loader = unittest2.TestLoader()
-        self.assertTrue(loader.testMethodPrefix == 'test')
-
-    ################################################################
-    # /Tests for TestLoader.testMethodPrefix
-
-    # Tests for TestLoader.sortTestMethodsUsing
-    ################################################################
-
-    # "Function to be used to compare method names when sorting them in
-    # getTestCaseNames() and all the loadTestsFromX() methods"
-    def test_sortTestMethodsUsing__loadTestsFromTestCase(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-        loader = unittest2.TestLoader()
-        loader.sortTestMethodsUsing = unittest2.reversed_cmp_
-
-        tests = loader.suiteClass([Foo('test_2'), Foo('test_1')])
-        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)
-
-    # "Function to be used to compare method names when sorting them in
-    # getTestCaseNames() and all the loadTestsFromX() methods"
-    def test_sortTestMethodsUsing__loadTestsFromModule(self):
-        m = types.ModuleType('m')
-
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-        m.Foo = Foo
-
-        loader = unittest2.TestLoader()
-        loader.sortTestMethodsUsing = unittest2.reversed_cmp_
-
-        tests = [loader.suiteClass([Foo('test_2'), Foo('test_1')])]
-        self.assertEqual(list(loader.loadTestsFromModule(m)), tests)
-
-    # "Function to be used to compare method names when sorting them in
-    # getTestCaseNames() and all the loadTestsFromX() methods"
-    def test_sortTestMethodsUsing__loadTestsFromName(self):
-        m = types.ModuleType('m')
-
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-        m.Foo = Foo
-
-        loader = unittest2.TestLoader()
-        loader.sortTestMethodsUsing = unittest2.reversed_cmp_
-
-        tests = loader.suiteClass([Foo('test_2'), Foo('test_1')])
-        self.assertEqual(loader.loadTestsFromName('Foo', m), tests)
-
-    # "Function to be used to compare method names when sorting them in
-    # getTestCaseNames() and all the loadTestsFromX() methods"
-    def test_sortTestMethodsUsing__loadTestsFromNames(self):
-        m = types.ModuleType('m')
-
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-        m.Foo = Foo
-
-        loader = unittest2.TestLoader()
-        loader.sortTestMethodsUsing = unittest2.reversed_cmp_
-
-        tests = [loader.suiteClass([Foo('test_2'), Foo('test_1')])]
-        self.assertEqual(list(loader.loadTestsFromNames(['Foo'], m)), tests)
-
-    # "Function to be used to compare method names when sorting them in
-    # getTestCaseNames()"
-    #
-    # Does it actually affect getTestCaseNames()?
-    def test_sortTestMethodsUsing__getTestCaseNames(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-        loader = unittest2.TestLoader()
-        loader.sortTestMethodsUsing = unittest2.reversed_cmp_
-
-        test_names = ['test_2', 'test_1']
-        self.assertEqual(loader.getTestCaseNames(Foo), test_names)
-
-    # "The default value is the built-in cmp() function"
-    def test_sortTestMethodsUsing__default_value(self):
-        loader = unittest2.TestLoader()
-        self.assertTrue(loader.sortTestMethodsUsing is unittest2.cmp_)
-
-    # "it can be set to None to disable the sort."
-    #
-    # XXX How is this different from reassigning cmp? Are the tests returned
-    # in a random order or something? This behaviour should die
-    def test_sortTestMethodsUsing__None(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-        loader = unittest2.TestLoader()
-        loader.sortTestMethodsUsing = None
-
-        test_names = ['test_2', 'test_1']
-        self.assertEqual(set(loader.getTestCaseNames(Foo)), set(test_names))
-
-    ################################################################
-    # /Tests for TestLoader.sortTestMethodsUsing
-
-    # Tests for TestLoader.suiteClass
-    ################################################################
-
-    # "Callable object that constructs a test suite from a list of tests."
-    def test_suiteClass__loadTestsFromTestCase(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-            def foo_bar(self): pass
-
-        tests = [Foo('test_1'), Foo('test_2')]
-
-        loader = unittest2.TestLoader()
-        loader.suiteClass = list
-        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)
-
-    # It is implicit in the documentation for TestLoader.suiteClass that
-    # all TestLoader.loadTestsFrom* methods respect it. Let's make sure
-    def test_suiteClass__loadTestsFromModule(self):
-        m = types.ModuleType('m')
-
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-            def foo_bar(self): pass
-        m.Foo = Foo
-
-        tests = [[Foo('test_1'), Foo('test_2')]]
-
-        loader = unittest2.TestLoader()
-        loader.suiteClass = list
-        self.assertEqual(loader.loadTestsFromModule(m), tests)
-
-    # It is implicit in the documentation for TestLoader.suiteClass that
-    # all TestLoader.loadTestsFrom* methods respect it. Let's make sure
-    def test_suiteClass__loadTestsFromName(self):
-        m = types.ModuleType('m')
-
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-            def foo_bar(self): pass
-        m.Foo = Foo
-
-        tests = [Foo('test_1'), Foo('test_2')]
-
-        loader = unittest2.TestLoader()
-        loader.suiteClass = list
-        self.assertEqual(loader.loadTestsFromName('Foo', m), tests)
-
-    # It is implicit in the documentation for TestLoader.suiteClass that
-    # all TestLoader.loadTestsFrom* methods respect it. Let's make sure
-    def test_suiteClass__loadTestsFromNames(self):
-        m = types.ModuleType('m')
-
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-            def foo_bar(self): pass
-        m.Foo = Foo
-
-        tests = [[Foo('test_1'), Foo('test_2')]]
-
-        loader = unittest2.TestLoader()
-        loader.suiteClass = list
-        self.assertEqual(loader.loadTestsFromNames(['Foo'], m), tests)
-
-    # "The default value is the TestSuite class"
-    def test_suiteClass__default_value(self):
-        loader = unittest2.TestLoader()
-        self.assertTrue(loader.suiteClass is unittest2.TestSuite)
-
-
-if __name__ == '__main__':
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_new_tests.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_new_tests.py
deleted file mode 100644
index 0b456c0..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_new_tests.py
+++ /dev/null
@@ -1,52 +0,0 @@
-from cStringIO import StringIO
-
-import unittest
-import unittest2
-
-from unittest2.test.support import resultFactory
-
-
-class TestUnittest(unittest2.TestCase):
-
-    def assertIsSubclass(self, actual, klass):
-        self.assertTrue(issubclass(actual, klass), "Not a subclass.")
-
-    def testInheritance(self):
-        self.assertIsSubclass(unittest2.TestCase, unittest.TestCase)
-        self.assertIsSubclass(unittest2.TestResult, unittest.TestResult)
-        self.assertIsSubclass(unittest2.TestSuite, unittest.TestSuite)
-        self.assertIsSubclass(
-            unittest2.TextTestRunner,
-            unittest.TextTestRunner)
-        self.assertIsSubclass(unittest2.TestLoader, unittest.TestLoader)
-        self.assertIsSubclass(unittest2.TextTestResult, unittest.TestResult)
-
-    def test_new_runner_old_case(self):
-        runner = unittest2.TextTestRunner(resultclass=resultFactory,
-                                          stream=StringIO())
-
-        class Test(unittest.TestCase):
-
-            def testOne(self):
-                pass
-        suite = unittest2.TestSuite((Test('testOne'),))
-        result = runner.run(suite)
-        self.assertEqual(result.testsRun, 1)
-        self.assertEqual(len(result.errors), 0)
-
-    def test_old_runner_new_case(self):
-        runner = unittest.TextTestRunner(stream=StringIO())
-
-        class Test(unittest2.TestCase):
-
-            def testOne(self):
-                self.assertDictEqual({}, {})
-
-        suite = unittest.TestSuite((Test('testOne'),))
-        result = runner.run(suite)
-        self.assertEqual(result.testsRun, 1)
-        self.assertEqual(len(result.errors), 0)
-
-
-if __name__ == '__main__':
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_program.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_program.py
deleted file mode 100644
index eb86487..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_program.py
+++ /dev/null
@@ -1,251 +0,0 @@
-from cStringIO import StringIO
-
-import sys
-import unittest2
-
-hasInstallHandler = hasattr(unittest2, 'installHandler')
-
-
-class Test_TestProgram(unittest2.TestCase):
-
-    # Horrible white box test
-    def testNoExit(self):
-        result = object()
-        test = object()
-
-        class FakeRunner(object):
-
-            def run(self, test):
-                self.test = test
-                return result
-
-        runner = FakeRunner()
-
-        oldParseArgs = unittest2.TestProgram.parseArgs
-
-        def restoreParseArgs():
-            unittest2.TestProgram.parseArgs = oldParseArgs
-        unittest2.TestProgram.parseArgs = lambda *args: None
-        self.addCleanup(restoreParseArgs)
-
-        def removeTest():
-            del unittest2.TestProgram.test
-        unittest2.TestProgram.test = test
-        self.addCleanup(removeTest)
-
-        program = unittest2.TestProgram(
-            testRunner=runner, exit=False, verbosity=2)
-
-        self.assertEqual(program.result, result)
-        self.assertEqual(runner.test, test)
-        self.assertEqual(program.verbosity, 2)
-
-    class FooBar(unittest2.TestCase):
-
-        def testPass(self):
-            assert True
-
-        def testFail(self):
-            assert False
-
-    class FooBarLoader(unittest2.TestLoader):
-        """Test loader that returns a suite containing FooBar."""
-
-        def loadTestsFromModule(self, module):
-            return self.suiteClass(
-                [self.loadTestsFromTestCase(Test_TestProgram.FooBar)])
-
-    def test_NonExit(self):
-        program = unittest2.main(
-            exit=False,
-            argv=["foobar"],
-            testRunner=unittest2.TextTestRunner(
-                stream=StringIO()),
-            testLoader=self.FooBarLoader())
-        self.assertTrue(hasattr(program, 'result'))
-
-    def test_Exit(self):
-        self.assertRaises(
-            SystemExit,
-            unittest2.main,
-            argv=["foobar"],
-            testRunner=unittest2.TextTestRunner(stream=StringIO()),
-            exit=True,
-            testLoader=self.FooBarLoader())
-
-    def test_ExitAsDefault(self):
-        self.assertRaises(
-            SystemExit,
-            unittest2.main,
-            argv=["foobar"],
-            testRunner=unittest2.TextTestRunner(stream=StringIO()),
-            testLoader=self.FooBarLoader())
-
-
-class InitialisableProgram(unittest2.TestProgram):
-    exit = False
-    result = None
-    verbosity = 1
-    defaultTest = None
-    testRunner = None
-    testLoader = unittest2.defaultTestLoader
-    progName = 'test'
-    test = 'test'
-
-    def __init__(self, *args):
-        pass
-
-RESULT = object()
-
-
-class FakeRunner(object):
-    initArgs = None
-    test = None
-    raiseError = False
-
-    def __init__(self, **kwargs):
-        FakeRunner.initArgs = kwargs
-        if FakeRunner.raiseError:
-            FakeRunner.raiseError = False
-            raise TypeError
-
-    def run(self, test):
-        FakeRunner.test = test
-        return RESULT
-
-
-class TestCommandLineArgs(unittest2.TestCase):
-
-    def setUp(self):
-        self.program = InitialisableProgram()
-        self.program.createTests = lambda: None
-        FakeRunner.initArgs = None
-        FakeRunner.test = None
-        FakeRunner.raiseError = False
-
-    def testHelpAndUnknown(self):
-        program = self.program
-
-        def usageExit(msg=None):
-            program.msg = msg
-            program.exit = True
-        program.usageExit = usageExit
-
-        for opt in '-h', '-H', '--help':
-            program.exit = False
-            program.parseArgs([None, opt])
-            self.assertTrue(program.exit)
-            self.assertIsNone(program.msg)
-
-        program.parseArgs([None, '-$'])
-        self.assertTrue(program.exit)
-        self.assertIsNotNone(program.msg)
-
-    def testVerbosity(self):
-        program = self.program
-
-        for opt in '-q', '--quiet':
-            program.verbosity = 1
-            program.parseArgs([None, opt])
-            self.assertEqual(program.verbosity, 0)
-
-        for opt in '-v', '--verbose':
-            program.verbosity = 1
-            program.parseArgs([None, opt])
-            self.assertEqual(program.verbosity, 2)
-
-    def testBufferCatchFailfast(self):
-        program = self.program
-        for arg, attr in (('buffer', 'buffer'), ('failfast', 'failfast'),
-                          ('catch', 'catchbreak')):
-            if attr == 'catch' and not hasInstallHandler:
-                continue
-
-            short_opt = '-%s' % arg[0]
-            long_opt = '--%s' % arg
-            for opt in short_opt, long_opt:
-                setattr(program, attr, None)
-
-                program.parseArgs([None, opt])
-                self.assertTrue(getattr(program, attr))
-
-            for opt in short_opt, long_opt:
-                not_none = object()
-                setattr(program, attr, not_none)
-
-                program.parseArgs([None, opt])
-                self.assertEqual(getattr(program, attr), not_none)
-
-    def testRunTestsRunnerClass(self):
-        program = self.program
-
-        program.testRunner = FakeRunner
-        program.verbosity = 'verbosity'
-        program.failfast = 'failfast'
-        program.buffer = 'buffer'
-
-        program.runTests()
-
-        self.assertEqual(FakeRunner.initArgs, {'verbosity': 'verbosity',
-                                               'failfast': 'failfast',
-                                               'buffer': 'buffer'})
-        self.assertEqual(FakeRunner.test, 'test')
-        self.assertIs(program.result, RESULT)
-
-    def testRunTestsRunnerInstance(self):
-        program = self.program
-
-        program.testRunner = FakeRunner()
-        FakeRunner.initArgs = None
-
-        program.runTests()
-
-        # A new FakeRunner should not have been instantiated
-        self.assertIsNone(FakeRunner.initArgs)
-
-        self.assertEqual(FakeRunner.test, 'test')
-        self.assertIs(program.result, RESULT)
-
-    def testRunTestsOldRunnerClass(self):
-        program = self.program
-
-        FakeRunner.raiseError = True
-        program.testRunner = FakeRunner
-        program.verbosity = 'verbosity'
-        program.failfast = 'failfast'
-        program.buffer = 'buffer'
-        program.test = 'test'
-
-        program.runTests()
-
-        # If initialising raises a type error it should be retried
-        # without the new keyword arguments
-        self.assertEqual(FakeRunner.initArgs, {})
-        self.assertEqual(FakeRunner.test, 'test')
-        self.assertIs(program.result, RESULT)
-
-    def testCatchBreakInstallsHandler(self):
-        module = sys.modules['unittest2.main']
-        original = module.installHandler
-
-        def restore():
-            module.installHandler = original
-        self.addCleanup(restore)
-
-        self.installed = False
-
-        def fakeInstallHandler():
-            self.installed = True
-        module.installHandler = fakeInstallHandler
-
-        program = self.program
-        program.catchbreak = True
-
-        program.testRunner = FakeRunner
-
-        program.runTests()
-        self.assertTrue(self.installed)
-
-
-if __name__ == '__main__':
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_result.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_result.py
deleted file mode 100644
index 9b64e82..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_result.py
+++ /dev/null
@@ -1,426 +0,0 @@
-import sys
-import textwrap
-from StringIO import StringIO
-
-import unittest2
-
-
-class Test_TestResult(unittest2.TestCase):
-    # Note: there are not separate tests for TestResult.wasSuccessful(),
-    # TestResult.errors, TestResult.failures, TestResult.testsRun or
-    # TestResult.shouldStop because these only have meaning in terms of
-    # other TestResult methods.
-    #
-    # Accordingly, tests for the aforenamed attributes are incorporated
-    # in with the tests for the defining methods.
-    ################################################################
-
-    def test_init(self):
-        result = unittest2.TestResult()
-
-        self.assertTrue(result.wasSuccessful())
-        self.assertEqual(len(result.errors), 0)
-        self.assertEqual(len(result.failures), 0)
-        self.assertEqual(result.testsRun, 0)
-        self.assertEqual(result.shouldStop, False)
-        self.assertIsNone(result._stdout_buffer)
-        self.assertIsNone(result._stderr_buffer)
-
-    # "This method can be called to signal that the set of tests being
-    # run should be aborted by setting the TestResult's shouldStop
-    # attribute to True."
-    def test_stop(self):
-        result = unittest2.TestResult()
-
-        result.stop()
-
-        self.assertEqual(result.shouldStop, True)
-
-    # "Called when the test case test is about to be run. The default
-    # implementation simply increments the instance's testsRun counter."
-    def test_startTest(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self):
-                pass
-
-        test = Foo('test_1')
-
-        result = unittest2.TestResult()
-
-        result.startTest(test)
-
-        self.assertTrue(result.wasSuccessful())
-        self.assertEqual(len(result.errors), 0)
-        self.assertEqual(len(result.failures), 0)
-        self.assertEqual(result.testsRun, 1)
-        self.assertEqual(result.shouldStop, False)
-
-        result.stopTest(test)
-
-    # "Called after the test case test has been executed, regardless of
-    # the outcome. The default implementation does nothing."
-    def test_stopTest(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self):
-                pass
-
-        test = Foo('test_1')
-
-        result = unittest2.TestResult()
-
-        result.startTest(test)
-
-        self.assertTrue(result.wasSuccessful())
-        self.assertEqual(len(result.errors), 0)
-        self.assertEqual(len(result.failures), 0)
-        self.assertEqual(result.testsRun, 1)
-        self.assertEqual(result.shouldStop, False)
-
-        result.stopTest(test)
-
-        # Same tests as above; make sure nothing has changed
-        self.assertTrue(result.wasSuccessful())
-        self.assertEqual(len(result.errors), 0)
-        self.assertEqual(len(result.failures), 0)
-        self.assertEqual(result.testsRun, 1)
-        self.assertEqual(result.shouldStop, False)
-
-    # "Called before and after tests are run. The default implementation does nothing."
-    def test_startTestRun_stopTestRun(self):
-        result = unittest2.TestResult()
-        result.startTestRun()
-        result.stopTestRun()
-
-    # "addSuccess(test)"
-    # ...
-    # "Called when the test case test succeeds"
-    # ...
-    # "wasSuccessful() - Returns True if all tests run so far have passed,
-    # otherwise returns False"
-    # ...
-    # "testsRun - The total number of tests run so far."
-    # ...
-    # "errors - A list containing 2-tuples of TestCase instances and
-    # formatted tracebacks. Each tuple represents a test which raised an
-    # unexpected exception. Contains formatted
-    # tracebacks instead of sys.exc_info() results."
-    # ...
-    # "failures - A list containing 2-tuples of TestCase instances and
-    # formatted tracebacks. Each tuple represents a test where a failure was
-    # explicitly signalled using the TestCase.fail*() or TestCase.assert*()
-    # methods. Contains formatted tracebacks instead
-    # of sys.exc_info() results."
-    def test_addSuccess(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self):
-                pass
-
-        test = Foo('test_1')
-
-        result = unittest2.TestResult()
-
-        result.startTest(test)
-        result.addSuccess(test)
-        result.stopTest(test)
-
-        self.assertTrue(result.wasSuccessful())
-        self.assertEqual(len(result.errors), 0)
-        self.assertEqual(len(result.failures), 0)
-        self.assertEqual(result.testsRun, 1)
-        self.assertEqual(result.shouldStop, False)
-
-    # "addFailure(test, err)"
-    # ...
-    # "Called when the test case test signals a failure. err is a tuple of
-    # the form returned by sys.exc_info(): (type, value, traceback)"
-    # ...
-    # "wasSuccessful() - Returns True if all tests run so far have passed,
-    # otherwise returns False"
-    # ...
-    # "testsRun - The total number of tests run so far."
-    # ...
-    # "errors - A list containing 2-tuples of TestCase instances and
-    # formatted tracebacks. Each tuple represents a test which raised an
-    # unexpected exception. Contains formatted
-    # tracebacks instead of sys.exc_info() results."
-    # ...
-    # "failures - A list containing 2-tuples of TestCase instances and
-    # formatted tracebacks. Each tuple represents a test where a failure was
-    # explicitly signalled using the TestCase.fail*() or TestCase.assert*()
-    # methods. Contains formatted tracebacks instead
-    # of sys.exc_info() results."
-    def test_addFailure(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self):
-                pass
-
-        test = Foo('test_1')
-        try:
-            test.fail("foo")
-        except:
-            exc_info_tuple = sys.exc_info()
-
-        result = unittest2.TestResult()
-
-        result.startTest(test)
-        result.addFailure(test, exc_info_tuple)
-        result.stopTest(test)
-
-        self.assertFalse(result.wasSuccessful())
-        self.assertEqual(len(result.errors), 0)
-        self.assertEqual(len(result.failures), 1)
-        self.assertEqual(result.testsRun, 1)
-        self.assertEqual(result.shouldStop, False)
-
-        test_case, formatted_exc = result.failures[0]
-        self.assertTrue(test_case is test)
-        self.assertIsInstance(formatted_exc, str)
-
-    # "addError(test, err)"
-    # ...
-    # "Called when the test case test raises an unexpected exception err
-    # is a tuple of the form returned by sys.exc_info():
-    # (type, value, traceback)"
-    # ...
-    # "wasSuccessful() - Returns True if all tests run so far have passed,
-    # otherwise returns False"
-    # ...
-    # "testsRun - The total number of tests run so far."
-    # ...
-    # "errors - A list containing 2-tuples of TestCase instances and
-    # formatted tracebacks. Each tuple represents a test which raised an
-    # unexpected exception. Contains formatted
-    # tracebacks instead of sys.exc_info() results."
-    # ...
-    # "failures - A list containing 2-tuples of TestCase instances and
-    # formatted tracebacks. Each tuple represents a test where a failure was
-    # explicitly signalled using the TestCase.fail*() or TestCase.assert*()
-    # methods. Contains formatted tracebacks instead
-    # of sys.exc_info() results."
-    def test_addError(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self):
-                pass
-
-        test = Foo('test_1')
-        try:
-            raise TypeError()
-        except:
-            exc_info_tuple = sys.exc_info()
-
-        result = unittest2.TestResult()
-
-        result.startTest(test)
-        result.addError(test, exc_info_tuple)
-        result.stopTest(test)
-
-        self.assertFalse(result.wasSuccessful())
-        self.assertEqual(len(result.errors), 1)
-        self.assertEqual(len(result.failures), 0)
-        self.assertEqual(result.testsRun, 1)
-        self.assertEqual(result.shouldStop, False)
-
-        test_case, formatted_exc = result.errors[0]
-        self.assertTrue(test_case is test)
-        self.assertIsInstance(formatted_exc, str)
-
-    def testGetDescriptionWithoutDocstring(self):
-        result = unittest2.TextTestResult(None, True, 1)
-        self.assertEqual(
-            result.getDescription(self),
-            'testGetDescriptionWithoutDocstring (' + __name__ +
-            '.Test_TestResult)')
-
-    def testGetDescriptionWithOneLineDocstring(self):
-        """Tests getDescription() for a method with a docstring."""
-        result = unittest2.TextTestResult(None, True, 1)
-        self.assertEqual(
-            result.getDescription(self),
-            ('testGetDescriptionWithOneLineDocstring '
-             '(' + __name__ + '.Test_TestResult)\n'
-             'Tests getDescription() for a method with a docstring.'))
-
-    def testGetDescriptionWithMultiLineDocstring(self):
-        """Tests getDescription() for a method with a longer docstring.
-        The second line of the docstring.
-        """
-        result = unittest2.TextTestResult(None, True, 1)
-        self.assertEqual(
-            result.getDescription(self),
-            ('testGetDescriptionWithMultiLineDocstring '
-             '(' + __name__ + '.Test_TestResult)\n'
-             'Tests getDescription() for a method with a longer '
-             'docstring.'))
-
-    def testStackFrameTrimming(self):
-        class Frame(object):
-
-            class tb_frame(object):
-                f_globals = {}
-        result = unittest2.TestResult()
-        self.assertFalse(result._is_relevant_tb_level(Frame))
-
-        Frame.tb_frame.f_globals['__unittest'] = True
-        self.assertTrue(result._is_relevant_tb_level(Frame))
-
-    def testFailFast(self):
-        result = unittest2.TestResult()
-        result._exc_info_to_string = lambda *_: ''
-        result.failfast = True
-        result.addError(None, None)
-        self.assertTrue(result.shouldStop)
-
-        result = unittest2.TestResult()
-        result._exc_info_to_string = lambda *_: ''
-        result.failfast = True
-        result.addFailure(None, None)
-        self.assertTrue(result.shouldStop)
-
-        result = unittest2.TestResult()
-        result._exc_info_to_string = lambda *_: ''
-        result.failfast = True
-        result.addUnexpectedSuccess(None)
-        self.assertTrue(result.shouldStop)
-
-    def testFailFastSetByRunner(self):
-        runner = unittest2.TextTestRunner(stream=StringIO(), failfast=True)
-        self.testRan = False
-
-        def test(result):
-            self.testRan = True
-            self.assertTrue(result.failfast)
-        runner.run(test)
-        self.assertTrue(self.testRan)
-
-
-class TestOutputBuffering(unittest2.TestCase):
-
-    def setUp(self):
-        self._real_out = sys.stdout
-        self._real_err = sys.stderr
-
-    def tearDown(self):
-        sys.stdout = self._real_out
-        sys.stderr = self._real_err
-
-    def testBufferOutputOff(self):
-        real_out = self._real_out
-        real_err = self._real_err
-
-        result = unittest2.TestResult()
-        self.assertFalse(result.buffer)
-
-        self.assertIs(real_out, sys.stdout)
-        self.assertIs(real_err, sys.stderr)
-
-        result.startTest(self)
-
-        self.assertIs(real_out, sys.stdout)
-        self.assertIs(real_err, sys.stderr)
-
-    def testBufferOutputStartTestAddSuccess(self):
-        real_out = self._real_out
-        real_err = self._real_err
-
-        result = unittest2.TestResult()
-        self.assertFalse(result.buffer)
-
-        result.buffer = True
-
-        self.assertIs(real_out, sys.stdout)
-        self.assertIs(real_err, sys.stderr)
-
-        result.startTest(self)
-
-        self.assertIsNot(real_out, sys.stdout)
-        self.assertIsNot(real_err, sys.stderr)
-        self.assertIsInstance(sys.stdout, StringIO)
-        self.assertIsInstance(sys.stderr, StringIO)
-        self.assertIsNot(sys.stdout, sys.stderr)
-
-        out_stream = sys.stdout
-        err_stream = sys.stderr
-
-        result._original_stdout = StringIO()
-        result._original_stderr = StringIO()
-
-        print('foo')
-        print('bar', file=sys.stderr)
-
-        self.assertEqual(out_stream.getvalue(), 'foo\n')
-        self.assertEqual(err_stream.getvalue(), 'bar\n')
-
-        self.assertEqual(result._original_stdout.getvalue(), '')
-        self.assertEqual(result._original_stderr.getvalue(), '')
-
-        result.addSuccess(self)
-        result.stopTest(self)
-
-        self.assertIs(sys.stdout, result._original_stdout)
-        self.assertIs(sys.stderr, result._original_stderr)
-
-        self.assertEqual(result._original_stdout.getvalue(), '')
-        self.assertEqual(result._original_stderr.getvalue(), '')
-
-        self.assertEqual(out_stream.getvalue(), '')
-        self.assertEqual(err_stream.getvalue(), '')
-
-    def getStartedResult(self):
-        result = unittest2.TestResult()
-        result.buffer = True
-        result.startTest(self)
-        return result
-
-    def testBufferOutputAddErrorOrFailure(self):
-        for message_attr, add_attr, include_error in [
-            ('errors', 'addError', True),
-            ('failures', 'addFailure', False),
-            ('errors', 'addError', True),
-            ('failures', 'addFailure', False)
-        ]:
-            result = self.getStartedResult()
-            result._original_stderr = StringIO()
-            result._original_stdout = StringIO()
-
-            print('foo')
-            if include_error:
-                print('bar', file=sys.stderr)
-
-            addFunction = getattr(result, add_attr)
-            addFunction(self, (None, None, None))
-            result.stopTest(self)
-
-            result_list = getattr(result, message_attr)
-            self.assertEqual(len(result_list), 1)
-
-            test, message = result_list[0]
-            expectedOutMessage = textwrap.dedent("""
-                Stdout:
-                foo
-            """)
-            expectedErrMessage = ''
-            if include_error:
-                expectedErrMessage = textwrap.dedent("""
-                Stderr:
-                bar
-            """)
-            expectedFullMessage = 'None\n%s%s' % (
-                expectedOutMessage, expectedErrMessage)
-
-            self.assertIs(test, self)
-            self.assertEqual(
-                result._original_stdout.getvalue(),
-                expectedOutMessage)
-            self.assertEqual(
-                result._original_stderr.getvalue(),
-                expectedErrMessage)
-            self.assertMultiLineEqual(message, expectedFullMessage)
-
-
-if __name__ == '__main__':
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_runner.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_runner.py
deleted file mode 100644
index cfdf132..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_runner.py
+++ /dev/null
@@ -1,136 +0,0 @@
-import pickle
-
-from cStringIO import StringIO
-from unittest2.test.support import LoggingResult, OldTestResult
-
-import unittest2
-
-
-class Test_TextTestRunner(unittest2.TestCase):
-    """Tests for TextTestRunner."""
-
-    def test_init(self):
-        runner = unittest2.TextTestRunner()
-        self.assertFalse(runner.failfast)
-        self.assertFalse(runner.buffer)
-        self.assertEqual(runner.verbosity, 1)
-        self.assertTrue(runner.descriptions)
-        self.assertEqual(runner.resultclass, unittest2.TextTestResult)
-
-    def testBufferAndFailfast(self):
-        class Test(unittest2.TestCase):
-
-            def testFoo(self):
-                pass
-        result = unittest2.TestResult()
-        runner = unittest2.TextTestRunner(stream=StringIO(), failfast=True,
-                                          buffer=True)
-        # Use our result object
-        runner._makeResult = lambda: result
-        runner.run(Test('testFoo'))
-
-        self.assertTrue(result.failfast)
-        self.assertTrue(result.buffer)
-
-    def testRunnerRegistersResult(self):
-        class Test(unittest2.TestCase):
-
-            def testFoo(self):
-                pass
-        originalRegisterResult = unittest2.runner.registerResult
-
-        def cleanup():
-            unittest2.runner.registerResult = originalRegisterResult
-        self.addCleanup(cleanup)
-
-        result = unittest2.TestResult()
-        runner = unittest2.TextTestRunner(stream=StringIO())
-        # Use our result object
-        runner._makeResult = lambda: result
-
-        self.wasRegistered = 0
-
-        def fakeRegisterResult(thisResult):
-            self.wasRegistered += 1
-            self.assertEqual(thisResult, result)
-        unittest2.runner.registerResult = fakeRegisterResult
-
-        runner.run(unittest2.TestSuite())
-        self.assertEqual(self.wasRegistered, 1)
-
-    def test_works_with_result_without_startTestRun_stopTestRun(self):
-        class OldTextResult(OldTestResult):
-
-            def __init__(self, *_):
-                super(OldTextResult, self).__init__()
-            separator2 = ''
-
-            def printErrors(self):
-                pass
-
-        runner = unittest2.TextTestRunner(stream=StringIO(),
-                                          resultclass=OldTextResult)
-        runner.run(unittest2.TestSuite())
-
-    def test_startTestRun_stopTestRun_called(self):
-        class LoggingTextResult(LoggingResult):
-            separator2 = ''
-
-            def printErrors(self):
-                pass
-
-        class LoggingRunner(unittest2.TextTestRunner):
-
-            def __init__(self, events):
-                super(LoggingRunner, self).__init__(StringIO())
-                self._events = events
-
-            def _makeResult(self):
-                return LoggingTextResult(self._events)
-
-        events = []
-        runner = LoggingRunner(events)
-        runner.run(unittest2.TestSuite())
-        expected = ['startTestRun', 'stopTestRun']
-        self.assertEqual(events, expected)
-
-    def test_pickle_unpickle(self):
-        # Issue #7197: a TextTestRunner should be (un)pickleable. This is
-        # required by test_multiprocessing under Windows (in verbose mode).
-        import StringIO
-        # cStringIO objects are not pickleable, but StringIO objects are.
-        stream = StringIO.StringIO("foo")
-        runner = unittest2.TextTestRunner(stream)
-        for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
-            s = pickle.dumps(runner, protocol=protocol)
-            obj = pickle.loads(s)
-            # StringIO objects never compare equal, a cheap test instead.
-            self.assertEqual(obj.stream.getvalue(), stream.getvalue())
-
-    def test_resultclass(self):
-        def MockResultClass(*args):
-            return args
-        STREAM = object()
-        DESCRIPTIONS = object()
-        VERBOSITY = object()
-        runner = unittest2.TextTestRunner(STREAM, DESCRIPTIONS, VERBOSITY,
-                                          resultclass=MockResultClass)
-        self.assertEqual(runner.resultclass, MockResultClass)
-
-        expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY)
-        self.assertEqual(runner._makeResult(), expectedresult)
-
-    def test_oldresult(self):
-        class Test(unittest2.TestCase):
-
-            def testFoo(self):
-                pass
-        runner = unittest2.TextTestRunner(resultclass=OldTestResult,
-                                          stream=StringIO())
-        # This will raise an exception if TextTestRunner can't handle old
-        # test result objects
-        runner.run(Test('testFoo'))
-
-
-if __name__ == '__main__':
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_setups.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_setups.py
deleted file mode 100644
index 7352689..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_setups.py
+++ /dev/null
@@ -1,596 +0,0 @@
-import sys
-
-from cStringIO import StringIO
-
-import unittest2
-from unittest2.test.support import resultFactory
-
-
-class TestSetups(unittest2.TestCase):
-
-    def getRunner(self):
-        return unittest2.TextTestRunner(resultclass=resultFactory,
-                                        stream=StringIO())
-
-    def runTests(self, *cases):
-        suite = unittest2.TestSuite()
-        for case in cases:
-            tests = unittest2.defaultTestLoader.loadTestsFromTestCase(case)
-            suite.addTests(tests)
-
-        runner = self.getRunner()
-
-        # creating a nested suite exposes some potential bugs
-        realSuite = unittest2.TestSuite()
-        realSuite.addTest(suite)
-        # adding empty suites to the end exposes potential bugs
-        suite.addTest(unittest2.TestSuite())
-        realSuite.addTest(unittest2.TestSuite())
-        return runner.run(realSuite)
-
-    def test_setup_class(self):
-        class Test(unittest2.TestCase):
-            setUpCalled = 0
-
-            @classmethod
-            def setUpClass(cls):
-                Test.setUpCalled += 1
-                unittest2.TestCase.setUpClass()
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-
-        result = self.runTests(Test)
-
-        self.assertEqual(Test.setUpCalled, 1)
-        self.assertEqual(result.testsRun, 2)
-        self.assertEqual(len(result.errors), 0)
-
-    def test_teardown_class(self):
-        class Test(unittest2.TestCase):
-            tearDownCalled = 0
-
-            @classmethod
-            def tearDownClass(cls):
-                Test.tearDownCalled += 1
-                unittest2.TestCase.tearDownClass()
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-
-        result = self.runTests(Test)
-
-        self.assertEqual(Test.tearDownCalled, 1)
-        self.assertEqual(result.testsRun, 2)
-        self.assertEqual(len(result.errors), 0)
-
-    def test_teardown_class_two_classes(self):
-        class Test(unittest2.TestCase):
-            tearDownCalled = 0
-
-            @classmethod
-            def tearDownClass(cls):
-                Test.tearDownCalled += 1
-                unittest2.TestCase.tearDownClass()
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-
-        class Test2(unittest2.TestCase):
-            tearDownCalled = 0
-
-            @classmethod
-            def tearDownClass(cls):
-                Test2.tearDownCalled += 1
-                unittest2.TestCase.tearDownClass()
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-
-        result = self.runTests(Test, Test2)
-
-        self.assertEqual(Test.tearDownCalled, 1)
-        self.assertEqual(Test2.tearDownCalled, 1)
-        self.assertEqual(result.testsRun, 4)
-        self.assertEqual(len(result.errors), 0)
-
-    def test_error_in_setupclass(self):
-        class BrokenTest(unittest2.TestCase):
-
-            @classmethod
-            def setUpClass(cls):
-                raise TypeError('foo')
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-
-        result = self.runTests(BrokenTest)
-
-        self.assertEqual(result.testsRun, 0)
-        self.assertEqual(len(result.errors), 1)
-        error, _ = result.errors[0]
-        self.assertEqual(str(error),
-                         'setUpClass (%s.BrokenTest)' % __name__)
-
-    def test_error_in_teardown_class(self):
-        class Test(unittest2.TestCase):
-            tornDown = 0
-
-            @classmethod
-            def tearDownClass(cls):
-                Test.tornDown += 1
-                raise TypeError('foo')
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-
-        class Test2(unittest2.TestCase):
-            tornDown = 0
-
-            @classmethod
-            def tearDownClass(cls):
-                Test2.tornDown += 1
-                raise TypeError('foo')
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-
-        result = self.runTests(Test, Test2)
-        self.assertEqual(result.testsRun, 4)
-        self.assertEqual(len(result.errors), 2)
-        self.assertEqual(Test.tornDown, 1)
-        self.assertEqual(Test2.tornDown, 1)
-
-        error, _ = result.errors[0]
-        self.assertEqual(str(error),
-                         'tearDownClass (%s.Test)' % __name__)
-
-    def test_class_not_torndown_when_setup_fails(self):
-        class Test(unittest2.TestCase):
-            tornDown = False
-
-            @classmethod
-            def setUpClass(cls):
-                raise TypeError
-
-            @classmethod
-            def tearDownClass(cls):
-                Test.tornDown = True
-                raise TypeError('foo')
-
-            def test_one(self):
-                pass
-
-        self.runTests(Test)
-        self.assertFalse(Test.tornDown)
-
-    def test_class_not_setup_or_torndown_when_skipped(self):
-        class Test(unittest2.TestCase):
-            classSetUp = False
-            tornDown = False
-
-            @classmethod
-            def setUpClass(cls):
-                Test.classSetUp = True
-
-            @classmethod
-            def tearDownClass(cls):
-                Test.tornDown = True
-
-            def test_one(self):
-                pass
-
-        Test = unittest2.skip("hop")(Test)
-        self.runTests(Test)
-        self.assertFalse(Test.classSetUp)
-        self.assertFalse(Test.tornDown)
-
-    def test_setup_teardown_order_with_pathological_suite(self):
-        results = []
-
-        class Module1(object):
-
-            @staticmethod
-            def setUpModule():
-                results.append('Module1.setUpModule')
-
-            @staticmethod
-            def tearDownModule():
-                results.append('Module1.tearDownModule')
-
-        class Module2(object):
-
-            @staticmethod
-            def setUpModule():
-                results.append('Module2.setUpModule')
-
-            @staticmethod
-            def tearDownModule():
-                results.append('Module2.tearDownModule')
-
-        class Test1(unittest2.TestCase):
-
-            @classmethod
-            def setUpClass(cls):
-                results.append('setup 1')
-
-            @classmethod
-            def tearDownClass(cls):
-                results.append('teardown 1')
-
-            def testOne(self):
-                results.append('Test1.testOne')
-
-            def testTwo(self):
-                results.append('Test1.testTwo')
-
-        class Test2(unittest2.TestCase):
-
-            @classmethod
-            def setUpClass(cls):
-                results.append('setup 2')
-
-            @classmethod
-            def tearDownClass(cls):
-                results.append('teardown 2')
-
-            def testOne(self):
-                results.append('Test2.testOne')
-
-            def testTwo(self):
-                results.append('Test2.testTwo')
-
-        class Test3(unittest2.TestCase):
-
-            @classmethod
-            def setUpClass(cls):
-                results.append('setup 3')
-
-            @classmethod
-            def tearDownClass(cls):
-                results.append('teardown 3')
-
-            def testOne(self):
-                results.append('Test3.testOne')
-
-            def testTwo(self):
-                results.append('Test3.testTwo')
-
-        Test1.__module__ = Test2.__module__ = 'Module'
-        Test3.__module__ = 'Module2'
-        sys.modules['Module'] = Module1
-        sys.modules['Module2'] = Module2
-
-        first = unittest2.TestSuite((Test1('testOne'),))
-        second = unittest2.TestSuite((Test1('testTwo'),))
-        third = unittest2.TestSuite((Test2('testOne'),))
-        fourth = unittest2.TestSuite((Test2('testTwo'),))
-        fifth = unittest2.TestSuite((Test3('testOne'),))
-        sixth = unittest2.TestSuite((Test3('testTwo'),))
-        suite = unittest2.TestSuite(
-            (first, second, third, fourth, fifth, sixth))
-
-        runner = self.getRunner()
-        result = runner.run(suite)
-        self.assertEqual(result.testsRun, 6)
-        self.assertEqual(len(result.errors), 0)
-
-        self.assertEqual(results,
-                         ['Module1.setUpModule', 'setup 1',
-                          'Test1.testOne', 'Test1.testTwo', 'teardown 1',
-                          'setup 2', 'Test2.testOne', 'Test2.testTwo',
-                          'teardown 2', 'Module1.tearDownModule',
-                          'Module2.setUpModule', 'setup 3',
-                          'Test3.testOne', 'Test3.testTwo',
-                          'teardown 3', 'Module2.tearDownModule'])
-
-    def test_setup_module(self):
-        class Module(object):
-            moduleSetup = 0
-
-            @staticmethod
-            def setUpModule():
-                Module.moduleSetup += 1
-
-        class Test(unittest2.TestCase):
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-        Test.__module__ = 'Module'
-        sys.modules['Module'] = Module
-
-        result = self.runTests(Test)
-        self.assertEqual(Module.moduleSetup, 1)
-        self.assertEqual(result.testsRun, 2)
-        self.assertEqual(len(result.errors), 0)
-
-    def test_error_in_setup_module(self):
-        class Module(object):
-            moduleSetup = 0
-            moduleTornDown = 0
-
-            @staticmethod
-            def setUpModule():
-                Module.moduleSetup += 1
-                raise TypeError('foo')
-
-            @staticmethod
-            def tearDownModule():
-                Module.moduleTornDown += 1
-
-        class Test(unittest2.TestCase):
-            classSetUp = False
-            classTornDown = False
-
-            @classmethod
-            def setUpClass(cls):
-                Test.classSetUp = True
-
-            @classmethod
-            def tearDownClass(cls):
-                Test.classTornDown = True
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-
-        class Test2(unittest2.TestCase):
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-        Test.__module__ = 'Module'
-        Test2.__module__ = 'Module'
-        sys.modules['Module'] = Module
-
-        result = self.runTests(Test, Test2)
-        self.assertEqual(Module.moduleSetup, 1)
-        self.assertEqual(Module.moduleTornDown, 0)
-        self.assertEqual(result.testsRun, 0)
-        self.assertFalse(Test.classSetUp)
-        self.assertFalse(Test.classTornDown)
-        self.assertEqual(len(result.errors), 1)
-        error, _ = result.errors[0]
-        self.assertEqual(str(error), 'setUpModule (Module)')
-
-    def test_testcase_with_missing_module(self):
-        class Test(unittest2.TestCase):
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-        Test.__module__ = 'Module'
-        sys.modules.pop('Module', None)
-
-        result = self.runTests(Test)
-        self.assertEqual(result.testsRun, 2)
-
-    def test_teardown_module(self):
-        class Module(object):
-            moduleTornDown = 0
-
-            @staticmethod
-            def tearDownModule():
-                Module.moduleTornDown += 1
-
-        class Test(unittest2.TestCase):
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-        Test.__module__ = 'Module'
-        sys.modules['Module'] = Module
-
-        result = self.runTests(Test)
-        self.assertEqual(Module.moduleTornDown, 1)
-        self.assertEqual(result.testsRun, 2)
-        self.assertEqual(len(result.errors), 0)
-
-    def test_error_in_teardown_module(self):
-        class Module(object):
-            moduleTornDown = 0
-
-            @staticmethod
-            def tearDownModule():
-                Module.moduleTornDown += 1
-                raise TypeError('foo')
-
-        class Test(unittest2.TestCase):
-            classSetUp = False
-            classTornDown = False
-
-            @classmethod
-            def setUpClass(cls):
-                Test.classSetUp = True
-
-            @classmethod
-            def tearDownClass(cls):
-                Test.classTornDown = True
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-
-        class Test2(unittest2.TestCase):
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-        Test.__module__ = 'Module'
-        Test2.__module__ = 'Module'
-        sys.modules['Module'] = Module
-
-        result = self.runTests(Test, Test2)
-        self.assertEqual(Module.moduleTornDown, 1)
-        self.assertEqual(result.testsRun, 4)
-        self.assertTrue(Test.classSetUp)
-        self.assertTrue(Test.classTornDown)
-        self.assertEqual(len(result.errors), 1)
-        error, _ = result.errors[0]
-        self.assertEqual(str(error), 'tearDownModule (Module)')
-
-    def test_skiptest_in_setupclass(self):
-        class Test(unittest2.TestCase):
-
-            @classmethod
-            def setUpClass(cls):
-                raise unittest2.SkipTest('foo')
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-
-        result = self.runTests(Test)
-        self.assertEqual(result.testsRun, 0)
-        self.assertEqual(len(result.errors), 0)
-        self.assertEqual(len(result.skipped), 1)
-        skipped = result.skipped[0][0]
-        self.assertEqual(str(skipped), 'setUpClass (%s.Test)' % __name__)
-
-    def test_skiptest_in_setupmodule(self):
-        class Test(unittest2.TestCase):
-
-            def test_one(self):
-                pass
-
-            def test_two(self):
-                pass
-
-        class Module(object):
-
-            @staticmethod
-            def setUpModule():
-                raise unittest2.SkipTest('foo')
-
-        Test.__module__ = 'Module'
-        sys.modules['Module'] = Module
-
-        result = self.runTests(Test)
-        self.assertEqual(result.testsRun, 0)
-        self.assertEqual(len(result.errors), 0)
-        self.assertEqual(len(result.skipped), 1)
-        skipped = result.skipped[0][0]
-        self.assertEqual(str(skipped), 'setUpModule (Module)')
-
-    def test_suite_debug_executes_setups_and_teardowns(self):
-        ordering = []
-
-        class Module(object):
-
-            @staticmethod
-            def setUpModule():
-                ordering.append('setUpModule')
-
-            @staticmethod
-            def tearDownModule():
-                ordering.append('tearDownModule')
-
-        class Test(unittest2.TestCase):
-
-            @classmethod
-            def setUpClass(cls):
-                ordering.append('setUpClass')
-
-            @classmethod
-            def tearDownClass(cls):
-                ordering.append('tearDownClass')
-
-            def test_something(self):
-                ordering.append('test_something')
-
-        Test.__module__ = 'Module'
-        sys.modules['Module'] = Module
-
-        suite = unittest2.defaultTestLoader.loadTestsFromTestCase(Test)
-        suite.debug()
-        expectedOrder = [
-            'setUpModule',
-            'setUpClass',
-            'test_something',
-            'tearDownClass',
-            'tearDownModule']
-        self.assertEqual(ordering, expectedOrder)
-
-    def test_suite_debug_propagates_exceptions(self):
-        class Module(object):
-
-            @staticmethod
-            def setUpModule():
-                if phase == 0:
-                    raise Exception('setUpModule')
-
-            @staticmethod
-            def tearDownModule():
-                if phase == 1:
-                    raise Exception('tearDownModule')
-
-        class Test(unittest2.TestCase):
-
-            @classmethod
-            def setUpClass(cls):
-                if phase == 2:
-                    raise Exception('setUpClass')
-
-            @classmethod
-            def tearDownClass(cls):
-                if phase == 3:
-                    raise Exception('tearDownClass')
-
-            def test_something(self):
-                if phase == 4:
-                    raise Exception('test_something')
-
-        Test.__module__ = 'Module'
-        sys.modules['Module'] = Module
-
-        _suite = unittest2.defaultTestLoader.loadTestsFromTestCase(Test)
-        suite = unittest2.TestSuite()
-
-        # nesting a suite again exposes a bug in the initial implementation
-        suite.addTest(_suite)
-        messages = (
-            'setUpModule',
-            'tearDownModule',
-            'setUpClass',
-            'tearDownClass',
-            'test_something')
-        for phase, msg in enumerate(messages):
-            self.assertRaisesRegexp(Exception, msg, suite.debug)
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_skipping.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_skipping.py
deleted file mode 100644
index 6ad12e9..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_skipping.py
+++ /dev/null
@@ -1,154 +0,0 @@
-from unittest2.test.support import LoggingResult
-
-import unittest2
-
-
-class Test_TestSkipping(unittest2.TestCase):
-
-    def test_skipping(self):
-        class Foo(unittest2.TestCase):
-
-            def test_skip_me(self):
-                self.skipTest("skip")
-        events = []
-        result = LoggingResult(events)
-        test = Foo("test_skip_me")
-        test.run(result)
-        self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
-        self.assertEqual(result.skipped, [(test, "skip")])
-
-        # Try letting setUp skip the test now.
-        class Foo(unittest2.TestCase):
-
-            def setUp(self):
-                self.skipTest("testing")
-
-            def test_nothing(self): pass
-        events = []
-        result = LoggingResult(events)
-        test = Foo("test_nothing")
-        test.run(result)
-        self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
-        self.assertEqual(result.skipped, [(test, "testing")])
-        self.assertEqual(result.testsRun, 1)
-
-    def test_skipping_decorators(self):
-        op_table = ((unittest2.skipUnless, False, True),
-                    (unittest2.skipIf, True, False))
-        for deco, do_skip, dont_skip in op_table:
-            class Foo(unittest2.TestCase):
-
-                @deco(do_skip, "testing")
-                def test_skip(self):
-                    pass
-
-                @deco(dont_skip, "testing")
-                def test_dont_skip(self):
-                    pass
-
-            test_do_skip = Foo("test_skip")
-            test_dont_skip = Foo("test_dont_skip")
-            suite = unittest2.TestSuite([test_do_skip, test_dont_skip])
-            events = []
-            result = LoggingResult(events)
-            suite.run(result)
-            self.assertEqual(len(result.skipped), 1)
-            expected = ['startTest', 'addSkip', 'stopTest',
-                        'startTest', 'addSuccess', 'stopTest']
-            self.assertEqual(events, expected)
-            self.assertEqual(result.testsRun, 2)
-            self.assertEqual(result.skipped, [(test_do_skip, "testing")])
-            self.assertTrue(result.wasSuccessful())
-
-    def test_skip_class(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self):
-                record.append(1)
-
-        # was originally a class decorator...
-        Foo = unittest2.skip("testing")(Foo)
-        record = []
-        result = unittest2.TestResult()
-        test = Foo("test_1")
-        suite = unittest2.TestSuite([test])
-        suite.run(result)
-        self.assertEqual(result.skipped, [(test, "testing")])
-        self.assertEqual(record, [])
-
-    def test_expected_failure(self):
-        class Foo(unittest2.TestCase):
-
-            @unittest2.expectedFailure
-            def test_die(self):
-                self.fail("help me!")
-        events = []
-        result = LoggingResult(events)
-        test = Foo("test_die")
-        test.run(result)
-        self.assertEqual(events,
-                         ['startTest', 'addExpectedFailure', 'stopTest'])
-        self.assertEqual(result.expectedFailures[0][0], test)
-        self.assertTrue(result.wasSuccessful())
-
-    def test_unexpected_success(self):
-        class Foo(unittest2.TestCase):
-
-            @unittest2.expectedFailure
-            def test_die(self):
-                pass
-        events = []
-        result = LoggingResult(events)
-        test = Foo("test_die")
-        test.run(result)
-        self.assertEqual(events,
-                         ['startTest', 'addUnexpectedSuccess', 'stopTest'])
-        self.assertFalse(result.failures)
-        self.assertEqual(result.unexpectedSuccesses, [test])
-        self.assertTrue(result.wasSuccessful())
-
-    def test_skip_doesnt_run_setup(self):
-        class Foo(unittest2.TestCase):
-            wasSetUp = False
-            wasTornDown = False
-
-            def setUp(self):
-                Foo.wasSetUp = True
-
-            def tornDown(self):
-                Foo.wasTornDown = True
-
-            @unittest2.skip('testing')
-            def test_1(self):
-                pass
-
-        result = unittest2.TestResult()
-        test = Foo("test_1")
-        suite = unittest2.TestSuite([test])
-        suite.run(result)
-        self.assertEqual(result.skipped, [(test, "testing")])
-        self.assertFalse(Foo.wasSetUp)
-        self.assertFalse(Foo.wasTornDown)
-
-    def test_decorated_skip(self):
-        def decorator(func):
-            def inner(*a):
-                return func(*a)
-            return inner
-
-        class Foo(unittest2.TestCase):
-
-            @decorator
-            @unittest2.skip('testing')
-            def test_1(self):
-                pass
-
-        result = unittest2.TestResult()
-        test = Foo("test_1")
-        suite = unittest2.TestSuite([test])
-        suite.run(result)
-        self.assertEqual(result.skipped, [(test, "testing")])
-
-
-if __name__ == '__main__':
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_suite.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_suite.py
deleted file mode 100644
index 570a9c6..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_suite.py
+++ /dev/null
@@ -1,363 +0,0 @@
-from unittest2.test.support import EqualityMixin, LoggingResult
-
-import sys
-import unittest2
-
-
-class Test(object):
-
-    class Foo(unittest2.TestCase):
-
-        def test_1(self): pass
-
-        def test_2(self): pass
-
-        def test_3(self): pass
-
-        def runTest(self): pass
-
-
-def _mk_TestSuite(*names):
-    return unittest2.TestSuite(Test.Foo(n) for n in names)
-
-
-class Test_TestSuite(unittest2.TestCase, EqualityMixin):
-
-    # Set up attributes needed by inherited tests
-    ################################################################
-
-    # Used by EqualityMixin.test_eq
-    eq_pairs = [(unittest2.TestSuite(), unittest2.TestSuite()),
-                (unittest2.TestSuite(), unittest2.TestSuite([])),
-                (_mk_TestSuite('test_1'), _mk_TestSuite('test_1'))]
-
-    # Used by EqualityMixin.test_ne
-    ne_pairs = [(unittest2.TestSuite(), _mk_TestSuite('test_1')),
-                (unittest2.TestSuite([]), _mk_TestSuite('test_1')),
-                (_mk_TestSuite('test_1', 'test_2'), _mk_TestSuite('test_1', 'test_3')),
-                (_mk_TestSuite('test_1'), _mk_TestSuite('test_2'))]
-
-    ################################################################
-    # /Set up attributes needed by inherited tests
-
-    # Tests for TestSuite.__init__
-    ################################################################
-
-    # "class TestSuite([tests])"
-    #
-    # The tests iterable should be optional
-    def test_init__tests_optional(self):
-        suite = unittest2.TestSuite()
-
-        self.assertEqual(suite.countTestCases(), 0)
-
-    # "class TestSuite([tests])"
-    # ...
-    # "If tests is given, it must be an iterable of individual test cases
-    # or other test suites that will be used to build the suite initially"
-    #
-    # TestSuite should deal with empty tests iterables by allowing the
-    # creation of an empty suite
-    def test_init__empty_tests(self):
-        suite = unittest2.TestSuite([])
-
-        self.assertEqual(suite.countTestCases(), 0)
-
-    # "class TestSuite([tests])"
-    # ...
-    # "If tests is given, it must be an iterable of individual test cases
-    # or other test suites that will be used to build the suite initially"
-    #
-    # TestSuite should allow any iterable to provide tests
-    def test_init__tests_from_any_iterable(self):
-        def tests():
-            yield unittest2.FunctionTestCase(lambda: None)
-            yield unittest2.FunctionTestCase(lambda: None)
-
-        suite_1 = unittest2.TestSuite(tests())
-        self.assertEqual(suite_1.countTestCases(), 2)
-
-        suite_2 = unittest2.TestSuite(suite_1)
-        self.assertEqual(suite_2.countTestCases(), 2)
-
-        suite_3 = unittest2.TestSuite(set(suite_1))
-        self.assertEqual(suite_3.countTestCases(), 2)
-
-    # "class TestSuite([tests])"
-    # ...
-    # "If tests is given, it must be an iterable of individual test cases
-    # or other test suites that will be used to build the suite initially"
-    #
-    # Does TestSuite() also allow other TestSuite() instances to be present
-    # in the tests iterable?
-    def test_init__TestSuite_instances_in_tests(self):
-        def tests():
-            ftc = unittest2.FunctionTestCase(lambda: None)
-            yield unittest2.TestSuite([ftc])
-            yield unittest2.FunctionTestCase(lambda: None)
-
-        suite = unittest2.TestSuite(tests())
-        self.assertEqual(suite.countTestCases(), 2)
-
-    ################################################################
-    # /Tests for TestSuite.__init__
-
-    # Container types should support the iter protocol
-    def test_iter(self):
-        test1 = unittest2.FunctionTestCase(lambda: None)
-        test2 = unittest2.FunctionTestCase(lambda: None)
-        suite = unittest2.TestSuite((test1, test2))
-
-        self.assertEqual(list(suite), [test1, test2])
-
-    # "Return the number of tests represented by the this test object.
-    # ...this method is also implemented by the TestSuite class, which can
-    # return larger [greater than 1] values"
-    #
-    # Presumably an empty TestSuite returns 0?
-    def test_countTestCases_zero_simple(self):
-        suite = unittest2.TestSuite()
-
-        self.assertEqual(suite.countTestCases(), 0)
-
-    # "Return the number of tests represented by the this test object.
-    # ...this method is also implemented by the TestSuite class, which can
-    # return larger [greater than 1] values"
-    #
-    # Presumably an empty TestSuite (even if it contains other empty
-    # TestSuite instances) returns 0?
-    def test_countTestCases_zero_nested(self):
-        class Test1(unittest2.TestCase):
-
-            def test(self):
-                pass
-
-        suite = unittest2.TestSuite([unittest2.TestSuite()])
-
-        self.assertEqual(suite.countTestCases(), 0)
-
-    # "Return the number of tests represented by the this test object.
-    # ...this method is also implemented by the TestSuite class, which can
-    # return larger [greater than 1] values"
-    def test_countTestCases_simple(self):
-        test1 = unittest2.FunctionTestCase(lambda: None)
-        test2 = unittest2.FunctionTestCase(lambda: None)
-        suite = unittest2.TestSuite((test1, test2))
-
-        self.assertEqual(suite.countTestCases(), 2)
-
-    # "Return the number of tests represented by the this test object.
-    # ...this method is also implemented by the TestSuite class, which can
-    # return larger [greater than 1] values"
-    #
-    # Make sure this holds for nested TestSuite instances, too
-    def test_countTestCases_nested(self):
-        class Test1(unittest2.TestCase):
-
-            def test1(self): pass
-
-            def test2(self): pass
-
-        test2 = unittest2.FunctionTestCase(lambda: None)
-        test3 = unittest2.FunctionTestCase(lambda: None)
-        child = unittest2.TestSuite((Test1('test2'), test2))
-        parent = unittest2.TestSuite((test3, child, Test1('test1')))
-
-        self.assertEqual(parent.countTestCases(), 4)
-
-    # "Run the tests associated with this suite, collecting the result into
-    # the test result object passed as result."
-    #
-    # And if there are no tests? What then?
-    def test_run__empty_suite(self):
-        events = []
-        result = LoggingResult(events)
-
-        suite = unittest2.TestSuite()
-
-        suite.run(result)
-
-        self.assertEqual(events, [])
-
-    # "Note that unlike TestCase.run(), TestSuite.run() requires the
-    # "result object to be passed in."
-    def test_run__requires_result(self):
-        suite = unittest2.TestSuite()
-
-        try:
-            suite.run()
-        except TypeError:
-            pass
-        else:
-            self.fail("Failed to raise TypeError")
-
-    # "Run the tests associated with this suite, collecting the result into
-    # the test result object passed as result."
-    def test_run(self):
-        events = []
-        result = LoggingResult(events)
-
-        class LoggingCase(unittest2.TestCase):
-
-            def run(self, result):
-                events.append('run %s' % self._testMethodName)
-
-            def test1(self): pass
-
-            def test2(self): pass
-
-        tests = [LoggingCase('test1'), LoggingCase('test2')]
-
-        unittest2.TestSuite(tests).run(result)
-
-        self.assertEqual(events, ['run test1', 'run test2'])
-
-    # "Add a TestCase ... to the suite"
-    def test_addTest__TestCase(self):
-        class Foo(unittest2.TestCase):
-
-            def test(self): pass
-
-        test = Foo('test')
-        suite = unittest2.TestSuite()
-
-        suite.addTest(test)
-
-        self.assertEqual(suite.countTestCases(), 1)
-        self.assertEqual(list(suite), [test])
-
-    # "Add a ... TestSuite to the suite"
-    def test_addTest__TestSuite(self):
-        class Foo(unittest2.TestCase):
-
-            def test(self): pass
-
-        suite_2 = unittest2.TestSuite([Foo('test')])
-
-        suite = unittest2.TestSuite()
-        suite.addTest(suite_2)
-
-        self.assertEqual(suite.countTestCases(), 1)
-        self.assertEqual(list(suite), [suite_2])
-
-    # "Add all the tests from an iterable of TestCase and TestSuite
-    # instances to this test suite."
-    #
-    # "This is equivalent to iterating over tests, calling addTest() for
-    # each element"
-    def test_addTests(self):
-        class Foo(unittest2.TestCase):
-
-            def test_1(self): pass
-
-            def test_2(self): pass
-
-        test_1 = Foo('test_1')
-        test_2 = Foo('test_2')
-        inner_suite = unittest2.TestSuite([test_2])
-
-        def gen():
-            yield test_1
-            yield test_2
-            yield inner_suite
-
-        suite_1 = unittest2.TestSuite()
-        suite_1.addTests(gen())
-
-        self.assertEqual(list(suite_1), list(gen()))
-
-        # "This is equivalent to iterating over tests, calling addTest() for
-        # each element"
-        suite_2 = unittest2.TestSuite()
-        for t in gen():
-            suite_2.addTest(t)
-
-        self.assertEqual(suite_1, suite_2)
-
-    # "Add all the tests from an iterable of TestCase and TestSuite
-    # instances to this test suite."
-    #
-    # What happens if it doesn't get an iterable?
-    def test_addTest__noniterable(self):
-        suite = unittest2.TestSuite()
-
-        try:
-            suite.addTests(5)
-        except TypeError:
-            pass
-        else:
-            self.fail("Failed to raise TypeError")
-
-    def test_addTest__noncallable(self):
-        suite = unittest2.TestSuite()
-        self.assertRaises(TypeError, suite.addTest, 5)
-
-    def test_addTest__casesuiteclass(self):
-        suite = unittest2.TestSuite()
-        self.assertRaises(TypeError, suite.addTest, Test_TestSuite)
-        self.assertRaises(TypeError, suite.addTest, unittest2.TestSuite)
-
-    def test_addTests__string(self):
-        suite = unittest2.TestSuite()
-        self.assertRaises(TypeError, suite.addTests, "foo")
-
-    def test_function_in_suite(self):
-        def f(_):
-            pass
-        suite = unittest2.TestSuite()
-        suite.addTest(f)
-
-        # when the bug is fixed this line will not crash
-        suite.run(unittest2.TestResult())
-
-    def test_basetestsuite(self):
-        class Test(unittest2.TestCase):
-            wasSetUp = False
-            wasTornDown = False
-
-            @classmethod
-            def setUpClass(cls):
-                cls.wasSetUp = True
-
-            @classmethod
-            def tearDownClass(cls):
-                cls.wasTornDown = True
-
-            def testPass(self):
-                pass
-
-            def testFail(self):
-                fail
-
-        class Module(object):
-            wasSetUp = False
-            wasTornDown = False
-
-            @staticmethod
-            def setUpModule():
-                Module.wasSetUp = True
-
-            @staticmethod
-            def tearDownModule():
-                Module.wasTornDown = True
-
-        Test.__module__ = 'Module'
-        sys.modules['Module'] = Module
-        self.addCleanup(sys.modules.pop, 'Module')
-
-        suite = unittest2.BaseTestSuite()
-        suite.addTests([Test('testPass'), Test('testFail')])
-        self.assertEqual(suite.countTestCases(), 2)
-
-        result = unittest2.TestResult()
-        suite.run(result)
-        self.assertFalse(Module.wasSetUp)
-        self.assertFalse(Module.wasTornDown)
-        self.assertFalse(Test.wasSetUp)
-        self.assertFalse(Test.wasTornDown)
-        self.assertEqual(len(result.errors), 1)
-        self.assertEqual(len(result.failures), 0)
-        self.assertEqual(result.testsRun, 2)
-
-if __name__ == '__main__':
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/test/test_unittest2_with.py b/lldb/third_party/Python/module/unittest2/unittest2/test/test_unittest2_with.py
deleted file mode 100644
index 7544757..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/test/test_unittest2_with.py
+++ /dev/null
@@ -1,148 +0,0 @@
-import unittest2
-from unittest2.test.support import OldTestResult, catch_warnings
-
-import warnings
-# needed to enable the deprecation warnings
-warnings.simplefilter('default')
-
-
-class TestWith(unittest2.TestCase):
-    """Tests that use the with statement live in this
-    module so that all other tests can be run with Python 2.4.
-    """
-
-    def testAssertRaisesExcValue(self):
-        class ExceptionMock(Exception):
-            pass
-
-        def Stub(foo):
-            raise ExceptionMock(foo)
-        v = "particular value"
-
-        ctx = self.assertRaises(ExceptionMock)
-        with ctx:
-            Stub(v)
-        e = ctx.exception
-        self.assertIsInstance(e, ExceptionMock)
-        self.assertEqual(e.args[0], v)
-
-    def test_assertRaises(self):
-        def _raise(e):
-            raise e
-        self.assertRaises(KeyError, _raise, KeyError)
-        self.assertRaises(KeyError, _raise, KeyError("key"))
-        try:
-            self.assertRaises(KeyError, lambda: None)
-        except self.failureException as e:
-            self.assertIn("KeyError not raised", e.args)
-        else:
-            self.fail("assertRaises() didn't fail")
-        try:
-            self.assertRaises(KeyError, _raise, ValueError)
-        except ValueError:
-            pass
-        else:
-            self.fail("assertRaises() didn't let exception pass through")
-        with self.assertRaises(KeyError) as cm:
-            try:
-                raise KeyError
-            except Exception as e:
-                raise
-        self.assertIs(cm.exception, e)
-
-        with self.assertRaises(KeyError):
-            raise KeyError("key")
-        try:
-            with self.assertRaises(KeyError):
-                pass
-        except self.failureException as e:
-            self.assertIn("KeyError not raised", e.args)
-        else:
-            self.fail("assertRaises() didn't fail")
-        try:
-            with self.assertRaises(KeyError):
-                raise ValueError
-        except ValueError:
-            pass
-        else:
-            self.fail("assertRaises() didn't let exception pass through")
-
-    def test_assert_dict_unicode_error(self):
-        with catch_warnings(record=True):
-            # This causes a UnicodeWarning due to its craziness
-            one = ''.join(chr(i) for i in range(255))
-            # this used to cause a UnicodeDecodeError constructing the failure
-            # msg
-            with self.assertRaises(self.failureException):
-                self.assertDictContainsSubset({'foo': one}, {'foo': u'\uFFFD'})
-
-    def test_formatMessage_unicode_error(self):
-        with catch_warnings(record=True):
-            # This causes a UnicodeWarning due to its craziness
-            one = ''.join(chr(i) for i in range(255))
-            # this used to cause a UnicodeDecodeError constructing msg
-            self._formatMessage(one, u'\uFFFD')
-
-    def assertOldResultWarning(self, test, failures):
-        with catch_warnings(record=True) as log:
-            result = OldTestResult()
-            test.run(result)
-            self.assertEqual(len(result.failures), failures)
-            warning, = log
-            self.assertIs(warning.category, DeprecationWarning)
-
-    def test_old_testresult(self):
-        class Test(unittest2.TestCase):
-
-            def testSkip(self):
-                self.skipTest('foobar')
-
-            @unittest2.expectedFailure
-            def testExpectedFail(self):
-                raise TypeError
-
-            @unittest2.expectedFailure
-            def testUnexpectedSuccess(self):
-                pass
-
-        for test_name, should_pass in (('testSkip', True),
-                                       ('testExpectedFail', True),
-                                       ('testUnexpectedSuccess', False)):
-            test = Test(test_name)
-            self.assertOldResultWarning(test, int(not should_pass))
-
-    def test_old_testresult_setup(self):
-        class Test(unittest2.TestCase):
-
-            def setUp(self):
-                self.skipTest('no reason')
-
-            def testFoo(self):
-                pass
-        self.assertOldResultWarning(Test('testFoo'), 0)
-
-    def test_old_testresult_class(self):
-        class Test(unittest2.TestCase):
-
-            def testFoo(self):
-                pass
-        Test = unittest2.skip('no reason')(Test)
-        self.assertOldResultWarning(Test('testFoo'), 0)
-
-    def testPendingDeprecationMethodNames(self):
-        """Test fail* methods pending deprecation, they will warn in 3.2.
-
-        Do not use these methods.  They will go away in 3.3.
-        """
-        with catch_warnings(record=True):
-            self.failIfEqual(3, 5)
-            self.failUnlessEqual(3, 3)
-            self.failUnlessAlmostEqual(2.0, 2.0)
-            self.failIfAlmostEqual(3.0, 5.0)
-            self.failUnless(True)
-            self.failUnlessRaises(TypeError, lambda _: 3.14 + u'spam')
-            self.failIf(False)
-
-
-if __name__ == '__main__':
-    unittest2.main()
diff --git a/lldb/third_party/Python/module/unittest2/unittest2/util.py b/lldb/third_party/Python/module/unittest2/unittest2/util.py
deleted file mode 100644
index d059861..0000000
--- a/lldb/third_party/Python/module/unittest2/unittest2/util.py
+++ /dev/null
@@ -1,105 +0,0 @@
-"""Various utility functions."""
-
-__unittest = True
-
-
-_MAX_LENGTH = 80
-
-
-def safe_repr(obj, short=False):
-    try:
-        result = repr(obj)
-    except Exception:
-        result = object.__repr__(obj)
-    if not short or len(result) < _MAX_LENGTH:
-        return result
-    return result[:_MAX_LENGTH] + ' [truncated]...'
-
-
-def safe_str(obj):
-    try:
-        return str(obj)
-    except Exception:
-        return object.__str__(obj)
-
-
-def strclass(cls):
-    return "%s.%s" % (cls.__module__, cls.__name__)
-
-
-def sorted_list_difference(expected, actual):
-    """Finds elements in only one or the other of two, sorted input lists.
-
-    Returns a two-element tuple of lists.    The first list contains those
-    elements in the "expected" list but not in the "actual" list, and the
-    second contains those elements in the "actual" list but not in the
-    "expected" list.    Duplicate elements in either input list are ignored.
-    """
-    i = j = 0
-    missing = []
-    unexpected = []
-    while True:
-        try:
-            e = expected[i]
-            a = actual[j]
-            if e < a:
-                missing.append(e)
-                i += 1
-                while expected[i] == e:
-                    i += 1
-            elif e > a:
-                unexpected.append(a)
-                j += 1
-                while actual[j] == a:
-                    j += 1
-            else:
-                i += 1
-                try:
-                    while expected[i] == e:
-                        i += 1
-                finally:
-                    j += 1
-                    while actual[j] == a:
-                        j += 1
-        except IndexError:
-            missing.extend(expected[i:])
-            unexpected.extend(actual[j:])
-            break
-    return missing, unexpected
-
-
-def unorderable_list_difference(expected, actual, ignore_duplicate=False):
-    """Same behavior as sorted_list_difference but
-    for lists of unorderable items (like dicts).
-
-    As it does a linear search per item (remove) it
-    has O(n*n) performance.
-    """
-    missing = []
-    unexpected = []
-    while expected:
-        item = expected.pop()
-        try:
-            actual.remove(item)
-        except ValueError:
-            missing.append(item)
-        if ignore_duplicate:
-            for lst in expected, actual:
-                try:
-                    while True:
-                        lst.remove(item)
-                except ValueError:
-                    pass
-    if ignore_duplicate:
-        while actual:
-            item = actual.pop()
-            unexpected.append(item)
-            try:
-                while True:
-                    actual.remove(item)
-            except ValueError:
-                pass
-        return missing, unexpected
-
-    # anything left in actual is unexpected
-    return missing, actual