def _test_pipe(self): ADDRESS = r'\\.\pipe\_test_pipe-%s' % os.getpid() with self.assertRaises(FileNotFoundError): yield from self.loop.create_pipe_connection( protocols.Protocol, ADDRESS) [server] = yield from self.loop.start_serving_pipe(UpperProto, ADDRESS) self.assertIsInstance(server, windows_events.PipeServer) clients = [] for i in range(5): stream_reader = streams.StreamReader(loop=self.loop) protocol = streams.StreamReaderProtocol(stream_reader) trans, proto = yield from self.loop.create_pipe_connection( lambda: protocol, ADDRESS) self.assertIsInstance(trans, transports.Transport) self.assertEqual(protocol, proto) clients.append((stream_reader, trans)) for i, (r, w) in enumerate(clients): w.write('lower-{}\n'.format(i).encode()) for i, (r, w) in enumerate(clients): response = yield from r.readline() self.assertEqual(response, 'LOWER-{}\n'.format(i).encode()) w.close() server.close() with self.assertRaises(FileNotFoundError): yield from self.loop.create_pipe_connection( protocols.Protocol, ADDRESS) return 'done'
def test_readline_eof(self): stream = streams.StreamReader(loop=self.loop) stream.feed_data(b'some data') stream.feed_eof() line = self.loop.run_until_complete(stream.readline()) self.assertEqual(b'some data', line)
def test_exception(self): stream = streams.StreamReader(loop=self.loop) self.assertIsNone(stream.exception()) exc = ValueError() stream.set_exception(exc) self.assertIs(stream.exception(), exc)
def test_read_zero(self): # Read zero bytes. stream = streams.StreamReader(loop=self.loop) stream.feed_data(self.DATA) data = self.loop.run_until_complete(stream.read(0)) self.assertEqual(b'', data) self.assertEqual(len(self.DATA), stream._byte_count)
def make_stream_pair(self): self._read_stream = streams.StreamReader(loop=self._loop) def read_proto_factory(): return streams.StreamReaderProtocol(self._read_stream, loop=self._loop) self._read_transport, self._read_protocol = yield from self._loop.connect_read_pipe(read_proto_factory, self._read_file) self._write_transport, self._write_protocol = yield from self._loop.connect_write_pipe(asyncio.Protocol, self._write_file) self._write_stream = streams.StreamWriter(self._write_transport, self._read_protocol, self._read_stream, self._loop) return self._read_stream, self._write_stream
def test_readline_line_byte_count(self): stream = streams.StreamReader(loop=self.loop) stream.feed_data(self.DATA[:6]) stream.feed_data(self.DATA[6:]) line = self.loop.run_until_complete(stream.readline()) self.assertEqual(b'line1\n', line) self.assertEqual(len(self.DATA) - len(b'line1\n'), stream._byte_count)
def test_readline_limit_with_existing_data(self): stream = streams.StreamReader(3, loop=self.loop) stream.feed_data(b'li') stream.feed_data(b'ne1\nline2\n') self.assertRaises(ValueError, self.loop.run_until_complete, stream.readline()) self.assertEqual([b'line2\n'], list(stream._buffer)) stream = streams.StreamReader(3, loop=self.loop) stream.feed_data(b'li') stream.feed_data(b'ne1') stream.feed_data(b'li') self.assertRaises(ValueError, self.loop.run_until_complete, stream.readline()) self.assertEqual([b'li'], list(stream._buffer)) self.assertEqual(2, stream._byte_count)
def connect_read_pipe(file): loop = asyncio.get_event_loop() stream_reader = streams.StreamReader(loop=loop) def factory(): return streams.StreamReaderProtocol(stream_reader) transport, _ = yield from loop.connect_read_pipe(factory, file) return stream_reader, transport
def test_readexactly_exception(self): stream = streams.StreamReader(loop=self.loop) stream.feed_data(b'line\n') data = self.loop.run_until_complete(stream.readexactly(2)) self.assertEqual(b'li', data) stream.set_exception(ValueError()) self.assertRaises(ValueError, self.loop.run_until_complete, stream.readexactly(2))
def test_read_line_breaks(self): # Read bytes without line breaks. stream = streams.StreamReader(loop=self.loop) stream.feed_data(b'line1') stream.feed_data(b'line2') data = self.loop.run_until_complete(stream.read(5)) self.assertEqual(b'line1', data) self.assertEqual(5, stream._byte_count)
def test_readexactly_zero_or_less(self): # Read exact number of bytes (zero or less). stream = streams.StreamReader(loop=self.loop) stream.feed_data(self.DATA) data = self.loop.run_until_complete(stream.readexactly(0)) self.assertEqual(b'', data) self.assertEqual(len(self.DATA), stream._byte_count) data = self.loop.run_until_complete(stream.readexactly(-1)) self.assertEqual(b'', data) self.assertEqual(len(self.DATA), stream._byte_count)
def test_readline_read_byte_count(self): stream = streams.StreamReader(loop=self.loop) stream.feed_data(self.DATA) self.loop.run_until_complete(stream.readline()) data = self.loop.run_until_complete(stream.read(7)) self.assertEqual(b'line2\nl', data) self.assertEqual( len(self.DATA) - len(b'line1\n') - len(b'line2\nl'), stream._byte_count)
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) def cb(): stream.feed_eof() self.loop.call_soon(cb) data = self.loop.run_until_complete(read_task) self.assertEqual(b'', data) self.assertFalse(stream._byte_count)
def test_read(self): # Read bytes. stream = streams.StreamReader(loop=self.loop) read_task = tasks.Task(stream.read(30), loop=self.loop) def cb(): stream.feed_data(self.DATA) self.loop.call_soon(cb) data = self.loop.run_until_complete(read_task) self.assertEqual(self.DATA, data) self.assertFalse(stream._byte_count)
def test_readline_limit(self): stream = streams.StreamReader(7, loop=self.loop) def cb(): stream.feed_data(b'chunk1') stream.feed_data(b'chunk2') stream.feed_data(b'chunk3\n') stream.feed_eof() self.loop.call_soon(cb) self.assertRaises(ValueError, self.loop.run_until_complete, stream.readline()) self.assertEqual([b'chunk3\n'], list(stream._buffer)) self.assertEqual(7, stream._byte_count)
def test_readexactly_eof(self): # Read exact number of bytes (eof). stream = streams.StreamReader(loop=self.loop) n = 2 * len(self.DATA) read_task = tasks.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) self.assertFalse(stream._byte_count)
def test_exception_cancel(self): stream = streams.StreamReader(loop=self.loop) @tasks.coroutine def read_a_line(): yield from stream.readline() t = tasks.Task(read_a_line(), loop=self.loop) test_utils.run_briefly(self.loop) t.cancel() test_utils.run_briefly(self.loop) # The following line fails if set_exception() isn't careful. stream.set_exception(RuntimeError('message')) test_utils.run_briefly(self.loop) self.assertIs(stream._waiter, None)
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) def cb(): stream.feed_data(b'chunk1\n') stream.feed_data(b'chunk2') stream.feed_eof() self.loop.call_soon(cb) data = self.loop.run_until_complete(read_task) self.assertEqual(b'chunk1\nchunk2', data) self.assertFalse(stream._byte_count)
def test_readline(self): # Read one line. stream = streams.StreamReader(loop=self.loop) stream.feed_data(b'chunk1 ') read_task = tasks.Task(stream.readline(), loop=self.loop) def cb(): stream.feed_data(b'chunk2 ') stream.feed_data(b'chunk3 ') stream.feed_data(b'\n chunk4') self.loop.call_soon(cb) line = self.loop.run_until_complete(read_task) self.assertEqual(b'chunk1 chunk2 chunk3 \n', line) self.assertEqual(len(b'\n chunk4') - 1, stream._byte_count)
def test_exception_waiter(self): stream = streams.StreamReader(loop=self.loop) @tasks.coroutine def set_err(): stream.set_exception(ValueError()) @tasks.coroutine def readline(): yield from stream.readline() t1 = tasks.Task(stream.readline(), loop=self.loop) t2 = tasks.Task(set_err(), loop=self.loop) self.loop.run_until_complete(tasks.wait([t1, t2], loop=self.loop)) self.assertRaises(ValueError, t1.result)
def test_feed_data_byte_count(self): stream = streams.StreamReader(loop=self.loop) stream.feed_data(self.DATA) self.assertEqual(len(self.DATA), stream._byte_count)
def test_feed_empty_data(self): stream = streams.StreamReader(loop=self.loop) stream.feed_data(b'') self.assertEqual(0, stream._byte_count)
def test_ctor_global_loop(self, m_events): stream = streams.StreamReader() self.assertIs(stream._loop, m_events.get_event_loop.return_value)