Update asyncio from the Tulip project

Major changes:

- StreamReader.readexactly() now raises an IncompleteReadError if the
  end of stream is reached before we received enough bytes, instead of
  returning less bytes than requested.

- Unit tests use the main asyncio module instead of submodules like events

- _UnixWritePipeTransport now also supports character devices, as
  _UnixReadPipeTransport. Patch written by Jonathan Slenders.

- Export more symbols: BaseEventLoop, BaseProactorEventLoop,
  BaseSelectorEventLoop, Queue and Queue sublasses, Empty, Full

1 files changed, 60 insertions, 58 deletions

diff --git a/Lib/test/test_asyncio/test_streams.py b/Lib/test/test_asyncio/test_streams.py
index 5516c15..2e4f99f 100644
--- a/Lib/test/test_asyncio/test_streams.py
+++ b/Lib/test/test_asyncio/test_streams.py
@@ -8,9 +8,7 @@ try:
 except ImportError:
     ssl = None
 
-from asyncio import events
-from asyncio import streams
-from asyncio import tasks
+import asyncio
 from asyncio import test_utils
 
 
@@ -19,8 +17,8 @@ class StreamReaderTests(unittest.TestCase):
     DATA = b'line1\nline2\nline3\n'
 
     def setUp(self):
-        self.loop = events.new_event_loop()
-        events.set_event_loop(None)
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(None)
 
     def tearDown(self):
         # just in case if we have transport close callbacks
@@ -31,12 +29,12 @@ class StreamReaderTests(unittest.TestCase):
 
     @unittest.mock.patch('asyncio.streams.events')
     def test_ctor_global_loop(self, m_events):
-        stream = streams.StreamReader()
+        stream = asyncio.StreamReader()
         self.assertIs(stream._loop, m_events.get_event_loop.return_value)
 
     def test_open_connection(self):
         with test_utils.run_test_server() as httpd:
-            f = streams.open_connection(*httpd.address, loop=self.loop)
+            f = asyncio.open_connection(*httpd.address, loop=self.loop)
             reader, writer = self.loop.run_until_complete(f)
             writer.write(b'GET / HTTP/1.0\r\n\r\n')
             f = reader.readline()
@@ -52,12 +50,12 @@ class StreamReaderTests(unittest.TestCase):
     def test_open_connection_no_loop_ssl(self):
         with test_utils.run_test_server(use_ssl=True) as httpd:
             try:
