def test_try_write(self): self.buffer = b'' self.bytes_written = 0 def on_read(connection, status, data): self.buffer += data connection.read_stop() def on_connection(pipe_handle, status): connection = pipe_handle.accept() connection.read_start(on_read=on_read) pipe_handle.close() def on_timeout(timer): try: self.bytes_written = self.client.try_write(b'hello') except uv.error.TemporaryUnavailableError: self.server.close() finally: timer.close() self.server = uv.Pipe() self.server.bind(common.TEST_PIPE1) self.server.listen(on_connection=on_connection) self.client = uv.Pipe() self.client.connect(common.TEST_PIPE1) self.timer = uv.Timer(on_timeout=on_timeout) self.timer.start(10) self.loop.run() self.assert_equal(self.buffer, b'hello'[:self.bytes_written])
def test_pipe(self): self.server = uv.Pipe() self.server.pending_instances(100) self.server.bind(common.TEST_PIPE1) self.server.listen(5, on_connection=self.on_connection) self.client = uv.Pipe() self.client.connect(common.TEST_PIPE1, on_connect=self.on_connect) self.run_ping_pong()
def test_process_hello(self): arguments = [sys.executable, PROGRAM_HELLO] self.buffer = b'' self.returncode = None def on_exit(process_handle, returncode, term_signal): self.returncode = returncode def on_read(pipe_handle, status, data): self.buffer += data self.pipe = uv.Pipe() self.pipe.bind(common.TEST_PIPE1) self.process = uv.Process(arguments, stdout=uv.PIPE, stdio=[self.pipe], on_exit=on_exit) self.process.stdout.read_start(on_read) self.loop.run() self.assert_equal(self.buffer.strip(), b'hello') self.assert_equal(self.returncode, 1) self.assert_not_equal(self.process.pid, None) self.assert_raises(uv.error.ProcessLookupError, self.process.kill) self.process.close() self.assert_raises(uv.ClosedHandleError, self.process.kill) with self.should_raise(uv.ClosedHandleError): pid = self.process.pid
def test_peername(self): def on_connect(request, status): self.assert_equal(status, uv.StatusCodes.SUCCESS) self.assert_equal(request.stream.peername, common.TEST_PIPE1) request.stream.close() def on_connection(handle, status): self.assert_equal(status, uv.StatusCodes.SUCCESS) handle.close() self.pipe1 = uv.Pipe() self.pipe1.bind(common.TEST_PIPE1) self.pipe1.listen(on_connection=on_connection) self.pipe2 = uv.Pipe() self.pipe2.connect(common.TEST_PIPE1, on_connect=on_connect) self.loop.run()
def test_connect_bad(self): def on_connect(request, status): self.assert_not_equal(status, uv.StatusCodes.SUCCESS) request.stream.close() self.pipe = uv.Pipe() self.pipe.connect(common.BAD_PIPE, on_connect=on_connect) self.loop.run()
def test_closed(self): self.pipe = uv.Pipe() self.pipe.close() self.assert_false(self.pipe.readable) self.assert_false(self.pipe.writable) self.assert_raises(uv.ClosedHandleError, self.pipe.shutdown) self.assert_raises(uv.ClosedHandleError, self.pipe.listen) self.assert_raises(uv.ClosedHandleError, self.pipe.read_start) self.assert_is(self.pipe.read_stop(), None) self.assert_raises(uv.ClosedHandleError, self.pipe.write, b'') self.assert_raises(uv.ClosedHandleError, self.pipe.try_write, b'') self.assert_raises(uv.ClosedHandleError, self.pipe.accept)
def test_tcp_ipv4_icp_client(self): address = (common.TEST_IPV4, common.TEST_PORT1) self.server = uv.TCP() self.server.bind(address) self.server.listen(5, on_connection=self.on_connection) client = uv.TCP() client.connect(address) def on_read(pipe_client, status, data): if pipe_client.pending_count: self.client = pipe_client.pending_accept() self.client.read_start(on_read=self.on_read) pipe_client.close() def on_connection(pipe_server, status): connection = pipe_server.accept(ipc=True) connection.write(b'hello', send_stream=client) connection.close() pipe_server.close() self.pipe_server = uv.Pipe() self.pipe_server.pending_instances(100) self.pipe_server.bind(common.TEST_PIPE1) self.pipe_server.listen(on_connection=on_connection) self.pipe_client = uv.Pipe(ipc=True) self.pipe_client.connect(common.TEST_PIPE1) self.pipe_client.read_start(on_read=on_read) self.loop.run() self.run_ping_pong() client.close() self.server.close() self.client.close()
def test_gc_loop_close(self): client = uv.Pipe() client.connect(common.TEST_PIPE1).clear_pending() client.clear_pending() weak_client = weakref.ref(client) del client gc.collect() self.assert_is(weak_client(), None) self.loop.close()
def test_gc_pending(self): loop = uv.Loop() client = uv.Pipe(loop=loop) client.connect(common.TEST_PIPE1) client.write(b'hello') weak_client = weakref.ref(client) self.loop.make_current() del loop del client gc.collect() self.assert_is(weak_client(), None)
def test_excepthook(self): self.loop.close() self.loop = uv.Loop() def excepthook(loop, exc_type, exc_value, exc_traceback): loop.stop() self.loop.excepthook = excepthook def throw_test(*_): raise Exception('test') self.prepare = uv.Prepare(on_prepare=throw_test) self.prepare.start() self.loop.run() self.assert_is(self.loop.exc_type, Exception) self.assert_equal(self.loop.exc_value.args[0], 'test') self.loop.reset_exception() self.assert_is(self.loop.exc_type, None) self.assert_is(self.loop.exc_value, None) self.prepare.close(on_closed=throw_test) self.loop.run() self.assert_is(self.loop.exc_type, Exception) self.assert_equal(self.loop.exc_value.args[0], 'test') self.loop.reset_exception() self.pipe = uv.Pipe() self.pipe.connect(common.BAD_PIPE, on_connect=throw_test) self.loop.run() self.assert_is(self.loop.exc_type, Exception) self.assert_equal(self.loop.exc_value.args[0], 'test') self.loop.reset_exception() self.loop.call_later(throw_test) self.loop.run() self.assert_is(self.loop.exc_type, Exception) self.assert_equal(self.loop.exc_value.args[0], 'test') self.loop.reset_exception()
def test_closed(self): self.pipe = uv.Pipe() self.pipe.close() self.assert_raises(uv.error.ClosedHandleError, self.pipe.open, 0) self.assert_equal(self.pipe.pending_count, 0) self.assert_equal(self.pipe.pending_type, None) self.assert_raises(uv.error.ClosedHandleError, self.pipe.pending_accept) self.assert_raises(uv.error.ClosedHandleError, self.pipe.pending_instances, 100) with self.should_raise(uv.error.ClosedHandleError): sockname = self.pipe.sockname with self.should_raise(uv.error.ClosedHandleError): peername = self.pipe.peername self.assert_raises(uv.error.ClosedHandleError, self.pipe.bind, '') self.assert_raises(uv.error.ClosedHandleError, self.pipe.connect, '')
def test_type(self): self.pipe = uv.Pipe() request = self.pipe.connect(common.BAD_PIPE) self.assert_is(request.type, uv.ConnectRequest)
def test_no_pending_accept(self): self.pipe = uv.Pipe() self.assert_raises(uv.error.ArgumentError, self.pipe.pending_accept)
def test_writable_readable(self): self.pipe = uv.Pipe() self.assert_false(self.pipe.readable) self.assert_false(self.pipe.writable)
def test_family(self): self.pipe = uv.Pipe() if uv.common.is_win32: self.assert_is(self.pipe.family, None) else: self.assert_is(self.pipe.family, socket.AF_UNIX)
def test_pipe_open(self): unix_socket = socket.socket(family=socket.AF_UNIX) self.pipe = uv.Pipe() self.pipe.open(unix_socket.fileno()) self.assert_equal(self.pipe.fileno(), unix_socket.fileno())
def test_sockname(self): self.pipe = uv.Pipe() self.pipe.bind(common.TEST_PIPE1) self.assert_equal(self.pipe.sockname, common.TEST_PIPE1)