From ac13ee5f64cd3bceb1628dbcbbfc77445358038f Mon Sep 17 00:00:00 2001
From: Ben Darnell <ben@bendarnell.com>
Date: Sun, 4 Jun 2017 23:55:59 -0400
Subject: [PATCH] concurrent: Use asyncio.Future when available

This improves compatibility with asyncio, but required small tweaks to
various tests due to changes in callback timing (asyncio future
callbacks are always scheduled for the next IOLoop iteration)

concurrent: Always schedule Future callbacks on the IOLoop

Make the python 2/tornado-specific Future implementation more
consistent with asyncio's.
---
 docs/concurrent.rst                  |  3 --
 docs/guide/security.rst              |  1 +
 tornado/concurrent.py                | 47 +++++++++++++++++++---------
 tornado/gen.py                       | 27 +++++-----------
 tornado/iostream.py                  |  1 +
 tornado/locks.py                     | 13 ++++++--
 tornado/platform/asyncio.py          | 28 ++++++++++-------
 tornado/queues.py                    |  3 +-
 tornado/test/asyncio_test.py         |  7 +++--
 tornado/test/concurrent_test.py      |  7 +++++
 tornado/test/curl_httpclient_test.py | 12 ++++---
 tornado/test/gen_test.py             |  2 ++
 tornado/test/httpserver_test.py      |  2 ++
 tornado/test/locks_test.py           | 19 +++++++++++
 tornado/test/runtests.py             |  7 +++++
 tornado/test/tcpclient_test.py       |  3 ++
 tornado/test/tcpserver_test.py       |  3 +-
 tornado/test/twisted_test.py         | 12 +++++++
 tornado/testing.py                   | 11 +++++++
 19 files changed, 148 insertions(+), 60 deletions(-)

diff --git a/docs/concurrent.rst b/docs/concurrent.rst
index 049eb6ff7..80d6f02e9 100644
--- a/docs/concurrent.rst
+++ b/docs/concurrent.rst
@@ -17,10 +17,8 @@
 
     .. automethod:: Future.result
     .. automethod:: Future.exception
-    .. automethod:: Future.exc_info
     .. automethod:: Future.add_done_callback
     .. automethod:: Future.done
-    .. automethod:: Future.running
     .. automethod:: Future.cancel
     .. automethod:: Future.cancelled
 
@@ -29,4 +27,3 @@
 
     .. automethod:: Future.set_result
     .. automethod:: Future.set_exception
-    .. automethod:: Future.set_exc_info
diff --git a/docs/guide/security.rst b/docs/guide/security.rst
index 05617fc99..02c16f0ba 100644
--- a/docs/guide/security.rst
+++ b/docs/guide/security.rst
@@ -3,6 +3,7 @@ Authentication and security
 
 .. testsetup::
 
+   import tornado.auth
    import tornado.web
 
 Cookies and secure cookies
diff --git a/tornado/concurrent.py b/tornado/concurrent.py
index 9fb06db02..379e3eec6 100644
--- a/tornado/concurrent.py
+++ b/tornado/concurrent.py
@@ -38,6 +38,11 @@ try:
 except ImportError:
     futures = None
 
+try:
+    import asyncio
+except ImportError:
+    asyncio = None
+
 try:
     import typing
 except ImportError:
@@ -138,14 +143,17 @@ class Future(object):
     Tornado they are normally used with `.IOLoop.add_future` or by
     yielding them in a `.gen.coroutine`.
 
-    `tornado.concurrent.Future` is similar to
-    `concurrent.futures.Future`, but not thread-safe (and therefore
-    faster for use with single-threaded event loops).
+    `tornado.concurrent.Future` is an alias for `asyncio.Future` when
+    that package is available (Python 3.4+). Unlike
+    `concurrent.futures.Future`, the ``Futures`` used by Tornado and
+    `asyncio` are not thread-safe (and therefore faster for use with
+    single-threaded event loops).
 
-    In addition to ``exception`` and ``set_exception``, methods ``exc_info``
-    and ``set_exc_info`` are supported to capture tracebacks in Python 2.
-    The traceback is automatically available in Python 3, but in the
-    Python 2 futures backport this information is discarded.
+    In addition to ``exception`` and ``set_exception``, Tornado's
+    ``Future`` implementation supports storing an ``exc_info`` triple
+    to support better tracebacks on Python 2. To set an ``exc_info``
+    triple, use `future_set_exc_info`, and to retrieve one, call
+    `result()` (which will raise it).
 
     .. versionchanged:: 4.0
        `tornado.concurrent.Future` is always a thread-unsafe ``Future``
