def test_event_timeout(self):
ev = Event()
def waiter():
self.assertFalse(ev.wait(0.001))
evergreen.spawn(waiter)
self.loop.call_later(0.1, ev.set)
self.loop.run()
def test_processpool_executor(self):
executor = futures.ProcessPoolExecutor(5)
def waiter():
f = executor.submit(dummy)
self.assertEqual(f.get(), 42)
evergreen.spawn(waiter)
self.loop.run()
def test_destroy_while_running(self):
def func():
evergreen.sleep(0.01)
self.assertRaises(RuntimeError, self.loop.destroy)
evergreen.spawn(func)
self.loop.run()
def test_event_simple(self):
ev = Event()
def waiter():
self.assertTrue(ev.wait())
evergreen.spawn(waiter)
evergreen.spawn(ev.set)
self.loop.run()
def test_semaphore(self):
def func():
lock = locks.Semaphore()
lock.acquire()
self.assertFalse(lock.acquire(blocking=False))
evergreen.spawn(func)
self.loop.run()
def test_default_executor(self):
def func():
return 42
def waiter():
f = self.loop.run_in_executor(None, func)
self.assertEqual(f.get(), 42)
evergreen.spawn(waiter)
self.loop.run()
def test_spawn(self):
d = dummy()
d.called = False
def func():
d.called = True
evergreen.spawn(func)
self.loop.run()
self.assertTrue(d.called)
def test_spawn_order(self):
called = []
def func(x):
called.append(x)
for i in range(5):
evergreen.spawn(func, i)
self.loop.run()
self.assertEqual(called, [0, 1, 2, 3, 4])
def test_bounded_semaphore(self):
def func():
lock = locks.BoundedSemaphore()
lock.acquire()
lock.release()
self.assertRaises(ValueError, lock.release)
evergreen.spawn(func)
self.loop.run()
def test_with_timeout(self):
def sleep():
with Timeout(0.01):
evergreen.sleep(10)
def func():
self.assertRaises(Timeout, sleep)
evergreen.spawn(func)
self.loop.run()
def test_with_negative_timeout(self):
def sleep():
with Timeout(-1):
evergreen.sleep(0.01)
def func():
sleep()
evergreen.spawn(func)
self.loop.run()
def test_timeout_custom_exception(self):
def sleep():
with Timeout(0.01, FooTimeout):
evergreen.sleep(10)
def func():
self.assertRaises(FooTimeout, sleep)
evergreen.spawn(func)
self.loop.run()
def test_semaphore(self):
def func():
lock = locks.Semaphore()
lock.acquire()
self.assertFalse(lock.acquire(blocking=False))
evergreen.spawn(func)
self.loop.run()
def test_default_executor_raises(self):
def func():
1/0
def waiter():
f = self.loop.run_in_executor(None, func)
self.assertRaises(ZeroDivisionError, f.get)
evergreen.spawn(waiter)
self.loop.run()
def test_processpool_executor(self):
executor = futures.ProcessPoolExecutor(5)
def waiter():
f = executor.submit(dummy)
self.assertEqual(f.get(), 42)
evergreen.spawn(waiter)
self.loop.run()
def test_channel_exception(self):
ch = evergreen.Channel()
def sender():
ch.send_exception(RuntimeError)
def receiver():
self.assertRaises(RuntimeError, ch.receive)
evergreen.spawn(sender)
evergreen.spawn(receiver)
self.loop.run()
def test_channel_simple(self):
ch = evergreen.Channel()
def sender():
ch.send('test')
def receiver():
self.assertEqual(ch.receive(), 'test')
evergreen.spawn(sender)
evergreen.spawn(receiver)
self.loop.run()
def test_taskpool_executor_raises(self):
executor = futures.TaskPoolExecutor(10)
def func():
1/0
def waiter():
f = executor.submit(func)
self.assertRaises(ZeroDivisionError, f.get)
evergreen.spawn(waiter)
self.loop.run()
def test_executor_with(self):
def func():
return 42
def waiter():
with futures.TaskPoolExecutor(5) as e:
f = e.submit(func)
self.assertEqual(f.get(), 42)
evergreen.spawn(waiter)
self.loop.run()
def test_event_kill_waiter(self):
ev = Event()
def waiter():
ev.wait()
t1 = evergreen.spawn(waiter)
evergreen.spawn(t1.kill)
evergreen.spawn(ev.set)
self.loop.run()
self.assertTrue(ev.is_set())
def test_event_clear(self):
ev = Event()
def waiter():
self.assertTrue(ev.wait())
ev.clear()
evergreen.spawn(waiter)
evergreen.spawn(ev.set)
self.loop.run()
self.assertFalse(ev.is_set())
def test_taskpool_executor(self):
executor = futures.TaskPoolExecutor(10)
def func():
return 42
def waiter():
f = executor.submit(func)
self.assertEqual(f.get(), 42)
evergreen.spawn(waiter)
self.loop.run()
def test_bounded_semaphore(self):
def func():
lock = locks.BoundedSemaphore()
lock.acquire()
lock.release()
self.assertRaises(ValueError, lock.release)
evergreen.spawn(func)
self.loop.run()
def test_timeout(self):
def func():
t = Timeout(0.01)
t.start()
try:
evergreen.sleep(10)
except Timeout as e:
self.assertTrue(t is e)
evergreen.spawn(func)
self.loop.run()
def test_taskpool_executor_return_exception(self):
executor = futures.TaskPoolExecutor(10)
def func():
1/0
def waiter():
f = executor.submit(func)
e = f.get(return_exception=True)
self.assertTrue(isinstance(e, ZeroDivisionError))
evergreen.spawn(waiter)
self.loop.run()
def test_spawn(self):
d = dummy()
d.called = False
def func():
d.called = True
evergreen.spawn(func)
self.loop.run()
self.assertTrue(d.called)
def test_rlock(self):
lock = locks.RLock()
def func1():
lock.acquire()
self.assertTrue(lock.acquire())
def func2():
self.assertFalse(lock.acquire(blocking=False))
evergreen.spawn(func1)
evergreen.spawn(func2)
self.loop.run()
def test_default_executor(self):
def func():
return 42
def waiter():
f = self.loop.run_in_executor(None, func)
self.assertEqual(f.get(), 42)
evergreen.spawn(waiter)
self.loop.run()
def test_default_executor_raises(self):
def func():
1 / 0
def waiter():
f = self.loop.run_in_executor(None, func)
self.assertRaises(ZeroDivisionError, f.get)
evergreen.spawn(waiter)
self.loop.run()
def test_with_negative_timeout(self):
def sleep():
with Timeout(-1):
evergreen.sleep(0.01)
def func():
sleep()
evergreen.spawn(func)
self.loop.run()
def test_timeout_custom_exception(self):
def sleep():
with Timeout(0.01, FooTimeout):
evergreen.sleep(10)
def func():
self.assertRaises(FooTimeout, sleep)
evergreen.spawn(func)
self.loop.run()
def test_with_timeout(self):
def sleep():
with Timeout(0.01):
evergreen.sleep(10)
def func():
self.assertRaises(Timeout, sleep)
evergreen.spawn(func)
self.loop.run()
def test_task_bogus_switch(self):
def func1():
evergreen.sleep(0)
evergreen.sleep(0)
def func2():
self.assertRaises(RuntimeError, t1.switch)
self.assertRaises(RuntimeError, t1.throw)
t1 = evergreen.spawn(func1)
t2 = evergreen.spawn(func2)
self.loop.run()
def test_spawn_order(self):
called = []
def func(x):
called.append(x)
for i in range(5):
evergreen.spawn(func, i)
self.loop.run()
self.assertEqual(called, [0, 1, 2, 3, 4])
def test_future_as_completed(self):
def func(x):
evergreen.sleep(x)
return 42
def waiter():
l = [self.loop.run_in_executor(None, func, 0.001) for x in range(10)]
for f in futures.as_completed(l):
self.assertEqual(f.get(), 42)
evergreen.spawn(waiter)
self.loop.run()
def test_executor_with(self):
def func():
return 42
def waiter():
with futures.TaskPoolExecutor(5) as e:
f = e.submit(func)
self.assertEqual(f.get(), 42)
evergreen.spawn(waiter)
self.loop.run()
def test_pipe_read_error(self):
def connect():
client = pipe.PipeClient()
client.connect(TEST_PIPE)
evergreen.sleep(0.1) # give it some time to stabilize
client.close()
self.assertRaises(pipe.PipeError, client.read_until, b'\n')
self.server.close()
evergreen.spawn(self._start_pipe_echo_server)
evergreen.spawn(connect)
self.loop.run()
def test_map(self):
executor = futures.TaskPoolExecutor(10)
def func(x):
return x*x
def waiter():
l1 = [2, 4, 6]
l2 = [4, 16, 36]
r = list(executor.map(func, l1))
self.assertEqual(r, l2)
evergreen.spawn(waiter)
self.loop.run()
def test_internal_threadpool(self):
tid = threading.current_thread().ident
def runner():
import time
time.sleep(0.001)
return threading.current_thread().ident
def func():
r = self.loop._threadpool.spawn(runner)
self.assertNotEqual(r.get(), tid)
evergreen.spawn(func)
self.loop.run()
def test_timeout(self):
def func():
t = Timeout(0.01)
t.start()
try:
evergreen.sleep(10)
except Timeout as e:
self.assertTrue(t is e)
evergreen.spawn(func)
self.loop.run()
def test_tcp_read_error(self):
def connect():
client = tcp.TCPClient()
client.connect(TEST_CLIENT)
evergreen.sleep(0.1) # give it some time to stabilize
client.close()
self.assertRaises(tcp.TCPError, client.read_until, b'\n')
self.server.close()
evergreen.spawn(self._start_tcp_echo_server)
evergreen.spawn(connect)
self.loop.run()
def test_future_as_completed(self):
executor = futures.TaskPoolExecutor(10)
def func(x):
evergreen.sleep(x)
return 42
def waiter():
l = [executor.submit(func, 0.001) for x in range(10)]
for f in futures.as_completed(l):
self.assertEqual(f.get(), 42)
evergreen.spawn(waiter)
self.loop.run()
def test_threadpool_executor(self):
executor = futures.ThreadPoolExecutor(5)
def func():
import time
time.sleep(0.01)
return 42
def waiter():
f = executor.submit(func)
self.assertEqual(f.get(), 42)
evergreen.spawn(waiter)
self.loop.run()
def test_pipe_read_error(self):
def connect():
client = pipe.PipeClient()
client.connect(TEST_PIPE)
evergreen.sleep(0.1) # give it some time to stabilize
client.close()
self.assertRaises(pipe.PipeError, client.read_until, b'\n')
self.server.close()
evergreen.spawn(self._start_pipe_echo_server)
evergreen.spawn(connect)
self.loop.run()
def test_tcp_read_error(self):
def connect():
client = tcp.TCPClient()
client.connect(TEST_CLIENT)
evergreen.sleep(0.1) # give it some time to stabilize
client.close()
self.assertRaises(tcp.TCPError, client.read_until, b'\n')
self.server.close()
evergreen.spawn(self._start_tcp_echo_server)
evergreen.spawn(connect)
self.loop.run()
def test_taskpool_executor_raises(self):
executor = futures.TaskPoolExecutor(10)
def func():
1 / 0
def waiter():
f = executor.submit(func)
self.assertRaises(ZeroDivisionError, f.get)
evergreen.spawn(waiter)
self.loop.run()
def test_task_bogus_switch(self):
def func1():
evergreen.sleep(0)
evergreen.sleep(0)
def func2():
self.assertRaises(RuntimeError, t1.switch)
self.assertRaises(RuntimeError, t1.throw)
t1 = evergreen.spawn(func1)
t2 = evergreen.spawn(func2)
self.loop.run()
def test_taskpool_executor(self):
executor = futures.TaskPoolExecutor(10)
def func():
return 42
def waiter():
f = executor.submit(func)
self.assertEqual(f.get(), 42)
evergreen.spawn(waiter)
self.loop.run()
def test_kill_running(self):
called = []
def func():
evergreen.sleep(0)
called.append(None)
evergreen.sleep(0)
called.append(None)
task1 = evergreen.spawn(func)
task2 = evergreen.spawn(task1.kill)
self.loop.run()
self.assertEqual(len(called), 1)
def test_rlock(self):
lock = locks.RLock()
def func1():
lock.acquire()
self.assertTrue(lock.acquire())
def func2():
self.assertFalse(lock.acquire(blocking=False))
evergreen.spawn(func1)
evergreen.spawn(func2)
self.loop.run()
def test_pipe_read(self):
def connect():
client = pipe.PipeClient()
client.connect(TEST_PIPE)
client.write(b'PING\n')
data = client.read_until(b'\n')
self.assertEqual(data, b'PING\n')
client.close()
self.server.close()
evergreen.spawn(self._start_pipe_echo_server)
evergreen.spawn(connect)
self.loop.run()
def test_future_wait(self):
def func():
evergreen.sleep(0.001)
return 42
def waiter():
f = self.loop.run_in_executor(None, func)
done, not_done = futures.wait([f])
self.assertTrue(f in done)
self.assertEqual(f.get(), 42)
evergreen.spawn(waiter)
self.loop.run()
def test_taskpool_executor_return_exception(self):
executor = futures.TaskPoolExecutor(10)
def func():
1 / 0
def waiter():
f = executor.submit(func)
e = f.get(return_exception=True)
self.assertTrue(isinstance(e, ZeroDivisionError))
evergreen.spawn(waiter)
self.loop.run()
def test_task_sleep(self):
called = []
def func():
called.append(None)
evergreen.sleep(0.001)
called.append(None)
evergreen.spawn(func)
t0 = time.time()
self.loop.run()
t1 = time.time()
self.assertEqual(len(called), 2)
self.assertTrue(0 <= t1 - t0 < 0.1)
