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)