@@ -164,8 +172,15 @@ class Future(object):
        ``f.add_done_callback(lambda f: f.exception())``.
 
     .. versionchanged:: 5.0
-       This class was previoiusly available under the name ``TracebackFuture``.
-       This name, which was deprecated since version 4.0, has been removed.
+
+       This class was previoiusly available under the name
+       ``TracebackFuture``. This name, which was deprecated since
+       version 4.0, has been removed. When `asyncio` is available
+       ``tornado.concurrent.Future`` is now an alias for
+       `asyncio.Future`. Like `asyncio.Future`, callbacks are now
+       always scheduled on the `.IOLoop` and are never run
+       synchronously.
+
     """
     def __init__(self):
         self._done = False
@@ -267,7 +282,8 @@ class Future(object):
         `add_done_callback` directly.
         """
         if self._done:
-            fn(self)
+            from tornado.ioloop import IOLoop
+            IOLoop.current().add_callback(fn, self)
         else:
             self._callbacks.append(fn)
 
@@ -322,12 +338,10 @@ class Future(object):
 
     def _set_done(self):
         self._done = True
+        from tornado.ioloop import IOLoop
+        loop = IOLoop.current()
         for cb in self._callbacks:
-            try:
-                cb(self)
-            except Exception:
-                app_log.exception('Exception in callback %r for %r',
-                                  cb, self)
+            loop.add_callback(cb, self)
         self._callbacks = None
 
     # On Python 3.3 or older, objects with a destructor part of a reference
@@ -346,6 +360,9 @@ class Future(object):
                           self, ''.join(tb).rstrip())
 
 
+if asyncio is not None:
+    Future = asyncio.Future  # noqa
+
 if futures is None:
     FUTURES = Future  # type: typing.Union[type, typing.Tuple[type, ...]]
 else:
diff --git a/tornado/gen.py b/tornado/gen.py
index 86a53be6b..533ccb749 100644
--- a/tornado/gen.py
+++ b/tornado/gen.py
@@ -908,7 +908,8 @@ def with_timeout(timeout, future, quiet_exceptions=()):
                               future, exc_info=True)
 
     def timeout_callback():
