Remove concurrencytest

While our version is better, it is tricky to use it when we are trying
to package things with pip. Drop it.

Somewhat reduced functionality is provided by the upstream version[1],
along with a rather annoying message each time it is used[2] [3].

[1] pip install concurrencytest
[2] https://github.com/cgoldberg/concurrencytest/issues/12
[3] https://github.com/cgoldberg/concurrencytest/pull/14

Signed-off-by: Simon Glass <sjg@chromium.org>

5 files changed, 2 insertions, 221 deletions

diff --git a/tools/concurrencytest/.gitignore b/tools/concurrencytest/.gitignore
deleted file mode 100644
index 0d20b6487c6..00000000000
--- a/tools/concurrencytest/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-*.pyc
diff --git a/tools/concurrencytest/README.md b/tools/concurrencytest/README.md
deleted file mode 100644
index 2d7fe75df53..00000000000
--- a/tools/concurrencytest/README.md
+++ /dev/null
@@ -1,74 +0,0 @@
-concurrencytest
-===============
-
-![testing goats](https://raw.github.com/cgoldberg/concurrencytest/master/testing-goats.png "testing goats")
-
-Python testtools extension for running unittest suites concurrently.
-
-----
-
-Install from PyPI:
-```
-pip install concurrencytest
-```
-
-----
-
-Requires:
-
-* [testtools](https://pypi.python.org/pypi/testtools) : `pip install testtools`
-* [python-subunit](https://pypi.python.org/pypi/python-subunit) : `pip install python-subunit`
-
-----
-
-Example:
-
-```python
-import time
-import unittest
-
-from concurrencytest import ConcurrentTestSuite, fork_for_tests
-
-
-class SampleTestCase(unittest.TestCase):
-    """Dummy tests that sleep for demo."""
-
-    def test_me_1(self):
-        time.sleep(0.5)
-
-    def test_me_2(self):
-        time.sleep(0.5)
-
-    def test_me_3(self):
-        time.sleep(0.5)
-
-    def test_me_4(self):
-        time.sleep(0.5)
-
-
-# Load tests from SampleTestCase defined above
-suite = unittest.TestLoader().loadTestsFromTestCase(SampleTestCase)
-runner = unittest.TextTestRunner()
-
-# Run tests sequentially
-runner.run(suite)
-
-# Run same tests across 4 processes
-suite = unittest.TestLoader().loadTestsFromTestCase(SampleTestCase)
-concurrent_suite = ConcurrentTestSuite(suite, fork_for_tests(4))
-runner.run(concurrent_suite)
-```
-Output:
-
-```
-....
-----------------------------------------------------------------------
-Ran 4 tests in 2.003s
-
-OK
-....
-----------------------------------------------------------------------
-Ran 4 tests in 0.504s
-
-OK
-```
diff --git a/tools/concurrencytest/__init__.py b/tools/concurrencytest/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
--- a/tools/concurrencytest/__init__.py
+++ /dev/null
diff --git a/tools/concurrencytest/concurrencytest.py b/tools/concurrencytest/concurrencytest.py
deleted file mode 100644
index 5e88b94f415..00000000000
--- a/tools/concurrencytest/concurrencytest.py
+++ /dev/null
@@ -1,144 +0,0 @@
-#!/usr/bin/env python
-# SPDX-License-Identifier: GPL-2.0+
-#
-# Modified by: Corey Goldberg, 2013
-#
-# Original code from:
-#   Bazaar (bzrlib.tests.__init__.py, v2.6, copied Jun 01 2013)
-#   Copyright (C) 2005-2011 Canonical Ltd
-
-"""Python testtools extension for running unittest suites concurrently.
-
-The `testtools` project provides a ConcurrentTestSuite class, but does
-not provide a `make_tests` implementation needed to use it.
-
-This allows you to parallelize a test run across a configurable number
-of worker processes. While this can speed up CPU-bound test runs, it is
-mainly useful for IO-bound tests that spend most of their time waiting for
-data to arrive from someplace else and can benefit from cocncurrency.
-
-Unix only.
-"""
-
-import os
-import sys
-import traceback
-import unittest
-from itertools import cycle
-from multiprocessing import cpu_count
-
-from subunit import ProtocolTestCase, TestProtocolClient
-from subunit.test_results import AutoTimingTestResultDecorator
-
-from testtools import ConcurrentTestSuite, iterate_tests
-
-
-_all__ = [
-    'ConcurrentTestSuite',
-    'fork_for_tests',
-    'partition_tests',
-]
-
-
-CPU_COUNT = cpu_count()
-
-
-def fork_for_tests(concurrency_num=CPU_COUNT):
-    """Implementation of `make_tests` used to construct `ConcurrentTestSuite`.
-
-    :param concurrency_num: number of processes to use.
-    """
-    def do_fork(suite):
-        """Take suite and start up multiple runners by forking (Unix only).
-
-        :param suite: TestSuite object.
-
-        :return: An iterable of TestCase-like objects which can each have
-        run(result) called on them to feed tests to result.
-        """
-        result = []
-        test_blocks = partition_tests(suite, concurrency_num)
-        # Clear the tests from the original suite so it doesn't keep them alive
-        suite._tests[:] = []
-        for process_tests in test_blocks:
-            process_suite = unittest.TestSuite(process_tests)
-            # Also clear each split list so new suite has only reference
-            process_tests[:] = []
-            c2pread, c2pwrite = os.pipe()
-            pid = os.fork()
-            if pid == 0:
-                try:
-                    stream = os.fdopen(c2pwrite, 'wb')
-                    os.close(c2pread)
-                    # Leave stderr and stdout open so we can see test noise
-                    # Close stdin so that the child goes away if it decides to
-                    # read from stdin (otherwise its a roulette to see what
-                    # child actually gets keystrokes for pdb etc).
-                    sys.stdin.close()
-                    subunit_result = AutoTimingTestResultDecorator(
-                        TestProtocolClient(stream)
-                    )
-                    process_suite.run(subunit_result)
-                except:
-                    # Try and report traceback on stream, but exit with error
-                    # even if stream couldn't be created or something else
-                    # goes wrong.  The traceback is formatted to a string and
-                    # written in one go to avoid interleaving lines from
-                    # multiple failing children.
-                    try:
-                        stream.write(traceback.format_exc())
-                    finally:
-                        os._exit(1)
-                os._exit(0)
-            else:
-                os.close(c2pwrite)
-                stream = os.fdopen(c2pread, 'rb')
-                test = ProtocolTestCase(stream)
-                result.append(test)
-        return result
-    return do_fork
-
-
-def partition_tests(suite, count):
-    """Partition suite into count lists of tests."""
-    # This just assigns tests in a round-robin fashion.  On one hand this
-    # splits up blocks of related tests that might run faster if they shared
-    # resources, but on the other it avoids assigning blocks of slow tests to
-    # just one partition.  So the slowest partition shouldn't be much slower
-    # than the fastest.
-    partitions = [list() for _ in range(count)]
-    tests = iterate_tests(suite)
-    for partition, test in zip(cycle(partitions), tests):
-        partition.append(test)
-    return partitions
-
-
-if __name__ == '__main__':
-    import time
-
-    class SampleTestCase(unittest.TestCase):
-        """Dummy tests that sleep for demo."""
-
-        def test_me_1(self):
-            time.sleep(0.5)
-
-        def test_me_2(self):
-            time.sleep(0.5)
-
-        def test_me_3(self):
-            time.sleep(0.5)
-
-        def test_me_4(self):
-            time.sleep(0.5)
-
-    # Load tests from SampleTestCase defined above
-    suite = unittest.TestLoader().loadTestsFromTestCase(SampleTestCase)
-    runner = unittest.TextTestRunner()
-
-    # Run tests sequentially
-    runner.run(suite)
-
-    # Run same tests across 4 processes
-    suite = unittest.TestLoader().loadTestsFromTestCase(SampleTestCase)
-    concurrent_suite = ConcurrentTestSuite(suite, fork_for_tests(4))
-    runner.run(concurrent_suite)
diff --git a/tools/patman/test_util.py b/tools/patman/test_util.py
index 4ee58f9fbb9..9e0811b61a2 100644
--- a/tools/patman/test_util.py
+++ b/tools/patman/test_util.py
@@ -17,8 +17,8 @@ from io import StringIO
 
 use_concurrent = True
 try:
-    from concurrencytest.concurrencytest import ConcurrentTestSuite
-    from concurrencytest.concurrencytest import fork_for_tests
+    from concurrencytest import ConcurrentTestSuite
+    from concurrencytest import fork_for_tests
 except:
     use_concurrent = False