com.googler.python 1.1.2 → 1.1.4

package/python3.6.2/lib/python3.6/test/test_coroutines.py

@@ -1,2151 +0,0 @@
-import contextlib
-import copy
-import inspect
-import pickle
-import sys
-import types
-import unittest
-import warnings
-from test import support
-
-
-class AsyncYieldFrom:
-    def __init__(self, obj):
-        self.obj = obj
-
-    def __await__(self):
-        yield from self.obj
-
-
-class AsyncYield:
-    def __init__(self, value):
-        self.value = value
-
-    def __await__(self):
-        yield self.value
-
-
-def run_async(coro):
-    assert coro.__class__ in {types.GeneratorType, types.CoroutineType}
-
-    buffer = []
-    result = None
-    while True:
-        try:
-            buffer.append(coro.send(None))
-        except StopIteration as ex:
-            result = ex.args[0] if ex.args else None
-            break
-    return buffer, result
-
-
-def run_async__await__(coro):
-    assert coro.__class__ is types.CoroutineType
-    aw = coro.__await__()
-    buffer = []
-    result = None
-    i = 0
-    while True:
-        try:
-            if i % 2:
-                buffer.append(next(aw))
-            else:
-                buffer.append(aw.send(None))
-            i += 1
-        except StopIteration as ex:
-            result = ex.args[0] if ex.args else None
-            break
-    return buffer, result
-
-
-@contextlib.contextmanager
-def silence_coro_gc():
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        yield
-        support.gc_collect()
-
-
-class AsyncBadSyntaxTest(unittest.TestCase):
-
-    def test_badsyntax_1(self):
-        samples = [
-            """def foo():
-                await something()
-            """,
-
-            """await something()""",
-
-            """async def foo():
-                yield from []
-            """,
-
-            """async def foo():
-                await await fut
-            """,
-
-            """async def foo(a=await something()):
-                pass
-            """,
-
-            """async def foo(a:await something()):
-                pass
-            """,
-
-            """async def foo():
-                def bar():
-                 [i async for i in els]
-            """,
-
-            """async def foo():
-                def bar():
-                 [await i for i in els]
-            """,
-
-            """async def foo():
-                def bar():
-                 [i for i in els
-                    async for b in els]
-            """,
-
-            """async def foo():
-                def bar():
-                 [i for i in els
-                    for c in b
-                    async for b in els]
-            """,
-
-            """async def foo():
-                def bar():
-                 [i for i in els
-                    async for b in els
-                    for c in b]
-            """,
-
-            """async def foo():
-                def bar():
-                 [i for i in els
-                    for b in await els]
-            """,
-
-            """async def foo():
-                def bar():
-                 [i for i in els
-                    for b in els
-                        if await b]
-            """,
-
-            """async def foo():
-                def bar():
-                 [i for i in await els]
-            """,
-
-            """async def foo():
-                def bar():
-                 [i for i in els if await i]
-            """,
-
-            """def bar():
-                 [i async for i in els]
-            """,
-
-            """def bar():
-                 [await i for i in els]
-            """,
-
-            """def bar():
-                 [i for i in els
-                    async for b in els]
-            """,
-
-            """def bar():
-                 [i for i in els
-                    for c in b
-                    async for b in els]
-            """,
-
-            """def bar():
-                 [i for i in els
-                    async for b in els
-                    for c in b]
-            """,
-
-            """def bar():
-                 [i for i in els
-                    for b in await els]
-            """,
-
-            """def bar():
-                 [i for i in els
-                    for b in els
-                        if await b]
-            """,
-
-            """def bar():
-                 [i for i in await els]
-            """,
-
-            """def bar():
-                 [i for i in els if await i]
-            """,
-
-            """async def foo():
-                await
-            """,
-
-            """async def foo():
-                   def bar(): pass
-                   await = 1
-            """,
-
-            """async def foo():
-
-                   def bar(): pass
-                   await = 1
-            """,
-
-            """async def foo():
-                   def bar(): pass
-                   if 1:
-                       await = 1
-            """,
-
-            """def foo():
-                   async def bar(): pass
-                   if 1:
-                       await a
-            """,
-
-            """def foo():
-                   async def bar(): pass
-                   await a
-            """,
-
-            """def foo():
-                   def baz(): pass
-                   async def bar(): pass
-                   await a
-            """,
-
-            """def foo():
-                   def baz(): pass
-                   # 456
-                   async def bar(): pass
-                   # 123
-                   await a
-            """,
-
-            """async def foo():
-                   def baz(): pass
-                   # 456
-                   async def bar(): pass
-                   # 123
-                   await = 2
-            """,
-
-            """def foo():
-
-                   def baz(): pass
-
-                   async def bar(): pass
-
-                   await a
-            """,
-
-            """async def foo():
-
-                   def baz(): pass
-
-                   async def bar(): pass
-
-                   await = 2
-            """,
-
-            """async def foo():
-                   def async(): pass
-            """,
-
-            """async def foo():
-                   def await(): pass
-            """,
-
-            """async def foo():
-                   def bar():
-                       await
-            """,
-
-            """async def foo():
-                   return lambda async: await
-            """,
-
-            """async def foo():
-                   return lambda a: await
-            """,
-
-            """await a()""",
-
-            """async def foo(a=await b):
-                   pass
-            """,
-
-            """async def foo(a:await b):
-                   pass
-            """,
-
-            """def baz():
-                   async def foo(a=await b):
-                       pass
-            """,
-
-            """async def foo(async):
-                   pass
-            """,
-
-            """async def foo():
-                   def bar():
-                        def baz():
-                            async = 1
-            """,
-
-            """async def foo():
-                   def bar():
-                        def baz():
-                            pass
-                        async = 1
-            """,
-
-            """def foo():
-                   async def bar():
-
-                        async def baz():
-                            pass
-
-                        def baz():
-                            42
-
-                        async = 1
-            """,
-
-            """async def foo():
-                   def bar():
-                        def baz():
-                            pass\nawait foo()
-            """,
-
-            """def foo():
-                   def bar():
-                        async def baz():
-                            pass\nawait foo()
-            """,
-
-            """async def foo(await):
-                   pass
-            """,
-
-            """def foo():
-
-                   async def bar(): pass
-
-                   await a
-            """,
-
-            """def foo():
-                   async def bar():
-                        pass\nawait a
-            """]
-
-        for code in samples:
-            with self.subTest(code=code), self.assertRaises(SyntaxError):
-                compile(code, "<test>", "exec")
-
-    def test_badsyntax_2(self):
-        samples = [
-            """def foo():
-                await = 1
-            """,
-
-            """class Bar:
-                def async(): pass
-            """,
-
-            """class Bar:
-                async = 1
-            """,
-
-            """class async:
-                pass
-            """,
-
-            """class await:
-                pass
-            """,
-
-            """import math as await""",
-
-            """def async():
-                pass""",
-
-            """def foo(*, await=1):
-                pass"""
-
-            """async = 1""",
-
-            """print(await=1)"""
-        ]
-
-        for code in samples:
-            with self.subTest(code=code), self.assertWarnsRegex(
-                    DeprecationWarning,
-                    "'await' will become reserved keywords"):
-                compile(code, "<test>", "exec")
-
-    def test_badsyntax_3(self):
-        with self.assertRaises(DeprecationWarning):
-            with warnings.catch_warnings():
-                warnings.simplefilter("error")
-                compile("async = 1", "<test>", "exec")
-
-    def test_goodsyntax_1(self):
-        # Tests for issue 24619
-
-        samples = [
-            '''def foo(await):
-                async def foo(): pass
-                async def foo():
-                    pass
-                return await + 1
-            ''',
-
-            '''def foo(await):
-                async def foo(): pass
-                async def foo(): pass
-                return await + 1
-            ''',
-
-            '''def foo(await):
-
-                async def foo(): pass
-
-                async def foo(): pass
-
-                return await + 1
-            ''',
-
-            '''def foo(await):
-                """spam"""
-                async def foo(): \
-                    pass
-                # 123
-                async def foo(): pass
-                # 456
-                return await + 1
-            ''',
-
-            '''def foo(await):
-                def foo(): pass
-                def foo(): pass
-                async def bar(): return await_
-                await_ = await
-                try:
-                    bar().send(None)
-                except StopIteration as ex:
-                    return ex.args[0] + 1
-            '''
-        ]
-
-        for code in samples:
-            with self.subTest(code=code):
-                loc = {}
-
-                with warnings.catch_warnings():
-                    warnings.simplefilter("ignore")
-                    exec(code, loc, loc)
-
-                self.assertEqual(loc['foo'](10), 11)
-
-
-class TokenizerRegrTest(unittest.TestCase):
-
-    def test_oneline_defs(self):
-        buf = []
-        for i in range(500):
-            buf.append('def i{i}(): return {i}'.format(i=i))
-        buf = '\n'.join(buf)
-
-        # Test that 500 consequent, one-line defs is OK
-        ns = {}
-        exec(buf, ns, ns)
-        self.assertEqual(ns['i499'](), 499)
-
-        # Test that 500 consequent, one-line defs *and*
-        # one 'async def' following them is OK
-        buf += '\nasync def foo():\n    return'
-        ns = {}
-        exec(buf, ns, ns)
-        self.assertEqual(ns['i499'](), 499)
-        self.assertTrue(inspect.iscoroutinefunction(ns['foo']))
-
-
-class CoroutineTest(unittest.TestCase):
-
-    def test_gen_1(self):
-        def gen(): yield
-        self.assertFalse(hasattr(gen, '__await__'))
-
-    def test_func_1(self):
-        async def foo():
-            return 10
-
-        f = foo()
-        self.assertIsInstance(f, types.CoroutineType)
-        self.assertTrue(bool(foo.__code__.co_flags & inspect.CO_COROUTINE))
-        self.assertFalse(bool(foo.__code__.co_flags & inspect.CO_GENERATOR))
-        self.assertTrue(bool(f.cr_code.co_flags & inspect.CO_COROUTINE))
-        self.assertFalse(bool(f.cr_code.co_flags & inspect.CO_GENERATOR))
-        self.assertEqual(run_async(f), ([], 10))
-
-        self.assertEqual(run_async__await__(foo()), ([], 10))
-
-        def bar(): pass
-        self.assertFalse(bool(bar.__code__.co_flags & inspect.CO_COROUTINE))
-
-    def test_func_2(self):
-        async def foo():
-            raise StopIteration
-
-        with self.assertRaisesRegex(
-                RuntimeError, "coroutine raised StopIteration"):
-
-            run_async(foo())
-
-    def test_func_3(self):
-        async def foo():
-            raise StopIteration
-
-        with silence_coro_gc():
-            self.assertRegex(repr(foo()), '^<coroutine object.* at 0x.*>$')
-
-    def test_func_4(self):
-        async def foo():
-            raise StopIteration
-
-        check = lambda: self.assertRaisesRegex(
-            TypeError, "'coroutine' object is not iterable")
-
-        with check():
-            list(foo())
-
-        with check():
-            tuple(foo())
-
-        with check():
-            sum(foo())
-
-        with check():
-            iter(foo())
-
-        with silence_coro_gc(), check():
-            for i in foo():
-                pass
-
-        with silence_coro_gc(), check():
-            [i for i in foo()]
-
-    def test_func_5(self):
-        @types.coroutine
-        def bar():
-            yield 1
-
-        async def foo():
-            await bar()
-
-        check = lambda: self.assertRaisesRegex(
-            TypeError, "'coroutine' object is not iterable")
-
-        with check():
-            for el in foo(): pass
-
-        # the following should pass without an error
-        for el in bar():
-            self.assertEqual(el, 1)
-        self.assertEqual([el for el in bar()], [1])
-        self.assertEqual(tuple(bar()), (1,))
-        self.assertEqual(next(iter(bar())), 1)
-
-    def test_func_6(self):
-        @types.coroutine
-        def bar():
-            yield 1
-            yield 2
-
-        async def foo():
-            await bar()
-
-        f = foo()
-        self.assertEqual(f.send(None), 1)
-        self.assertEqual(f.send(None), 2)
-        with self.assertRaises(StopIteration):
-            f.send(None)
-
-    def test_func_7(self):
-        async def bar():
-            return 10
-
-        def foo():
-            yield from bar()
-
-        with silence_coro_gc(), self.assertRaisesRegex(
-            TypeError,
-            "cannot 'yield from' a coroutine object in a non-coroutine generator"):
-
-            list(foo())
-
-    def test_func_8(self):
-        @types.coroutine
-        def bar():
-            return (yield from foo())
-
-        async def foo():
-            return 'spam'
-
-        self.assertEqual(run_async(bar()), ([], 'spam') )
-
-    def test_func_9(self):
-        async def foo(): pass
-
-        with self.assertWarnsRegex(
-            RuntimeWarning, "coroutine '.*test_func_9.*foo' was never awaited"):
-
-            foo()
-            support.gc_collect()
-
-    def test_func_10(self):
-        N = 0
-
-        @types.coroutine
-        def gen():
-            nonlocal N
-            try:
-                a = yield
-                yield (a ** 2)
-            except ZeroDivisionError:
-                N += 100
-                raise
-            finally:
-                N += 1
-
-        async def foo():
-            await gen()
-
-        coro = foo()
-        aw = coro.__await__()
-        self.assertIs(aw, iter(aw))
-        next(aw)
-        self.assertEqual(aw.send(10), 100)
-
-        self.assertEqual(N, 0)
-        aw.close()
-        self.assertEqual(N, 1)
-
-        coro = foo()
-        aw = coro.__await__()
-        next(aw)
-        with self.assertRaises(ZeroDivisionError):
-            aw.throw(ZeroDivisionError, None, None)
-        self.assertEqual(N, 102)
-
-    def test_func_11(self):
-        async def func(): pass
-        coro = func()
-        # Test that PyCoro_Type and _PyCoroWrapper_Type types were properly
-        # initialized
-        self.assertIn('__await__', dir(coro))
-        self.assertIn('__iter__', dir(coro.__await__()))
-        self.assertIn('coroutine_wrapper', repr(coro.__await__()))
-        coro.close() # avoid RuntimeWarning
-
-    def test_func_12(self):
-        async def g():
-            i = me.send(None)
-            await foo
-        me = g()
-        with self.assertRaisesRegex(ValueError,
-                                    "coroutine already executing"):
-            me.send(None)
-
-    def test_func_13(self):
-        async def g():
-            pass
-        with self.assertRaisesRegex(
-            TypeError,
-            "can't send non-None value to a just-started coroutine"):
-
-            g().send('spam')
-
-    def test_func_14(self):
-        @types.coroutine
-        def gen():
-            yield
-        async def coro():
-            try:
-                await gen()
-            except GeneratorExit:
-                await gen()
-        c = coro()
-        c.send(None)
-        with self.assertRaisesRegex(RuntimeError,
-                                    "coroutine ignored GeneratorExit"):
-            c.close()
-
-    def test_func_15(self):
-        # See http://bugs.python.org/issue25887 for details
-
-        async def spammer():
-            return 'spam'
-        async def reader(coro):
-            return await coro
-
-        spammer_coro = spammer()
-
-        with self.assertRaisesRegex(StopIteration, 'spam'):
-            reader(spammer_coro).send(None)
-
-        with self.assertRaisesRegex(RuntimeError,
-                                    'cannot reuse already awaited coroutine'):
-            reader(spammer_coro).send(None)
-
-    def test_func_16(self):
-        # See http://bugs.python.org/issue25887 for details
-
-        @types.coroutine
-        def nop():
-            yield
-        async def send():
-            await nop()
-            return 'spam'
-        async def read(coro):
-            await nop()
-            return await coro
-
-        spammer = send()
-
-        reader = read(spammer)
-        reader.send(None)
-        reader.send(None)
-        with self.assertRaisesRegex(Exception, 'ham'):
-            reader.throw(Exception('ham'))
-
-        reader = read(spammer)
-        reader.send(None)
-        with self.assertRaisesRegex(RuntimeError,
-                                    'cannot reuse already awaited coroutine'):
-            reader.send(None)
-
-        with self.assertRaisesRegex(RuntimeError,
-                                    'cannot reuse already awaited coroutine'):
-            reader.throw(Exception('wat'))
-
-    def test_func_17(self):
-        # See http://bugs.python.org/issue25887 for details
-
-        async def coroutine():
-            return 'spam'
-
-        coro = coroutine()
-        with self.assertRaisesRegex(StopIteration, 'spam'):
-            coro.send(None)
-
-        with self.assertRaisesRegex(RuntimeError,
-                                    'cannot reuse already awaited coroutine'):
-            coro.send(None)
-
-        with self.assertRaisesRegex(RuntimeError,
-                                    'cannot reuse already awaited coroutine'):
-            coro.throw(Exception('wat'))
-
-        # Closing a coroutine shouldn't raise any exception even if it's
-        # already closed/exhausted (similar to generators)
-        coro.close()
-        coro.close()
-
-    def test_func_18(self):
-        # See http://bugs.python.org/issue25887 for details
-
-        async def coroutine():
-            return 'spam'
-
-        coro = coroutine()
-        await_iter = coro.__await__()
-        it = iter(await_iter)
-
-        with self.assertRaisesRegex(StopIteration, 'spam'):
-            it.send(None)
-
-        with self.assertRaisesRegex(RuntimeError,
-                                    'cannot reuse already awaited coroutine'):
-            it.send(None)
-
-        with self.assertRaisesRegex(RuntimeError,
-                                    'cannot reuse already awaited coroutine'):
-            # Although the iterator protocol requires iterators to
-            # raise another StopIteration here, we don't want to do
-            # that.  In this particular case, the iterator will raise
-            # a RuntimeError, so that 'yield from' and 'await'
-            # expressions will trigger the error, instead of silently
-            # ignoring the call.
-            next(it)
-
-        with self.assertRaisesRegex(RuntimeError,
-                                    'cannot reuse already awaited coroutine'):
-            it.throw(Exception('wat'))
-
-        with self.assertRaisesRegex(RuntimeError,
-                                    'cannot reuse already awaited coroutine'):
-            it.throw(Exception('wat'))
-
-        # Closing a coroutine shouldn't raise any exception even if it's
-        # already closed/exhausted (similar to generators)
-        it.close()
-        it.close()
-
-    def test_func_19(self):
-        CHK = 0
-
-        @types.coroutine
-        def foo():
-            nonlocal CHK
-            yield
-            try:
-                yield
-            except GeneratorExit:
-                CHK += 1
-
-        async def coroutine():
-            await foo()
-
-        coro = coroutine()
-
-        coro.send(None)
-        coro.send(None)
-
-        self.assertEqual(CHK, 0)
-        coro.close()
-        self.assertEqual(CHK, 1)
-
-        for _ in range(3):
-            # Closing a coroutine shouldn't raise any exception even if it's
-            # already closed/exhausted (similar to generators)
-            coro.close()
-            self.assertEqual(CHK, 1)
-
-    def test_coro_wrapper_send_tuple(self):
-        async def foo():
-            return (10,)
-
-        result = run_async__await__(foo())
-        self.assertEqual(result, ([], (10,)))
-
-    def test_coro_wrapper_send_stop_iterator(self):
-        async def foo():
-            return StopIteration(10)
-
-        result = run_async__await__(foo())
-        self.assertIsInstance(result[1], StopIteration)
-        self.assertEqual(result[1].value, 10)
-
-    def test_cr_await(self):
-        @types.coroutine
-        def a():
-            self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_RUNNING)
-            self.assertIsNone(coro_b.cr_await)
-            yield
-            self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_RUNNING)
-            self.assertIsNone(coro_b.cr_await)
-
-        async def c():
-            await a()
-
-        async def b():
-            self.assertIsNone(coro_b.cr_await)
-            await c()
-            self.assertIsNone(coro_b.cr_await)
-
-        coro_b = b()
-        self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_CREATED)
-        self.assertIsNone(coro_b.cr_await)
-
-        coro_b.send(None)
-        self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_SUSPENDED)
-        self.assertEqual(coro_b.cr_await.cr_await.gi_code.co_name, 'a')
-
-        with self.assertRaises(StopIteration):
-            coro_b.send(None)  # complete coroutine
-        self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_CLOSED)
-        self.assertIsNone(coro_b.cr_await)
-
-    def test_corotype_1(self):
-        ct = types.CoroutineType
-        self.assertIn('into coroutine', ct.send.__doc__)
-        self.assertIn('inside coroutine', ct.close.__doc__)
-        self.assertIn('in coroutine', ct.throw.__doc__)
-        self.assertIn('of the coroutine', ct.__dict__['__name__'].__doc__)
-        self.assertIn('of the coroutine', ct.__dict__['__qualname__'].__doc__)
-        self.assertEqual(ct.__name__, 'coroutine')
-
-        async def f(): pass
-        c = f()
-        self.assertIn('coroutine object', repr(c))
-        c.close()
-
-    def test_await_1(self):
-
-        async def foo():
-            await 1
-        with self.assertRaisesRegex(TypeError, "object int can.t.*await"):
-            run_async(foo())
-
-    def test_await_2(self):
-        async def foo():
-            await []
-        with self.assertRaisesRegex(TypeError, "object list can.t.*await"):
-            run_async(foo())
-
-    def test_await_3(self):
-        async def foo():
-            await AsyncYieldFrom([1, 2, 3])
-
-        self.assertEqual(run_async(foo()), ([1, 2, 3], None))
-        self.assertEqual(run_async__await__(foo()), ([1, 2, 3], None))
-
-    def test_await_4(self):
-        async def bar():
-            return 42
-
-        async def foo():
-            return await bar()
-
-        self.assertEqual(run_async(foo()), ([], 42))
-
-    def test_await_5(self):
-        class Awaitable:
-            def __await__(self):
-                return
-
-        async def foo():
-            return (await Awaitable())
-
-        with self.assertRaisesRegex(
-            TypeError, "__await__.*returned non-iterator of type"):
-
-            run_async(foo())
-
-    def test_await_6(self):
-        class Awaitable:
-            def __await__(self):
-                return iter([52])
-
-        async def foo():
-            return (await Awaitable())
-
-        self.assertEqual(run_async(foo()), ([52], None))
-
-    def test_await_7(self):
-        class Awaitable:
-            def __await__(self):
-                yield 42
-                return 100
-
-        async def foo():
-            return (await Awaitable())
-
-        self.assertEqual(run_async(foo()), ([42], 100))
-
-    def test_await_8(self):
-        class Awaitable:
-            pass
-
-        async def foo(): return await Awaitable()
-
-        with self.assertRaisesRegex(
-            TypeError, "object Awaitable can't be used in 'await' expression"):
-
-            run_async(foo())
-
-    def test_await_9(self):
-        def wrap():
-            return bar
-
-        async def bar():
-            return 42
-
-        async def foo():
-            b = bar()
-
-            db = {'b':  lambda: wrap}
-
-            class DB:
-                b = wrap
-
-            return (await bar() + await wrap()() + await db['b']()()() +
-                    await bar() * 1000 + await DB.b()())
-
-        async def foo2():
-            return -await bar()
-
-        self.assertEqual(run_async(foo()), ([], 42168))
-        self.assertEqual(run_async(foo2()), ([], -42))
-
-    def test_await_10(self):
-        async def baz():
-            return 42
-
-        async def bar():
-            return baz()
-
-        async def foo():
-            return await (await bar())
-
-        self.assertEqual(run_async(foo()), ([], 42))
-
-    def test_await_11(self):
-        def ident(val):
-            return val
-
-        async def bar():
-            return 'spam'
-
-        async def foo():
-            return ident(val=await bar())
-
-        async def foo2():
-            return await bar(), 'ham'
-
-        self.assertEqual(run_async(foo2()), ([], ('spam', 'ham')))
-
-    def test_await_12(self):
-        async def coro():
-            return 'spam'
-
-        class Awaitable:
-            def __await__(self):
-                return coro()
-
-        async def foo():
-            return await Awaitable()
-
-        with self.assertRaisesRegex(
-            TypeError, r"__await__\(\) returned a coroutine"):
-
-            run_async(foo())
-
-    def test_await_13(self):
-        class Awaitable:
-            def __await__(self):
-                return self
-
-        async def foo():
-            return await Awaitable()
-
-        with self.assertRaisesRegex(
-            TypeError, "__await__.*returned non-iterator of type"):
-
-            run_async(foo())
-
-    def test_await_14(self):
-        class Wrapper:
-            # Forces the interpreter to use CoroutineType.__await__
-            def __init__(self, coro):
-                assert coro.__class__ is types.CoroutineType
-                self.coro = coro
-            def __await__(self):
-                return self.coro.__await__()
-
-        class FutureLike:
-            def __await__(self):
-                return (yield)
-
-        class Marker(Exception):
-            pass
-
-        async def coro1():
-            try:
-                return await FutureLike()
-            except ZeroDivisionError:
-                raise Marker
-        async def coro2():
-            return await Wrapper(coro1())
-
-        c = coro2()
-        c.send(None)
-        with self.assertRaisesRegex(StopIteration, 'spam'):
-            c.send('spam')
-
-        c = coro2()
-        c.send(None)
-        with self.assertRaises(Marker):
-            c.throw(ZeroDivisionError)
-
-    def test_await_15(self):
-        @types.coroutine
-        def nop():
-            yield
-
-        async def coroutine():
-            await nop()
-
-        async def waiter(coro):
-            await coro
-
-        coro = coroutine()
-        coro.send(None)
-
-        with self.assertRaisesRegex(RuntimeError,
-                                    "coroutine is being awaited already"):
-            waiter(coro).send(None)
-
-    def test_await_16(self):
-        # See https://bugs.python.org/issue29600 for details.
-
-        async def f():
-            return ValueError()
-
-        async def g():
-            try:
-                raise KeyError
-            except:
-                return await f()
-
-        _, result = run_async(g())
-        self.assertIsNone(result.__context__)
-
-    def test_with_1(self):
-        class Manager:
-            def __init__(self, name):
-                self.name = name
-
-            async def __aenter__(self):
-                await AsyncYieldFrom(['enter-1-' + self.name,
-                                      'enter-2-' + self.name])
-                return self
-
-            async def __aexit__(self, *args):
-                await AsyncYieldFrom(['exit-1-' + self.name,
-                                      'exit-2-' + self.name])
-
-                if self.name == 'B':
-                    return True
-
-
-        async def foo():
-            async with Manager("A") as a, Manager("B") as b:
-                await AsyncYieldFrom([('managers', a.name, b.name)])
-                1/0
-
-        f = foo()
-        result, _ = run_async(f)
-
-        self.assertEqual(
-            result, ['enter-1-A', 'enter-2-A', 'enter-1-B', 'enter-2-B',
-                     ('managers', 'A', 'B'),
-                     'exit-1-B', 'exit-2-B', 'exit-1-A', 'exit-2-A']
-        )
-
-        async def foo():
-            async with Manager("A") as a, Manager("C") as c:
-                await AsyncYieldFrom([('managers', a.name, c.name)])
-                1/0
-
-        with self.assertRaises(ZeroDivisionError):
-            run_async(foo())
-
-    def test_with_2(self):
-        class CM:
-            def __aenter__(self):
-                pass
-
-        async def foo():
-            async with CM():
-                pass
-
-        with self.assertRaisesRegex(AttributeError, '__aexit__'):
-            run_async(foo())
-
-    def test_with_3(self):
-        class CM:
-            def __aexit__(self):
-                pass
-
-        async def foo():
-            async with CM():
-                pass
-
-        with self.assertRaisesRegex(AttributeError, '__aenter__'):
-            run_async(foo())
-
-    def test_with_4(self):
-        class CM:
-            def __enter__(self):
-                pass
-
-            def __exit__(self):
-                pass
-
-        async def foo():
-            async with CM():
-                pass
-
-        with self.assertRaisesRegex(AttributeError, '__aexit__'):
-            run_async(foo())
-
-    def test_with_5(self):
-        # While this test doesn't make a lot of sense,
-        # it's a regression test for an early bug with opcodes
-        # generation
-
-        class CM:
-            async def __aenter__(self):
-                return self
-
-            async def __aexit__(self, *exc):
-                pass
-
-        async def func():
-            async with CM():
-                assert (1, ) == 1
-
-        with self.assertRaises(AssertionError):
-            run_async(func())
-
-    def test_with_6(self):
-        class CM:
-            def __aenter__(self):
-                return 123
-
-            def __aexit__(self, *e):
-                return 456
-
-        async def foo():
-            async with CM():
-                pass
-
-        with self.assertRaisesRegex(
-            TypeError, "object int can't be used in 'await' expression"):
-            # it's important that __aexit__ wasn't called
-            run_async(foo())
-
-    def test_with_7(self):
-        class CM:
-            async def __aenter__(self):
-                return self
-
-            def __aexit__(self, *e):
-                return 444
-
-        async def foo():
-            async with CM():
-                1/0
-
-        try:
-            run_async(foo())
-        except TypeError as exc:
-            self.assertRegex(
-                exc.args[0], "object int can't be used in 'await' expression")
-            self.assertTrue(exc.__context__ is not None)
-            self.assertTrue(isinstance(exc.__context__, ZeroDivisionError))
-        else:
-            self.fail('invalid asynchronous context manager did not fail')
-
-
-    def test_with_8(self):
-        CNT = 0
-
-        class CM:
-            async def __aenter__(self):
-                return self
-
-            def __aexit__(self, *e):
-                return 456
-
-        async def foo():
-            nonlocal CNT
-            async with CM():
-                CNT += 1
-
-
-        with self.assertRaisesRegex(
-            TypeError, "object int can't be used in 'await' expression"):
-
-            run_async(foo())
-
-        self.assertEqual(CNT, 1)
-
-
-    def test_with_9(self):
-        CNT = 0
-
-        class CM:
-            async def __aenter__(self):
-                return self
-
-            async def __aexit__(self, *e):
-                1/0
-
-        async def foo():
-            nonlocal CNT
-            async with CM():
-                CNT += 1
-
-        with self.assertRaises(ZeroDivisionError):
-            run_async(foo())
-
-        self.assertEqual(CNT, 1)
-
-    def test_with_10(self):
-        CNT = 0
-
-        class CM:
-            async def __aenter__(self):
-                return self
-
-            async def __aexit__(self, *e):
-                1/0
-
-        async def foo():
-            nonlocal CNT
-            async with CM():
-                async with CM():
-                    raise RuntimeError
-
-        try:
-            run_async(foo())
-        except ZeroDivisionError as exc:
-            self.assertTrue(exc.__context__ is not None)
-            self.assertTrue(isinstance(exc.__context__, ZeroDivisionError))
-            self.assertTrue(isinstance(exc.__context__.__context__,
-                                       RuntimeError))
-        else:
-            self.fail('exception from __aexit__ did not propagate')
-
-    def test_with_11(self):
-        CNT = 0
-
-        class CM:
-            async def __aenter__(self):
-                raise NotImplementedError
-
-            async def __aexit__(self, *e):
-                1/0
-
-        async def foo():
-            nonlocal CNT
-            async with CM():
-                raise RuntimeError
-
-        try:
-            run_async(foo())
-        except NotImplementedError as exc:
-            self.assertTrue(exc.__context__ is None)
-        else:
-            self.fail('exception from __aenter__ did not propagate')
-
-    def test_with_12(self):
-        CNT = 0
-
-        class CM:
-            async def __aenter__(self):
-                return self
-
-            async def __aexit__(self, *e):
-                return True
-
-        async def foo():
-            nonlocal CNT
-            async with CM() as cm:
-                self.assertIs(cm.__class__, CM)
-                raise RuntimeError
-
-        run_async(foo())
-
-    def test_with_13(self):
-        CNT = 0
-
-        class CM:
-            async def __aenter__(self):
-                1/0
-
-            async def __aexit__(self, *e):
-                return True
-
-        async def foo():
-            nonlocal CNT
-            CNT += 1
-            async with CM():
-                CNT += 1000
-            CNT += 10000
-
-        with self.assertRaises(ZeroDivisionError):
-            run_async(foo())
-        self.assertEqual(CNT, 1)
-
-    def test_for_1(self):
-        aiter_calls = 0
-
-        class AsyncIter:
-            def __init__(self):
-                self.i = 0
-
-            async def __aiter__(self):
-                nonlocal aiter_calls
-                aiter_calls += 1
-                return self
-
-            async def __anext__(self):
-                self.i += 1
-
-                if not (self.i % 10):
-                    await AsyncYield(self.i * 10)
-
-                if self.i > 100:
-                    raise StopAsyncIteration
-
-                return self.i, self.i
-
-
-        buffer = []
-        async def test1():
-            with self.assertWarnsRegex(DeprecationWarning, "legacy"):
-                async for i1, i2 in AsyncIter():
-                    buffer.append(i1 + i2)
-
-        yielded, _ = run_async(test1())
-        # Make sure that __aiter__ was called only once
-        self.assertEqual(aiter_calls, 1)
-        self.assertEqual(yielded, [i * 100 for i in range(1, 11)])
-        self.assertEqual(buffer, [i*2 for i in range(1, 101)])
-
-
-        buffer = []
-        async def test2():
-            nonlocal buffer
-            with self.assertWarnsRegex(DeprecationWarning, "legacy"):
-                async for i in AsyncIter():
-                    buffer.append(i[0])
-                    if i[0] == 20:
-                        break
-                else:
-                    buffer.append('what?')
-            buffer.append('end')
-
-        yielded, _ = run_async(test2())
-        # Make sure that __aiter__ was called only once
-        self.assertEqual(aiter_calls, 2)
-        self.assertEqual(yielded, [100, 200])
-        self.assertEqual(buffer, [i for i in range(1, 21)] + ['end'])
-
-
-        buffer = []
-        async def test3():
-            nonlocal buffer
-            with self.assertWarnsRegex(DeprecationWarning, "legacy"):
-                async for i in AsyncIter():
-                    if i[0] > 20:
-                        continue
-                    buffer.append(i[0])
-                else:
-                    buffer.append('what?')
-            buffer.append('end')
-
-        yielded, _ = run_async(test3())
-        # Make sure that __aiter__ was called only once
-        self.assertEqual(aiter_calls, 3)
-        self.assertEqual(yielded, [i * 100 for i in range(1, 11)])
-        self.assertEqual(buffer, [i for i in range(1, 21)] +
-                                 ['what?', 'end'])
-
-    def test_for_2(self):
-        tup = (1, 2, 3)
-        refs_before = sys.getrefcount(tup)
-
-        async def foo():
-            async for i in tup:
-                print('never going to happen')
-
-        with self.assertRaisesRegex(
-                TypeError, "async for' requires an object.*__aiter__.*tuple"):
-
-            run_async(foo())
-
-        self.assertEqual(sys.getrefcount(tup), refs_before)
-
-    def test_for_3(self):
-        class I:
-            def __aiter__(self):
-                return self
-
-        aiter = I()
-        refs_before = sys.getrefcount(aiter)
-
-        async def foo():
-            async for i in aiter:
-                print('never going to happen')
-
-        with self.assertRaisesRegex(
-                TypeError,
-                r"async for' received an invalid object.*__aiter.*\: I"):
-
-            run_async(foo())
-
-        self.assertEqual(sys.getrefcount(aiter), refs_before)
-
-    def test_for_4(self):
-        class I:
-            def __aiter__(self):
-                return self
-
-            def __anext__(self):
-                return ()
-
-        aiter = I()
-        refs_before = sys.getrefcount(aiter)
-
-        async def foo():
-            async for i in aiter:
-                print('never going to happen')
-
-        with self.assertRaisesRegex(
-                TypeError,
-                "async for' received an invalid object.*__anext__.*tuple"):
-
-            run_async(foo())
-
-        self.assertEqual(sys.getrefcount(aiter), refs_before)
-
-    def test_for_5(self):
-        class I:
-            async def __aiter__(self):
-                return self
-
-            def __anext__(self):
-                return 123
-
-        async def foo():
-            with self.assertWarnsRegex(DeprecationWarning, "legacy"):
-                async for i in I():
-                    print('never going to happen')
-
-        with self.assertRaisesRegex(
-                TypeError,
-                "async for' received an invalid object.*__anext.*int"):
-
-            run_async(foo())
-
-    def test_for_6(self):
-        I = 0
-
-        class Manager:
-            async def __aenter__(self):
-                nonlocal I
-                I += 10000
-
-            async def __aexit__(self, *args):
-                nonlocal I
-                I += 100000
-
-        class Iterable:
-            def __init__(self):
-                self.i = 0
-
-            def __aiter__(self):
-                return self
-
-            async def __anext__(self):
-                if self.i > 10:
-                    raise StopAsyncIteration
-                self.i += 1
-                return self.i
-
-        ##############
-
-        manager = Manager()
-        iterable = Iterable()
-        mrefs_before = sys.getrefcount(manager)
-        irefs_before = sys.getrefcount(iterable)
-
-        async def main():
-            nonlocal I
-
-            async with manager:
-                async for i in iterable:
-                    I += 1
-            I += 1000
-
-        with warnings.catch_warnings():
-            warnings.simplefilter("error")
-            # Test that __aiter__ that returns an asynchronous iterator
-            # directly does not throw any warnings.
-            run_async(main())
-        self.assertEqual(I, 111011)
-
-        self.assertEqual(sys.getrefcount(manager), mrefs_before)
-        self.assertEqual(sys.getrefcount(iterable), irefs_before)
-
-        ##############
-
-        async def main():
-            nonlocal I
-
-            async with Manager():
-                async for i in Iterable():
-                    I += 1
-            I += 1000
-
-            async with Manager():
-                async for i in Iterable():
-                    I += 1
-            I += 1000
-
-        run_async(main())
-        self.assertEqual(I, 333033)
-
-        ##############
-
-        async def main():
-            nonlocal I
-
-            async with Manager():
-                I += 100
-                async for i in Iterable():
-                    I += 1
-                else:
-                    I += 10000000
-            I += 1000
-
-            async with Manager():
-                I += 100
-                async for i in Iterable():
-                    I += 1
-                else:
-                    I += 10000000
-            I += 1000
-
-        run_async(main())
-        self.assertEqual(I, 20555255)
-
-    def test_for_7(self):
-        CNT = 0
-        class AI:
-            async def __aiter__(self):
-                1/0
-        async def foo():
-            nonlocal CNT
-            with self.assertWarnsRegex(DeprecationWarning, "legacy"):
-                async for i in AI():
-                    CNT += 1
-            CNT += 10
-        with self.assertRaises(ZeroDivisionError):
-            run_async(foo())
-        self.assertEqual(CNT, 0)
-
-    def test_for_8(self):
-        CNT = 0
-        class AI:
-            def __aiter__(self):
-                1/0
-        async def foo():
-            nonlocal CNT
-            async for i in AI():
-                CNT += 1
-            CNT += 10
-        with self.assertRaises(ZeroDivisionError):
-            with warnings.catch_warnings():
-                warnings.simplefilter("error")
-                # Test that if __aiter__ raises an exception it propagates
-                # without any kind of warning.
-                run_async(foo())
-        self.assertEqual(CNT, 0)
-
-    def test_for_9(self):
-        # Test that DeprecationWarning can safely be converted into
-        # an exception (__aiter__ should not have a chance to raise
-        # a ZeroDivisionError.)
-        class AI:
-            async def __aiter__(self):
-                1/0
-        async def foo():
-            async for i in AI():
-                pass
-
-        with self.assertRaises(DeprecationWarning):
-            with warnings.catch_warnings():
-                warnings.simplefilter("error")
-                run_async(foo())
-
-    def test_for_10(self):
-        # Test that DeprecationWarning can safely be converted into
-        # an exception.
-        class AI:
-            async def __aiter__(self):
-                pass
-        async def foo():
-            async for i in AI():
-                pass
-
-        with self.assertRaises(DeprecationWarning):
-            with warnings.catch_warnings():
-                warnings.simplefilter("error")
-                run_async(foo())
-
-    def test_for_11(self):
-        class F:
-            def __aiter__(self):
-                return self
-            def __anext__(self):
-                return self
-            def __await__(self):
-                1 / 0
-
-        async def main():
-            async for _ in F():
-                pass
-
-        with self.assertRaisesRegex(TypeError,
-                                    'an invalid object from __anext__') as c:
-            main().send(None)
-
-        err = c.exception
-        self.assertIsInstance(err.__cause__, ZeroDivisionError)
-
-    def test_for_12(self):
-        class F:
-            def __aiter__(self):
-                return self
-            def __await__(self):
-                1 / 0
-
-        async def main():
-            async for _ in F():
-                pass
-
-        with self.assertRaisesRegex(TypeError,
-                                    'an invalid object from __aiter__') as c:
-            main().send(None)
-
-        err = c.exception
-        self.assertIsInstance(err.__cause__, ZeroDivisionError)
-
-    def test_for_tuple(self):
-        class Done(Exception): pass
-
-        class AIter(tuple):
-            i = 0
-            def __aiter__(self):
-                return self
-            async def __anext__(self):
-                if self.i >= len(self):
-                    raise StopAsyncIteration
-                self.i += 1
-                return self[self.i - 1]
-
-        result = []
-        async def foo():
-            async for i in AIter([42]):
-                result.append(i)
-            raise Done
-
-        with self.assertRaises(Done):
-            foo().send(None)
-        self.assertEqual(result, [42])
-
-    def test_for_stop_iteration(self):
-        class Done(Exception): pass
-
-        class AIter(StopIteration):
-            i = 0
-            def __aiter__(self):
-                return self
-            async def __anext__(self):
-                if self.i:
-                    raise StopAsyncIteration
-                self.i += 1
-                return self.value
-
-        result = []
-        async def foo():
-            async for i in AIter(42):
-                result.append(i)
-            raise Done
-
-        with self.assertRaises(Done):
-            foo().send(None)
-        self.assertEqual(result, [42])
-
-    def test_comp_1(self):
-        async def f(i):
-            return i
-
-        async def run_list():
-            return [await c for c in [f(1), f(41)]]
-
-        async def run_set():
-            return {await c for c in [f(1), f(41)]}
-
-        async def run_dict1():
-            return {await c: 'a' for c in [f(1), f(41)]}
-
-        async def run_dict2():
-            return {i: await c for i, c in enumerate([f(1), f(41)])}
-
-        self.assertEqual(run_async(run_list()), ([], [1, 41]))
-        self.assertEqual(run_async(run_set()), ([], {1, 41}))
-        self.assertEqual(run_async(run_dict1()), ([], {1: 'a', 41: 'a'}))
-        self.assertEqual(run_async(run_dict2()), ([], {0: 1, 1: 41}))
-
-    def test_comp_2(self):
-        async def f(i):
-            return i
-
-        async def run_list():
-            return [s for c in [f(''), f('abc'), f(''), f(['de', 'fg'])]
-                    for s in await c]
-
-        self.assertEqual(
-            run_async(run_list()),
-            ([], ['a', 'b', 'c', 'de', 'fg']))
-
-        async def run_set():
-            return {d
-                    for c in [f([f([10, 30]),
-                                 f([20])])]
-                    for s in await c
-                    for d in await s}
-
-        self.assertEqual(
-            run_async(run_set()),
-            ([], {10, 20, 30}))
-
-        async def run_set2():
-            return {await s
-                    for c in [f([f(10), f(20)])]
-                    for s in await c}
-
-        self.assertEqual(
-            run_async(run_set2()),
-            ([], {10, 20}))
-
-    def test_comp_3(self):
-        async def f(it):
-            for i in it:
-                yield i
-
-        async def run_list():
-            return [i + 1 async for i in f([10, 20])]
-        self.assertEqual(
-            run_async(run_list()),
-            ([], [11, 21]))
-
-        async def run_set():
-            return {i + 1 async for i in f([10, 20])}
-        self.assertEqual(
-            run_async(run_set()),
-            ([], {11, 21}))
-
-        async def run_dict():
-            return {i + 1: i + 2 async for i in f([10, 20])}
-        self.assertEqual(
-            run_async(run_dict()),
-            ([], {11: 12, 21: 22}))
-
-        async def run_gen():
-            gen = (i + 1 async for i in f([10, 20]))
-            return [g + 100 async for g in gen]
-        self.assertEqual(
-            run_async(run_gen()),
-            ([], [111, 121]))
-
-    def test_comp_4(self):
-        async def f(it):
-            for i in it:
-                yield i
-
-        async def run_list():
-            return [i + 1 async for i in f([10, 20]) if i > 10]
-        self.assertEqual(
-            run_async(run_list()),
-            ([], [21]))
-
-        async def run_set():
-            return {i + 1 async for i in f([10, 20]) if i > 10}
-        self.assertEqual(
-            run_async(run_set()),
-            ([], {21}))
-
-        async def run_dict():
-            return {i + 1: i + 2 async for i in f([10, 20]) if i > 10}
-        self.assertEqual(
-            run_async(run_dict()),
-            ([], {21: 22}))
-
-        async def run_gen():
-            gen = (i + 1 async for i in f([10, 20]) if i > 10)
-            return [g + 100 async for g in gen]
-        self.assertEqual(
-            run_async(run_gen()),
-            ([], [121]))
-
-    def test_comp_5(self):
-        async def f(it):
-            for i in it:
-                yield i
-
-        async def run_list():
-            return [i + 1 for pair in ([10, 20], [30, 40]) if pair[0] > 10
-                    async for i in f(pair) if i > 30]
-        self.assertEqual(
-            run_async(run_list()),
-            ([], [41]))
-
-    def test_comp_6(self):
-        async def f(it):
-            for i in it:
-                yield i
-
-        async def run_list():
-            return [i + 1 async for seq in f([(10, 20), (30,)])
-                    for i in seq]
-
-        self.assertEqual(
-            run_async(run_list()),
-            ([], [11, 21, 31]))
-
-    def test_comp_7(self):
-        async def f():
-            yield 1
-            yield 2
-            raise Exception('aaa')
-
-        async def run_list():
-            return [i async for i in f()]
-
-        with self.assertRaisesRegex(Exception, 'aaa'):
-            run_async(run_list())
-
-    def test_comp_8(self):
-        async def f():
-            return [i for i in [1, 2, 3]]
-
-        self.assertEqual(
-            run_async(f()),
-            ([], [1, 2, 3]))
-
-    def test_comp_9(self):
-        async def gen():
-            yield 1
-            yield 2
-        async def f():
-            l = [i async for i in gen()]
-            return [i for i in l]
-
-        self.assertEqual(
-            run_async(f()),
-            ([], [1, 2]))
-
-    def test_comp_10(self):
-        async def f():
-            xx = {i for i in [1, 2, 3]}
-            return {x: x for x in xx}
-
-        self.assertEqual(
-            run_async(f()),
-            ([], {1: 1, 2: 2, 3: 3}))
-
-    def test_copy(self):
-        async def func(): pass
-        coro = func()
-        with self.assertRaises(TypeError):
-            copy.copy(coro)
-
-        aw = coro.__await__()
-        try:
-            with self.assertRaises(TypeError):
-                copy.copy(aw)
-        finally:
-            aw.close()
-
-    def test_pickle(self):
-        async def func(): pass
-        coro = func()
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            with self.assertRaises((TypeError, pickle.PicklingError)):
-                pickle.dumps(coro, proto)
-
-        aw = coro.__await__()
-        try:
-            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-                with self.assertRaises((TypeError, pickle.PicklingError)):
-                    pickle.dumps(aw, proto)
-        finally:
-            aw.close()
-
-    def test_fatal_coro_warning(self):
-        # Issue 27811
-        async def func(): pass
-        with warnings.catch_warnings(), support.captured_stderr() as stderr:
-            warnings.filterwarnings("error")
-            func()
-            support.gc_collect()
-        self.assertIn("was never awaited", stderr.getvalue())
-
-
-class CoroAsyncIOCompatTest(unittest.TestCase):
-
-    def test_asyncio_1(self):
-        # asyncio cannot be imported when Python is compiled without thread
-        # support
-        asyncio = support.import_module('asyncio')
-
-        class MyException(Exception):
-            pass
-
-        buffer = []
-
-        class CM:
-            async def __aenter__(self):
-                buffer.append(1)
-                await asyncio.sleep(0.01)
-                buffer.append(2)
-                return self
-
-            async def __aexit__(self, exc_type, exc_val, exc_tb):
-                await asyncio.sleep(0.01)
-                buffer.append(exc_type.__name__)
-
-        async def f():
-            async with CM() as c:
-                await asyncio.sleep(0.01)
-                raise MyException
-            buffer.append('unreachable')
-
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        try:
-            loop.run_until_complete(f())
-        except MyException:
-            pass
-        finally:
-            loop.close()
-            asyncio.set_event_loop(None)
-
-        self.assertEqual(buffer, [1, 2, 'MyException'])
-
-
-class SysSetCoroWrapperTest(unittest.TestCase):
-
-    def test_set_wrapper_1(self):
-        async def foo():
-            return 'spam'
-
-        wrapped = None
-        def wrap(gen):
-            nonlocal wrapped
-            wrapped = gen
-            return gen
-
-        self.assertIsNone(sys.get_coroutine_wrapper())
-
-        sys.set_coroutine_wrapper(wrap)
-        self.assertIs(sys.get_coroutine_wrapper(), wrap)
-        try:
-            f = foo()
-            self.assertTrue(wrapped)
-
-            self.assertEqual(run_async(f), ([], 'spam'))
-        finally:
-            sys.set_coroutine_wrapper(None)
-
-        self.assertIsNone(sys.get_coroutine_wrapper())
-
-        wrapped = None
-        with silence_coro_gc():
-            foo()
-        self.assertFalse(wrapped)
-
-    def test_set_wrapper_2(self):
-        self.assertIsNone(sys.get_coroutine_wrapper())
-        with self.assertRaisesRegex(TypeError, "callable expected, got int"):
-            sys.set_coroutine_wrapper(1)
-        self.assertIsNone(sys.get_coroutine_wrapper())
-
-    def test_set_wrapper_3(self):
-        async def foo():
-            return 'spam'
-
-        def wrapper(coro):
-            async def wrap(coro):
-                return await coro
-            return wrap(coro)
-
-        sys.set_coroutine_wrapper(wrapper)
-        try:
-            with silence_coro_gc(), self.assertRaisesRegex(
-                RuntimeError,
-                r"coroutine wrapper.*\.wrapper at 0x.*attempted to "
-                r"recursively wrap .* wrap .*"):
-
-                foo()
-        finally:
-            sys.set_coroutine_wrapper(None)
-
-    def test_set_wrapper_4(self):
-        @types.coroutine
-        def foo():
-            return 'spam'
-
-        wrapped = None
-        def wrap(gen):
-            nonlocal wrapped
-            wrapped = gen
-            return gen
-
-        sys.set_coroutine_wrapper(wrap)
-        try:
-            foo()
-            self.assertIs(
-                wrapped, None,
-                "generator-based coroutine was wrapped via "
-                "sys.set_coroutine_wrapper")
-        finally:
-            sys.set_coroutine_wrapper(None)
-
-
-@support.cpython_only
-class CAPITest(unittest.TestCase):
-
-    def test_tp_await_1(self):
-        from _testcapi import awaitType as at
-
-        async def foo():
-            future = at(iter([1]))
-            return (await future)
-
-        self.assertEqual(foo().send(None), 1)
-
-    def test_tp_await_2(self):
-        # Test tp_await to __await__ mapping
-        from _testcapi import awaitType as at
-        future = at(iter([1]))
-        self.assertEqual(next(future.__await__()), 1)
-
-    def test_tp_await_3(self):
-        from _testcapi import awaitType as at
-
-        async def foo():
-            future = at(1)
-            return (await future)
-
-        with self.assertRaisesRegex(
-                TypeError, "__await__.*returned non-iterator of type 'int'"):
-            self.assertEqual(foo().send(None), 1)
-
-
-if __name__=="__main__":
-    unittest.main()