human
Solve the following python programming problem given the following code:
@nottest
def subtest(iterator, *_names):
assistant
#Here is the Python code you requested.

    """Construct a subtest in a unittest.
    Consider using ``zipline.testing.parameter_space`` when subtests
    are constructed over a single input or over the cross-product of multiple
    inputs.
    ``subtest`` works by decorating a function as a subtest. The decorated
    function will be run by iterating over the ``iterator`` and *unpacking the
    values into the function. If any of the runs fail, the result will be put
    into a set and the rest of the tests will be run. Finally, if any failed,
    all of the results will be dumped as one failure.
    Parameters
    iterator : iterable[iterable]
    The iterator of arguments to pass to the function.
    *name : iterator[str]
    The names to use for each element of ``iterator``. These will be used
    to print the scope when a test fails. If not provided, it will use the
    integer index of the value as the name.
    Examples
    class MyTest(TestCase):
    def test_thing(self):
    # Example usage inside another test.
    @subtest(([n] for n in range(100000)), \n\)
    def subtest(n):
    self.assertEqual(n % 2, 0, \n was not even\)
    subtest()
    @subtest(([n] for n in range(100000)), \n\)
    def test_decorated_function(self, n):
    # Example usage to parameterize an entire function.
    self.assertEqual(n % 2, 1, \n was not odd\)
    Notes
    We use this when we:
    * Will never want to run each parameter individually.
    * Have a large parameter space we are testing
    (see tests/utils/test_events.py).
    ``nose_parameterized.expand`` will create a test for each parameter
    combination which bloats the test output and makes the travis pages slow.
    We cannot use ``unittest2.TestCase.subTest`` because nose, pytest, and
    nose2 do not support ``addSubTest``.
    See Also
    zipline.testing.parameter_space
    """
    def dec(f):
        @wraps(f)
        def wrapped(*args, **kwargs):
            names = _names
            failures = []
            for scope in iterator:
                scope = tuple(scope)
                try:
                    f(*(args + scope), **kwargs)
                except Exception as e:
                    if (not names):
                        names = count()
                    failures.append((dict(zip(names, scope)), e))
            if failures:
                raise SubTestFailures(*failures)
        return wrapped
    return dec