-        result.set_exception(TimeoutError("Timeout"))
+        if not result.done():
+            result.set_exception(TimeoutError("Timeout"))
         # In case the wrapped future goes on to fail, log it.
         future_add_done_callback(future, error_callback)
     timeout_handle = io_loop.add_timeout(
@@ -962,7 +963,8 @@ Usage: ``yield gen.moment``
 .. versionadded:: 4.0
 
 .. deprecated:: 4.5
-   ``yield None`` is now equivalent to ``yield gen.moment``.
+   ``yield None`` (or ``yield`` with no argument) is now equivalent to
+    ``yield gen.moment``.
 """
 moment.set_result(None)
 
@@ -1139,7 +1141,10 @@ class Runner(object):
                 self.future = Future()
                 future_set_exc_info(self.future, sys.exc_info())
 
-        if not self.future.done() or self.future is moment:
+        if self.future is moment:
+            self.io_loop.add_callback(self.run)
+            return False
+        elif not self.future.done():
             def inner(f):
                 # Break a reference cycle to speed GC.
                 f = None # noqa
@@ -1279,19 +1284,3 @@ def convert_yielded(yielded):
 
 if singledispatch is not None:
     convert_yielded = singledispatch(convert_yielded)
-
-    try:
-        # If we can import t.p.asyncio, do it for its side effect
-        # (registering asyncio.Future with convert_yielded).
-        # It's ugly to do this here, but it prevents a cryptic
-        # infinite recursion in _wrap_awaitable.
-        # Note that even with this, asyncio integration is unlikely
-        # to work unless the application also configures AsyncIOLoop,
-        # but at least the error messages in that case are more
-        # comprehensible than a stack overflow.
-        import tornado.platform.asyncio
-    except ImportError:
-        pass
-    else:
-        # Reference the imported module to make pyflakes happy.
-        tornado
diff --git a/tornado/iostream.py b/tornado/iostream.py
index cede1f585..fa0a27736 100644
--- a/tornado/iostream.py
+++ b/tornado/iostream.py
@@ -463,6 +463,7 @@ class BaseIOStream(object):
                 self._ssl_connect_future = None
             for future in futures:
                 future.set_exception(StreamClosedError(real_error=self.error))
+                future.exception()
             if self._close_callback is not None:
                 cb = self._close_callback
                 self._close_callback = None
diff --git a/tornado/locks.py b/tornado/locks.py
index c883aa234..822c74421 100644
--- a/tornado/locks.py
+++ b/tornado/locks.py
@@ -101,6 +101,11 @@ class Condition(_TimeoutGarbageCollector):
 
     The method raises `tornado.util.TimeoutError` if there's no notification
     before the deadline.
+
+    .. versionchanged:: 5.0
+       Previously, waiters could be notified synchronously from within
+       `notify`. Now, the notification will always be received on the
+       next iteration of the `.IOLoop`.
     """
 
     def __init__(self):
@@ -123,7 +128,8 @@ class Condition(_TimeoutGarbageCollector):
         self._waiters.append(waiter)
         if timeout:
             def on_timeout():
-                waiter.set_result(False)
+                if not waiter.done():
+                    waiter.set_result(False)
                 self._garbage_collect()
             io_loop = ioloop.IOLoop.current()
             timeout_handle = io_loop.add_timeout(timeout, on_timeout)
@@ -272,6 +278,8 @@ class Semaphore(_TimeoutGarbageCollector):
        @gen.coroutine
        def simulator(futures):
            for f in futures:
+               # simulate the asynchronous passage of time
+               yield gen.moment
                yield gen.moment
                f.set_result(None)
 
@@ -388,7 +396,8 @@ class Semaphore(_TimeoutGarbageCollector):
             self._waiters.append(waiter)
             if timeout:
                 def on_timeout():
-                    waiter.set_exception(gen.TimeoutError())
+                    if not waiter.done():
+                        waiter.set_exception(gen.TimeoutError())
                     self._garbage_collect()
                 io_loop = ioloop.IOLoop.current()
                 timeout_handle = io_loop.add_timeout(timeout, on_timeout)
diff --git a/tornado/platform/asyncio.py b/tornado/platform/asyncio.py
index c0e390891..5066fe4ba 100644
--- a/tornado/platform/asyncio.py
+++ b/tornado/platform/asyncio.py
@@ -104,15 +104,22 @@ class BaseAsyncIOLoop(IOLoop):
 
     def start(self):
         old_current = IOLoop.current(instance=False)
+        try:
+            old_asyncio = asyncio.get_event_loop()
+        except RuntimeError:
+            old_asyncio = None
         try:
             self._setup_logging()
             self.make_current()
+            # This is automatic in 3.5, but must be done manually in 3.4.
+            asyncio.set_event_loop(self.asyncio_loop)
             self.asyncio_loop.run_forever()
         finally:
             if old_current is None:
                 IOLoop.clear_current()
             else:
                 old_current.make_current()
+            asyncio.set_event_loop(old_asyncio)
 
     def stop(self):
         self.asyncio_loop.stop()
@@ -186,10 +193,12 @@ def to_tornado_future(asyncio_future):
     """Convert an `asyncio.Future` to a `tornado.concurrent.Future`.
 
     .. versionadded:: 4.1
+
+    .. deprecated:: 5.0
+       Tornado ``Futures`` have been merged with `asyncio.Future`,
+       so this method is now a no-op.
     """
-    tf = tornado.concurrent.Future()
-    tornado.concurrent.chain_future(asyncio_future, tf)
-    return tf
+    return asyncio_future
 
 
 def to_asyncio_future(tornado_future):
@@ -200,12 +209,9 @@ def to_asyncio_future(tornado_future):
     .. versionchanged:: 4.3
        Now accepts any yieldable object, not just
        `tornado.concurrent.Future`.
-    """
-    tornado_future = convert_yielded(tornado_future)
-    af = asyncio.Future()
-    tornado.concurrent.chain_future(tornado_future, af)
-    return af
 
-
-if hasattr(convert_yielded, 'register'):
-    convert_yielded.register(asyncio.Future, to_tornado_future)  # type: ignore
+    .. deprecated:: 5.0
+       Tornado ``Futures`` have been merged with `asyncio.Future`,
+       so this method is now equivalent to `tornado.gen.convert_yielded`.
+    """
+    return convert_yielded(tornado_future)
diff --git a/tornado/queues.py b/tornado/queues.py
index e6a99b15c..318c40933 100644
--- a/tornado/queues.py
+++ b/tornado/queues.py
@@ -47,7 +47,8 @@ class QueueFull(Exception):
 def _set_timeout(future, timeout):
     if timeout:
         def on_timeout():
-            future.set_exception(gen.TimeoutError())
+            if not future.done():
+                future.set_exception(gen.TimeoutError())
         io_loop = ioloop.IOLoop.current()
         timeout_handle = io_loop.add_timeout(timeout, on_timeout)
         future.add_done_callback(
diff --git a/tornado/test/asyncio_test.py b/tornado/test/asyncio_test.py
index d0e3f2b02..1bfbe76ca 100644
--- a/tornado/test/asyncio_test.py
+++ b/tornado/test/asyncio_test.py
@@ -105,10 +105,11 @@ class AsyncIOLoopTest(AsyncTestCase):
             42)
 
         # Asyncio only supports coroutines that yield asyncio-compatible
-        # Futures.
-        with self.assertRaises(RuntimeError):
+        # Futures (which our Future is since 5.0).
+        self.assertEqual(
             asyncio.get_event_loop().run_until_complete(
-                native_coroutine_without_adapter())
+                native_coroutine_without_adapter()),
+            42)
         self.assertEqual(
             asyncio.get_event_loop().run_until_complete(
                 native_coroutine_with_adapter()),
diff --git a/tornado/test/concurrent_test.py b/tornado/test/concurrent_test.py
index fd8bcc086..2b8dc3655 100644
--- a/tornado/test/concurrent_test.py
+++ b/tornado/test/concurrent_test.py
@@ -176,6 +176,13 @@ class ReturnFutureTest(AsyncTestCase):
 
     @gen_test
     def test_uncaught_exception_log(self):
+        if IOLoop.configured_class().__name__.endswith('AsyncIOLoop'):
+            # Install an exception handler that mirrors our
+            # non-asyncio logging behavior.
+            def exc_handler(loop, context):
+                app_log.error('%s: %s', context['message'],
+                              type(context.get('exception')))
+            self.io_loop.asyncio_loop.set_exception_handler(exc_handler)
         @gen.coroutine
         def f():
             yield gen.moment
diff --git a/tornado/test/curl_httpclient_test.py b/tornado/test/curl_httpclient_test.py
index 35d75011c..cc29ee10b 100644
--- a/tornado/test/curl_httpclient_test.py
+++ b/tornado/test/curl_httpclient_test.py
@@ -5,8 +5,9 @@ from hashlib import md5
 
 from tornado.escape import utf8
 from tornado.httpclient import HTTPRequest
+from tornado.locks import Event
 from tornado.stack_context import ExceptionStackContext
-from tornado.testing import AsyncHTTPTestCase
+from tornado.testing import AsyncHTTPTestCase, gen_test
 from tornado.test import httpclient_test
 from tornado.test.util import unittest
 from tornado.web import Application, RequestHandler
@@ -97,19 +98,20 @@ class CurlHTTPClientTestCase(AsyncHTTPTestCase):
                                    defaults=dict(allow_ipv6=False),
                                    **kwargs)
 