-                events.set_event_loop(self.loop)
-                f = streams.open_connection(*httpd.address,
+                asyncio.set_event_loop(self.loop)
+                f = asyncio.open_connection(*httpd.address,
                                             ssl=test_utils.dummy_ssl_context())
                 reader, writer = self.loop.run_until_complete(f)
             finally:
-                events.set_event_loop(None)
+                asyncio.set_event_loop(None)
             writer.write(b'GET / HTTP/1.0\r\n\r\n')
             f = reader.read()
             data = self.loop.run_until_complete(f)
@@ -67,7 +65,7 @@ class StreamReaderTests(unittest.TestCase):
 
     def test_open_connection_error(self):
         with test_utils.run_test_server() as httpd:
-            f = streams.open_connection(*httpd.address, loop=self.loop)
+            f = asyncio.open_connection(*httpd.address, loop=self.loop)
             reader, writer = self.loop.run_until_complete(f)
             writer._protocol.connection_lost(ZeroDivisionError())
             f = reader.read()
@@ -78,20 +76,20 @@ class StreamReaderTests(unittest.TestCase):
             test_utils.run_briefly(self.loop)
 
     def test_feed_empty_data(self):
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
 
         stream.feed_data(b'')
         self.assertEqual(0, stream._byte_count)
 
     def test_feed_data_byte_count(self):
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
 
         stream.feed_data(self.DATA)
         self.assertEqual(len(self.DATA), stream._byte_count)
 
     def test_read_zero(self):
         # Read zero bytes.
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         stream.feed_data(self.DATA)
 
         data = self.loop.run_until_complete(stream.read(0))
@@ -100,8 +98,8 @@ class StreamReaderTests(unittest.TestCase):
 
     def test_read(self):
         # Read bytes.
-        stream = streams.StreamReader(loop=self.loop)
-        read_task = tasks.Task(stream.read(30), loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
+        read_task = asyncio.Task(stream.read(30), loop=self.loop)
 
         def cb():
             stream.feed_data(self.DATA)
@@ -113,7 +111,7 @@ class StreamReaderTests(unittest.TestCase):
 
     def test_read_line_breaks(self):
         # Read bytes without line breaks.
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         stream.feed_data(b'line1')
         stream.feed_data(b'line2')
 
@@ -124,8 +122,8 @@ class StreamReaderTests(unittest.TestCase):
 
     def test_read_eof(self):
         # Read bytes, stop at eof.
-        stream = streams.StreamReader(loop=self.loop)
-        read_task = tasks.Task(stream.read(1024), loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
+        read_task = asyncio.Task(stream.read(1024), loop=self.loop)
 
         def cb():
             stream.feed_eof()
@@ -137,8 +135,8 @@ class StreamReaderTests(unittest.TestCase):
 
     def test_read_until_eof(self):
         # Read all bytes until eof.
-        stream = streams.StreamReader(loop=self.loop)
-        read_task = tasks.Task(stream.read(-1), loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
+        read_task = asyncio.Task(stream.read(-1), loop=self.loop)
 
         def cb():
             stream.feed_data(b'chunk1\n')
@@ -152,7 +150,7 @@ class StreamReaderTests(unittest.TestCase):
         self.assertFalse(stream._byte_count)
 
     def test_read_exception(self):
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         stream.feed_data(b'line\n')
 
         data = self.loop.run_until_complete(stream.read(2))
@@ -164,9 +162,9 @@ class StreamReaderTests(unittest.TestCase):
 
     def test_readline(self):
         # Read one line.
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         stream.feed_data(b'chunk1 ')
-        read_task = tasks.Task(stream.readline(), loop=self.loop)
+        read_task = asyncio.Task(stream.readline(), loop=self.loop)
 
         def cb():
             stream.feed_data(b'chunk2 ')
@@ -179,7 +177,7 @@ class StreamReaderTests(unittest.TestCase):
         self.assertEqual(len(b'\n chunk4')-1, stream._byte_count)
 
     def test_readline_limit_with_existing_data(self):
-        stream = streams.StreamReader(3, loop=self.loop)
+        stream = asyncio.StreamReader(3, loop=self.loop)
         stream.feed_data(b'li')
         stream.feed_data(b'ne1\nline2\n')
 
@@ -187,7 +185,7 @@ class StreamReaderTests(unittest.TestCase):
             ValueError, self.loop.run_until_complete, stream.readline())
         self.assertEqual([b'line2\n'], list(stream._buffer))
 
-        stream = streams.StreamReader(3, loop=self.loop)
+        stream = asyncio.StreamReader(3, loop=self.loop)
         stream.feed_data(b'li')
         stream.feed_data(b'ne1')
         stream.feed_data(b'li')
@@ -198,7 +196,7 @@ class StreamReaderTests(unittest.TestCase):
         self.assertEqual(2, stream._byte_count)
 
     def test_readline_limit(self):
-        stream = streams.StreamReader(7, loop=self.loop)
+        stream = asyncio.StreamReader(7, loop=self.loop)
 
         def cb():
             stream.feed_data(b'chunk1')
@@ -213,7 +211,7 @@ class StreamReaderTests(unittest.TestCase):
         self.assertEqual(7, stream._byte_count)
 
     def test_readline_line_byte_count(self):
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         stream.feed_data(self.DATA[:6])
         stream.feed_data(self.DATA[6:])
 
@@ -223,7 +221,7 @@ class StreamReaderTests(unittest.TestCase):
         self.assertEqual(len(self.DATA) - len(b'line1\n'), stream._byte_count)
 
     def test_readline_eof(self):
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         stream.feed_data(b'some data')
         stream.feed_eof()
 
@@ -231,14 +229,14 @@ class StreamReaderTests(unittest.TestCase):
         self.assertEqual(b'some data', line)
 
     def test_readline_empty_eof(self):
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         stream.feed_eof()
 
         line = self.loop.run_until_complete(stream.readline())
         self.assertEqual(b'', line)
 
     def test_readline_read_byte_count(self):
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         stream.feed_data(self.DATA)
 
         self.loop.run_until_complete(stream.readline())
@@ -251,7 +249,7 @@ class StreamReaderTests(unittest.TestCase):
             stream._byte_count)
 
     def test_readline_exception(self):
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         stream.feed_data(b'line\n')
 
         data = self.loop.run_until_complete(stream.readline())
@@ -263,7 +261,7 @@ class StreamReaderTests(unittest.TestCase):
 
     def test_readexactly_zero_or_less(self):
         # Read exact number of bytes (zero or less).
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         stream.feed_data(self.DATA)
 
         data = self.loop.run_until_complete(stream.readexactly(0))
@@ -276,10 +274,10 @@ class StreamReaderTests(unittest.TestCase):
 
     def test_readexactly(self):
         # Read exact number of bytes.
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
 
         n = 2 * len(self.DATA)
-        read_task = tasks.Task(stream.readexactly(n), loop=self.loop)
+        read_task = asyncio.Task(stream.readexactly(n), loop=self.loop)
 
         def cb():
             stream.feed_data(self.DATA)
@@ -293,21 +291,25 @@ class StreamReaderTests(unittest.TestCase):
 
     def test_readexactly_eof(self):
         # Read exact number of bytes (eof).
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         n = 2 * len(self.DATA)
-        read_task = tasks.Task(stream.readexactly(n), loop=self.loop)
+        read_task = asyncio.Task(stream.readexactly(n), loop=self.loop)
 
         def cb():
             stream.feed_data(self.DATA)
             stream.feed_eof()
         self.loop.call_soon(cb)
 
-        data = self.loop.run_until_complete(read_task)
-        self.assertEqual(self.DATA, data)
+        with self.assertRaises(asyncio.IncompleteReadError) as cm:
+            self.loop.run_until_complete(read_task)
+        self.assertEqual(cm.exception.partial, self.DATA)
+        self.assertEqual(cm.exception.expected, n)
+        self.assertEqual(str(cm.exception),
+                         '18 bytes read on a total of 36 expected bytes')
         self.assertFalse(stream._byte_count)
 
     def test_readexactly_exception(self):
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         stream.feed_data(b'line\n')
 
         data = self.loop.run_until_complete(stream.readexactly(2))
@@ -318,7 +320,7 @@ class StreamReaderTests(unittest.TestCase):
             ValueError, self.loop.run_until_complete, stream.readexactly(2))
 
     def test_exception(self):
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
         self.assertIsNone(stream.exception())
 
         exc = ValueError()
@@ -326,31 +328,31 @@ class StreamReaderTests(unittest.TestCase):
         self.assertIs(stream.exception(), exc)
 
     def test_exception_waiter(self):
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
 
-        @tasks.coroutine
+        @asyncio.coroutine
         def set_err():
             stream.set_exception(ValueError())
 
-        @tasks.coroutine
+        @asyncio.coroutine
         def readline():
             yield from stream.readline()
 
-        t1 = tasks.Task(stream.readline(), loop=self.loop)
-        t2 = tasks.Task(set_err(), loop=self.loop)
+        t1 = asyncio.Task(stream.readline(), loop=self.loop)
+        t2 = asyncio.Task(set_err(), loop=self.loop)
 
-        self.loop.run_until_complete(tasks.wait([t1, t2], loop=self.loop))
+        self.loop.run_until_complete(asyncio.wait([t1, t2], loop=self.loop))
 
         self.assertRaises(ValueError, t1.result)
 
     def test_exception_cancel(self):
-        stream = streams.StreamReader(loop=self.loop)
+        stream = asyncio.StreamReader(loop=self.loop)
 
-        @tasks.coroutine
+        @asyncio.coroutine
         def read_a_line():
             yield from stream.readline()
 
-        t = tasks.Task(read_a_line(), loop=self.loop)
+        t = asyncio.Task(read_a_line(), loop=self.loop)
         test_utils.run_briefly(self.loop)
         t.cancel()
         test_utils.run_briefly(self.loop)
@@ -367,19 +369,19 @@ class StreamReaderTests(unittest.TestCase):
                 self.server = None
                 self.loop = loop
 
-            @tasks.coroutine
+            @asyncio.coroutine
             def handle_client(self, client_reader, client_writer):
                 data = yield from client_reader.readline()
                 client_writer.write(data)
 
             def start(self):
                 self.server = self.loop.run_until_complete(
-                    streams.start_server(self.handle_client,
+                    asyncio.start_server(self.handle_client,
                                          '127.0.0.1', 12345,
                                          loop=self.loop))
 
             def handle_client_callback(self, client_reader, client_writer):
-                task = tasks.Task(client_reader.readline(), loop=self.loop)
+                task = asyncio.Task(client_reader.readline(), loop=self.loop)
 
                 def done(task):
                     client_writer.write(task.result())
@@ -388,7 +390,7 @@ class StreamReaderTests(unittest.TestCase):
 
             def start_callback(self):
                 self.server = self.loop.run_until_complete(
-                    streams.start_server(self.handle_client_callback,
+                    asyncio.start_server(self.handle_client_callback,
                                          '127.0.0.1', 12345,
                                          loop=self.loop))
 
@@ -398,9 +400,9 @@ class StreamReaderTests(unittest.TestCase):
                     self.loop.run_until_complete(self.server.wait_closed())
                     self.server = None
 
-        @tasks.coroutine
+        @asyncio.coroutine
         def client():
-            reader, writer = yield from streams.open_connection(
+            reader, writer = yield from asyncio.open_connection(
                 '127.0.0.1', 12345, loop=self.loop)
             # send a line
             writer.write(b"hello world!\n")
@@ -412,7 +414,7 @@ class StreamReaderTests(unittest.TestCase):
         # test the server variant with a coroutine as client handler
         server = MyServer(self.loop)
         server.start()
-        msg = self.loop.run_until_complete(tasks.Task(client(),
+        msg = self.loop.run_until_complete(asyncio.Task(client(),
                                                       loop=self.loop))
         server.stop()
         self.assertEqual(msg, b"hello world!\n")
@@ -420,7 +422,7 @@ class StreamReaderTests(unittest.TestCase):
         # test the server variant with a callback as client handler
         server = MyServer(self.loop)
         server.start_callback()
-        msg = self.loop.run_until_complete(tasks.Task(client(),
+        msg = self.loop.run_until_complete(asyncio.Task(client(),
                                                       loop=self.loop))
         server.stop()
         self.assertEqual(msg, b"hello world!\n")