def test_gc_handle(self):
weak_handle = weakref.ref(uv.Prepare())
gc.collect()
self.assert_equal(weak_handle(), None)
prepare = uv.Prepare()
prepare.start()
weak_handle = weakref.ref(prepare)
del prepare
gc.collect()
self.assert_not_equal(weak_handle(), None)
def test_stop(self):
self.timer_called = 0
self.prepare_called = 0
def on_timeout(timer):
self.timer_called += 1
if self.timer_called == 2:
self.loop.stop()
if self.timer_called == 10:
timer.close()
def on_prepare(prepare):
self.prepare_called += 1
if self.prepare_called == 10:
prepare.close()
self.timer = uv.Timer(on_timeout=on_timeout)
self.timer.start(10, repeat=10)
self.prepare = uv.Prepare(on_prepare=on_prepare)
self.prepare.start()
self.loop.run()
self.assert_equal(self.timer_called, 2)
self.assert_greater_equal(self.prepare_called, 2)
self.loop.run(uv.RunModes.NOWAIT)
self.assert_greater_equal(self.prepare_called, 3)
self.loop.run()
self.assert_equal(self.timer_called, 10)
self.assert_equal(self.prepare_called, 10)
def test_close(self):
self.prepare = uv.Prepare()
self.prepare.start()
self.assert_false(self.loop.closed)
self.assert_raises(uv.UVError, self.loop.close)
self.prepare.close()
self.assert_raises(uv.UVError, self.loop.close)
self.loop.run()
self.loop.close()
self.assert_raises(uv.ClosedLoopError, uv.Async, loop=self.loop)
self.assert_raises(uv.ClosedLoopError, uv.Check, loop=self.loop)
self.assert_raises(uv.ClosedLoopError, uv.Idle, loop=self.loop)
self.assert_raises(uv.ClosedLoopError, uv.Pipe, loop=self.loop)
self.assert_raises(uv.ClosedLoopError, uv.Poll, 0, loop=self.loop)
self.assert_raises(uv.ClosedLoopError, uv.Prepare, loop=self.loop)
self.assert_raises(uv.ClosedLoopError, uv.Process, ['python'], loop=self.loop)
self.assert_raises(uv.ClosedLoopError, uv.Signal, loop=self.loop)
self.assert_raises(uv.ClosedLoopError, uv.TCP, loop=self.loop)
self.assert_raises(uv.ClosedLoopError, uv.Timer, loop=self.loop)
self.assert_raises(uv.ClosedLoopError, uv.TTY, 0, loop=self.loop)
self.assert_raises(uv.ClosedLoopError, uv.UDP, loop=self.loop)
def test_run_once(self):
self.callback_called = 0
def on_prepare(prepare):
self.callback_called += 1
prepare.close()
for _ in range(500):
self.prepare = uv.Prepare(on_prepare=on_prepare)
self.prepare.start()
self.loop.run(uv.RunModes.ONCE)
self.assert_equal(self.callback_called, 500)
def test_update_time(self):
def on_prepare(prepare):
now = self.loop.now
time.sleep(0.5)
self.assert_equal(now, self.loop.now)
self.loop.update_time()
self.assert_greater(self.loop.now, now)
prepare.close()
self.prepare = uv.Prepare(on_prepare=on_prepare)
self.prepare.start()
self.loop.run()
def test_prepare(self):
self.on_prepare_called = 0
def on_prepare(prepare_handle):
self.on_prepare_called += 1
prepare_handle.stop()
self.prepare = uv.Prepare(on_prepare=on_prepare)
self.prepare.start()
self.loop.run()
self.assert_equal(self.on_prepare_called, 1)
def test_get_handles(self):
prepare = uv.Prepare()
timer = uv.Timer()
self.assert_equal(len(self.loop.handles), 2)
self.assert_in(prepare, self.loop.handles)
self.assert_in(timer, self.loop.handles)
prepare.close()
timer.close()
self.loop.run()
self.assert_equal(len(self.loop.handles), 0)
def test_call_later(self):
self.callback_called = False
# keep the loop alive
self.prepare = uv.Prepare()
self.prepare.start()
def callback():
self.callback_called = True
self.prepare.close()
self.loop.call_later(callback)
self.loop.run()
self.assert_true(self.callback_called)
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_loop_alive(self):
self.assert_false(self.loop.alive)
self.loop_alive = False
def on_prepare(prepare):
self.loop_alive = self.loop.alive
prepare.close()
self.prepare = uv.Prepare(on_prepare=on_prepare)
self.prepare.start()
self.loop.run()
self.assert_true(self.loop_alive)
self.assert_false(self.loop.alive)
def test_process_endless_loop(self):
arguments = [sys.executable, PROGRAM_ENDLESS_LOOP]
self.returncode = None
self.term_signal = None
def on_exit(process_handle, returncode, term_signal):
self.returncode = returncode
self.term_signal = term_signal
def on_prepare(prepare_handle):
prepare_handle.close()
self.process.kill()
self.process = uv.Process(arguments, on_exit=on_exit)
self.prepare = uv.Prepare(on_prepare=on_prepare)
self.prepare.start()
self.loop.run()
self.assert_is_not(self.returncode, None)
self.assert_is_not(self.term_signal, None)
def test_async(self):
def thread():
while True:
with self.lock:
if self.async_callback_called == 3:
break
self. async .send()
def on_closed(_):
self.close_callback_called += 1
def on_wakeup(async):
with self.lock:
self.async_callback_called += 1
if self.async_callback_called == 3:
async .close(on_closed=on_closed)
self.assert_equal(self.loop_thread, threading.current_thread)
def on_prepare(prepare):
threading.Thread(target=thread).start()
prepare.close(on_closed=on_closed)
self.async_callback_called = 0
self.close_callback_called = 0
self.lock = threading.RLock()
self.loop_thread = threading.current_thread
self. async = uv.Async(on_wakeup=on_wakeup)
self.prepare = uv.Prepare(on_prepare=on_prepare)
self.prepare.start()
self.loop.run()
self.assert_equal(self.async_callback_called, 3)
self.assert_equal(self.close_callback_called, 2)
def main2():
for _ in range(500):
self.prepare2 = uv.Prepare(self.loop2, on_prepare2)
self.prepare2.start()
self.loop2.run()
def main1():
for _ in range(500):
self.prepare1 = uv.Prepare(self.loop1, on_prepare1)
self.prepare1.start()
self.loop1.run()
def test_closed(self):
self.prepare = uv.Prepare()
self.prepare.close()
self.assert_raises(uv.ClosedHandleError, self.prepare.start)
self.assert_is(self.prepare.stop(), None)
def test_double_close(self):
self.prepare = uv.Prepare()
self.prepare.close()
self.prepare.close()