+    @gen_test
     def test_prepare_curl_callback_stack_context(self):
         exc_info = []
+        error_event = Event()
 
         def error_handler(typ, value, tb):
             exc_info.append((typ, value, tb))
-            self.stop()
+            error_event.set()
             return True
 
         with ExceptionStackContext(error_handler):
-            request = HTTPRequest(self.get_url('/'),
+            request = HTTPRequest(self.get_url('/custom_reason'),
                                   prepare_curl_callback=lambda curl: 1 / 0)
-        self.http_client.fetch(request, callback=self.stop)
-        self.wait()
+        yield [error_event.wait(), self.http_client.fetch(request)]
         self.assertEqual(1, len(exc_info))
         self.assertIs(exc_info[0][0], ZeroDivisionError)
 
diff --git a/tornado/test/gen_test.py b/tornado/test/gen_test.py
index 1805bce56..87302eeb9 100644
--- a/tornado/test/gen_test.py
+++ b/tornado/test/gen_test.py
@@ -1016,6 +1016,8 @@ class GenCoroutineTest(AsyncTestCase):
         self.finished = True
 
     @skipNotCPython
+    @unittest.skipIf((3,) < sys.version_info < (3,6),
+                     "asyncio.Future has reference cycles")
     def test_coroutine_refcounting(self):
         # On CPython, tasks and their arguments should be released immediately
         # without waiting for garbage collection.
diff --git a/tornado/test/httpserver_test.py b/tornado/test/httpserver_test.py
index 2564e83b9..2f9e9094a 100644
--- a/tornado/test/httpserver_test.py
+++ b/tornado/test/httpserver_test.py
@@ -41,6 +41,7 @@ def read_stream_body(stream, callback):
             chunks.append(chunk)
 
         def finish(self):
+            conn.detach()
             callback((self.start_line, self.headers, b''.join(chunks)))
     conn = HTTP1Connection(stream, True)
     conn.read_response(Delegate())
@@ -614,6 +615,7 @@ class UnixSocketTest(AsyncTestCase):
 
     def tearDown(self):
         self.stream.close()
+        self.io_loop.run_sync(self.server.close_all_connections)
         self.server.stop()
         shutil.rmtree(self.tmpdir)
         super(UnixSocketTest, self).tearDown()
diff --git a/tornado/test/locks_test.py b/tornado/test/locks_test.py
index 844d4fb0f..409126056 100644
--- a/tornado/test/locks_test.py
+++ b/tornado/test/locks_test.py
@@ -35,6 +35,16 @@ class ConditionTest(AsyncTestCase):
                 self.history.append(key)
         future.add_done_callback(callback)
 
+    def loop_briefly(self):
+        """Run all queued callbacks on the IOLoop.
+
+        In these tests, this method is used after calling notify() to
+        preserve the pre-5.0 behavior in which callbacks ran
+        synchronously.
+        """
+        self.io_loop.add_callback(self.stop)
+        self.wait()
+
     def test_repr(self):
         c = locks.Condition()
         self.assertIn('Condition', repr(c))
@@ -53,8 +63,10 @@ class ConditionTest(AsyncTestCase):
         self.record_done(c.wait(), 'wait1')
         self.record_done(c.wait(), 'wait2')
         c.notify(1)
+        self.loop_briefly()
         self.history.append('notify1')
         c.notify(1)
+        self.loop_briefly()
         self.history.append('notify2')
         self.assertEqual(['wait1', 'notify1', 'wait2', 'notify2'],
                          self.history)
@@ -65,12 +77,15 @@ class ConditionTest(AsyncTestCase):
             self.record_done(c.wait(), i)
 
         c.notify(3)
+        self.loop_briefly()
 
         # Callbacks execute in the order they were registered.
         self.assertEqual(list(range(3)), self.history)
         c.notify(1)
+        self.loop_briefly()
         self.assertEqual(list(range(4)), self.history)
         c.notify(2)
+        self.loop_briefly()
         self.assertEqual(list(range(6)), self.history)
 
     def test_notify_all(self):
@@ -79,6 +94,7 @@ class ConditionTest(AsyncTestCase):
             self.record_done(c.wait(), i)
 
         c.notify_all()
+        self.loop_briefly()
         self.history.append('notify_all')
 
         # Callbacks execute in the order they were registered.
@@ -125,6 +141,7 @@ class ConditionTest(AsyncTestCase):
         self.assertEqual(['timeout', 0, 2], self.history)
         self.assertEqual(['timeout', 0, 2], self.history)
         c.notify()
+        yield
         self.assertEqual(['timeout', 0, 2, 3], self.history)
 
     @gen_test
@@ -139,6 +156,7 @@ class ConditionTest(AsyncTestCase):
         self.assertEqual(['timeout'], self.history)
 
         c.notify_all()
+        yield
         self.assertEqual(['timeout', 0, 2], self.history)
 
     @gen_test
@@ -154,6 +172,7 @@ class ConditionTest(AsyncTestCase):
         # resolving third future.
         futures[1].add_done_callback(lambda _: c.notify())
         c.notify(2)
+        yield
         self.assertTrue(all(f.done() for f in futures))
 
     @gen_test
diff --git a/tornado/test/runtests.py b/tornado/test/runtests.py
index 2548058da..d9842ed75 100644
--- a/tornado/test/runtests.py
+++ b/tornado/test/runtests.py
@@ -121,6 +121,13 @@ def main():
     # Twisted 15.0.0 triggers some warnings on py3 with -bb.
     warnings.filterwarnings("ignore", category=BytesWarning,
                             module=r"twisted\..*")
+    if (3,) < sys.version_info < (3, 6):
+        # Prior to 3.6, async ResourceWarnings were rather noisy
+        # and even
+        # `python3.4 -W error -c 'import asyncio; asyncio.get_event_loop()'`
+        # would generate a warning.
+        warnings.filterwarnings("ignore", category=ResourceWarning,
+                                module=r"asyncio\..*")
 
     logging.getLogger("tornado.access").setLevel(logging.CRITICAL)
 
diff --git a/tornado/test/tcpclient_test.py b/tornado/test/tcpclient_test.py
index 3c3abd1f1..27fc073f8 100644
--- a/tornado/test/tcpclient_test.py
+++ b/tornado/test/tcpclient_test.py
@@ -230,6 +230,9 @@ class ConnectorTest(AsyncTestCase):
         else:
             self.streams.pop(addr)
             future.set_exception(IOError())
+        # Run the loop to allow callbacks to be run.
+        self.io_loop.add_callback(self.stop)
+        self.wait()
 
     def assert_connector_streams_closed(self, conn):
         for stream in conn.streams:
diff --git a/tornado/test/tcpserver_test.py b/tornado/test/tcpserver_test.py
index 2417992cd..0fe7a81ac 100644
--- a/tornado/test/tcpserver_test.py
+++ b/tornado/test/tcpserver_test.py
@@ -19,7 +19,7 @@ class TCPServerTest(AsyncTestCase):
         class TestServer(TCPServer):
             @gen.coroutine
             def handle_stream(self, stream, address):
-                yield gen.moment
+                yield stream.read_bytes(len(b'hello'))
                 stream.close()
                 1 / 0
 
@@ -32,6 +32,7 @@ class TCPServerTest(AsyncTestCase):
             client = IOStream(socket.socket())
             with ExpectLog(app_log, "Exception in callback"):
                 yield client.connect(('localhost', port))
+                yield client.write(b'hello')
                 yield client.read_until_close()
                 yield gen.moment
         finally:
diff --git a/tornado/test/twisted_test.py b/tornado/test/twisted_test.py
index 1d75904a4..5c9884dfd 100644
--- a/tornado/test/twisted_test.py
+++ b/tornado/test/twisted_test.py
@@ -68,6 +68,10 @@ if PY3:
 else:
     import thread
 
+try:
+    import asyncio
+except ImportError:
+    asyncio = None
 
 skipIfNoTwisted = unittest.skipUnless(have_twisted,
                                       "twisted module not present")
@@ -501,6 +505,14 @@ class CompatibilityTests(unittest.TestCase):
 
 @skipIfNoTwisted
 class ConvertDeferredTest(unittest.TestCase):
+    def setUp(self):
+        if asyncio is not None:
+            asyncio.set_event_loop(asyncio.new_event_loop())
+
+    def tearDown(self):
+        if asyncio is not None:
+            asyncio.set_event_loop(None)
+
     def test_success(self):
         @inlineCallbacks
         def fn():
diff --git a/tornado/testing.py b/tornado/testing.py
index 86d4b5744..8463b14ec 100644
--- a/tornado/testing.py
+++ b/tornado/testing.py
@@ -47,6 +47,12 @@ if PY3:
 else:
     from cStringIO import StringIO
 
+try:
+    import asyncio
+except ImportError:
+    asyncio = None
+
+
 try:
     from collections.abc import Generator as GeneratorType  # type: ignore
 except ImportError:
@@ -211,6 +217,9 @@ class AsyncTestCase(unittest.TestCase):
         super(AsyncTestCase, self).setUp()
         self.io_loop = self.get_new_ioloop()
         self.io_loop.make_current()
+        if hasattr(self.io_loop, 'asyncio_loop'):
+            # Ensure that asyncio's current event loop matches ours.
+            asyncio.set_event_loop(self.io_loop.asyncio_loop)
 
     def tearDown(self):
         # Clean up Subprocess, so it can be used again with a new ioloop.
@@ -222,6 +231,8 @@ class AsyncTestCase(unittest.TestCase):
         # set FD_CLOEXEC on its file descriptors)
         self.io_loop.close(all_fds=True)
         super(AsyncTestCase, self).tearDown()
+        if hasattr(self.io_loop, 'asyncio_loop'):
+            asyncio.set_event_loop(None)
         # In case an exception escaped or the StackContext caught an exception
         # when there wasn't a wait() to re-raise it, do so here.
         # This is our last chance to raise an exception in a way that the
-- 
2.47.2