m_socket = mock.MagicMock(spec=socket)

for name in (

'AF_INET', 'AF_INET6', 'AF_UNSPEC', 'IPPROTO_TCP', 'IPPROTO_UDP',

'SOCK_STREAM', 'SOCK_DGRAM', 'SOL_SOCKET', 'SO_REUSEADDR', 'inet_pton'

):

if hasattr(socket, name):

setattr(m_socket, name, getattr(socket, name))

else:

delattr(m_socket, name)

m_socket.socket = mock.MagicMock()

m_socket.socket.return_value = test_utils.mock_nonblocking_socket()

def test_ipaddr_info(self):

UNSPEC = socket.AF_UNSPEC

INET = socket.AF_INET

INET6 = socket.AF_INET6

STREAM = socket.SOCK_STREAM

DGRAM = socket.SOCK_DGRAM

TCP = socket.IPPROTO_TCP

UDP = socket.IPPROTO_UDP

self.assertEqual(

(INET, STREAM, TCP, '', ('1.2.3.4', 1)),

base_events._ipaddr_info('1.2.3.4', 1, INET, STREAM, TCP))

self.assertEqual(

(INET, STREAM, TCP, '', ('1.2.3.4', 1)),

base_events._ipaddr_info(b'1.2.3.4', 1, INET, STREAM, TCP))

self.assertEqual(

(INET, STREAM, TCP, '', ('1.2.3.4', 1)),

base_events._ipaddr_info('1.2.3.4', 1, UNSPEC, STREAM, TCP))

self.assertEqual(

(INET, DGRAM, UDP, '', ('1.2.3.4', 1)),

base_events._ipaddr_info('1.2.3.4', 1, UNSPEC, DGRAM, UDP))

# Socket type STREAM implies TCP protocol.

self.assertEqual(

(INET, STREAM, TCP, '', ('1.2.3.4', 1)),

base_events._ipaddr_info('1.2.3.4', 1, UNSPEC, STREAM, 0))

# Socket type DGRAM implies UDP protocol.

self.assertEqual(

(INET, DGRAM, UDP, '', ('1.2.3.4', 1)),

base_events._ipaddr_info('1.2.3.4', 1, UNSPEC, DGRAM, 0))

# No socket type.

self.assertIsNone(

base_events._ipaddr_info('1.2.3.4', 1, UNSPEC, 0, 0))

if socket_helper.IPV6_ENABLED:

# IPv4 address with family IPv6.

self.assertIsNone(

base_events._ipaddr_info('1.2.3.4', 1, INET6, STREAM, TCP))

self.assertEqual(

(INET6, STREAM, TCP, '', ('::3', 1, 0, 0)),

base_events._ipaddr_info('::3', 1, INET6, STREAM, TCP))

self.assertEqual(

(INET6, STREAM, TCP, '', ('::3', 1, 0, 0)),

base_events._ipaddr_info('::3', 1, UNSPEC, STREAM, TCP))

# IPv6 address with family IPv4.

self.assertIsNone(

base_events._ipaddr_info('::3', 1, INET, STREAM, TCP))

# IPv6 address with zone index.

self.assertIsNone(

base_events._ipaddr_info('::3%lo0', 1, INET6, STREAM, TCP))

def test_port_parameter_types(self):

# Test obscure kinds of arguments for "port".

INET = socket.AF_INET

STREAM = socket.SOCK_STREAM

TCP = socket.IPPROTO_TCP

self.assertEqual(

(INET, STREAM, TCP, '', ('1.2.3.4', 0)),

base_events._ipaddr_info('1.2.3.4', None, INET, STREAM, TCP))

self.assertEqual(

(INET, STREAM, TCP, '', ('1.2.3.4', 0)),

base_events._ipaddr_info('1.2.3.4', b'', INET, STREAM, TCP))

self.assertEqual(

(INET, STREAM, TCP, '', ('1.2.3.4', 0)),

base_events._ipaddr_info('1.2.3.4', '', INET, STREAM, TCP))

self.assertEqual(

(INET, STREAM, TCP, '', ('1.2.3.4', 1)),

base_events._ipaddr_info('1.2.3.4', '1', INET, STREAM, TCP))

self.assertEqual(

(INET, STREAM, TCP, '', ('1.2.3.4', 1)),

base_events._ipaddr_info('1.2.3.4', b'1', INET, STREAM, TCP))

@patch_socket

def test_ipaddr_info_no_inet_pton(self, m_socket):

del m_socket.inet_pton

self.assertIsNone(base_events._ipaddr_info('1.2.3.4', 1,

socket.AF_INET,

socket.SOCK_STREAM,

socket.IPPROTO_TCP))

def test_interleave_addrinfos(self):

self.maxDiff = None

SIX_A = (socket.AF_INET6, 0, 0, '', ('2001:db8::1', 1))

SIX_B = (socket.AF_INET6, 0, 0, '', ('2001:db8::2', 2))

SIX_C = (socket.AF_INET6, 0, 0, '', ('2001:db8::3', 3))

SIX_D = (socket.AF_INET6, 0, 0, '', ('2001:db8::4', 4))

FOUR_A = (socket.AF_INET, 0, 0, '', ('192.0.2.1', 5))

FOUR_B = (socket.AF_INET, 0, 0, '', ('192.0.2.2', 6))

FOUR_C = (socket.AF_INET, 0, 0, '', ('192.0.2.3', 7))

FOUR_D = (socket.AF_INET, 0, 0, '', ('192.0.2.4', 8))

addrinfos = [SIX_A, SIX_B, SIX_C, FOUR_A, FOUR_B, FOUR_C, FOUR_D, SIX_D]

expected = [SIX_A, FOUR_A, SIX_B, FOUR_B, SIX_C, FOUR_C, SIX_D, FOUR_D]

self.assertEqual(expected, base_events._interleave_addrinfos(addrinfos))

expected_fafc_2 = [SIX_A, SIX_B, FOUR_A, SIX_C, FOUR_B, SIX_D, FOUR_C, FOUR_D]

self.assertEqual(

expected_fafc_2,

base_events._interleave_addrinfos(addrinfos, first_address_family_count=2),

def setUp(self):

super().setUp()

self.loop = base_events.BaseEventLoop()

self.loop._selector = mock.Mock()

self.loop._selector.select.return_value = ()

self.set_event_loop(self.loop)

def test_not_implemented(self):

m = mock.Mock()

self.assertRaises(

NotImplementedError,

self.loop._make_socket_transport, m, m)

self.assertRaises(

NotImplementedError,

self.loop._make_ssl_transport, m, m, m, m)

self.assertRaises(

NotImplementedError,

self.loop._make_datagram_transport, m, m)

self.assertRaises(

NotImplementedError, self.loop._process_events, [])

self.assertRaises(

NotImplementedError, self.loop._write_to_self)

self.assertRaises(

NotImplementedError,

self.loop._make_read_pipe_transport, m, m)

self.assertRaises(

NotImplementedError,

self.loop._make_write_pipe_transport, m, m)

gen = self.loop._make_subprocess_transport(m, m, m, m, m, m, m)

with self.assertRaises(NotImplementedError):

gen.send(None)

def test_close(self):

self.assertFalse(self.loop.is_closed())

self.loop.close()

self.assertTrue(self.loop.is_closed())

# it should be possible to call close() more than once

self.loop.close()

self.loop.close()

# operation blocked when the loop is closed

f = self.loop.create_future()

self.assertRaises(RuntimeError, self.loop.run_forever)

self.assertRaises(RuntimeError, self.loop.run_until_complete, f)

def test__add_callback_handle(self):

h = asyncio.Handle(lambda: False, (), self.loop, None)

self.loop._add_callback(h)

self.assertFalse(self.loop._scheduled)

self.assertIn(h, self.loop._ready)

def test__add_callback_cancelled_handle(self):

h = asyncio.Handle(lambda: False, (), self.loop, None)

h.cancel()

self.loop._add_callback(h)

self.assertFalse(self.loop._scheduled)

self.assertFalse(self.loop._ready)

def test_set_default_executor(self):

class DummyExecutor(concurrent.futures.ThreadPoolExecutor):

def submit(self, fn, *args, **kwargs):

raise NotImplementedError(

'cannot submit into a dummy executor')

self.loop._process_events = mock.Mock()

self.loop._write_to_self = mock.Mock()

executor = DummyExecutor()

self.loop.set_default_executor(executor)

self.assertIs(executor, self.loop._default_executor)

def test_set_default_executor_error(self):

executor = mock.Mock()

msg = 'executor must be ThreadPoolExecutor instance'

with self.assertRaisesRegex(TypeError, msg):

self.loop.set_default_executor(executor)

self.assertIsNone(self.loop._default_executor)

def test_shutdown_default_executor_timeout(self):

event = threading.Event()

class DummyExecutor(concurrent.futures.ThreadPoolExecutor):

def shutdown(self, wait=True, *, cancel_futures=False):

if wait:

event.wait()

self.loop._process_events = mock.Mock()

self.loop._write_to_self = mock.Mock()

executor = DummyExecutor()

self.loop.set_default_executor(executor)

try:

with self.assertWarnsRegex(RuntimeWarning,

"The executor did not finishing joining"):

self.loop.run_until_complete(

self.loop.shutdown_default_executor(timeout=0.01))

finally:

event.set()

def test_call_soon(self):

def cb():

pass

h = self.loop.call_soon(cb)

self.assertEqual(h._callback, cb)

self.assertIsInstance(h, asyncio.Handle)

self.assertIn(h, self.loop._ready)

def test_call_soon_non_callable(self):

self.loop.set_debug(True)

with self.assertRaisesRegex(TypeError, 'a callable object'):

self.loop.call_soon(1)

def test_call_later(self):

def cb():

pass

h = self.loop.call_later(10.0, cb)

self.assertIsInstance(h, asyncio.TimerHandle)

self.assertIn(h, self.loop._scheduled)

self.assertNotIn(h, self.loop._ready)

with self.assertRaises(TypeError, msg="delay must not be None"):

self.loop.call_later(None, cb)

def test_call_later_negative_delays(self):

calls = []

def cb(arg):

calls.append(arg)

self.loop._process_events = mock.Mock()

self.loop.call_later(-1, cb, 'a')

self.loop.call_later(-2, cb, 'b')

test_utils.run_briefly(self.loop)

self.assertEqual(calls, ['b', 'a'])

def test_time_and_call_at(self):

def cb():

self.loop.stop()

self.loop._process_events = mock.Mock()

delay = 0.100

when = self.loop.time() + delay

self.loop.call_at(when, cb)

t0 = self.loop.time()

self.loop.run_forever()

dt = self.loop.time() - t0

# 50 ms: maximum granularity of the event loop

self.assertGreaterEqual(dt, delay - test_utils.CLOCK_RES)

with self.assertRaises(TypeError, msg="when cannot be None"):

self.loop.call_at(None, cb)

def check_thread(self, loop, debug):

def cb():

pass

loop.set_debug(debug)

if debug:

msg = ("Non-thread-safe operation invoked on an event loop other "

"than the current one")

with self.assertRaisesRegex(RuntimeError, msg):

loop.call_soon(cb)

with self.assertRaisesRegex(RuntimeError, msg):

loop.call_later(60, cb)

with self.assertRaisesRegex(RuntimeError, msg):

loop.call_at(loop.time() + 60, cb)

else:

loop.call_soon(cb)

loop.call_later(60, cb)

loop.call_at(loop.time() + 60, cb)

def test_check_thread(self):

def check_in_thread(loop, event, debug, create_loop, fut):

# wait until the event loop is running

event.wait()

try:

if create_loop:

loop2 = base_events.BaseEventLoop()

try:

asyncio.set_event_loop(loop2)

self.check_thread(loop, debug)

finally:

asyncio.set_event_loop(None)

loop2.close()

else:

self.check_thread(loop, debug)

except Exception as exc:

loop.call_soon_threadsafe(fut.set_exception, exc)

else:

loop.call_soon_threadsafe(fut.set_result, None)

def test_thread(loop, debug, create_loop=False):

event = threading.Event()

fut = loop.create_future()

loop.call_soon(event.set)

args = (loop, event, debug, create_loop, fut)

thread = threading.Thread(target=check_in_thread, args=args)

thread.start()

loop.run_until_complete(fut)

thread.join()

self.loop._process_events = mock.Mock()

self.loop._write_to_self = mock.Mock()

# raise RuntimeError if the thread has no event loop

test_thread(self.loop, True)

# check disabled if debug mode is disabled

test_thread(self.loop, False)

# raise RuntimeError if the event loop of the thread is not the called

# event loop

test_thread(self.loop, True, create_loop=True)

# check disabled if debug mode is disabled

test_thread(self.loop, False, create_loop=True)

def test__run_once(self):

h1 = asyncio.TimerHandle(time.monotonic() + 5.0, lambda: True, (),

self.loop, None)

h2 = asyncio.TimerHandle(time.monotonic() + 10.0, lambda: True, (),

self.loop, None)

h1.cancel()

self.loop._process_events = mock.Mock()

self.loop._scheduled.append(h1)

self.loop._scheduled.append(h2)

self.loop._run_once()

t = self.loop._selector.select.call_args[0][0]

self.assertTrue(9.5 < t < 10.5, t)

self.assertEqual([h2], self.loop._scheduled)

self.assertTrue(self.loop._process_events.called)

def test_set_debug(self):

self.loop.set_debug(True)

self.assertTrue(self.loop.get_debug())

self.loop.set_debug(False)

self.assertFalse(self.loop.get_debug())

def test__run_once_schedule_handle(self):

handle = None

processed = False

def cb(loop):

nonlocal processed, handle

processed = True

handle = loop.call_soon(lambda: True)

h = asyncio.TimerHandle(time.monotonic() - 1, cb, (self.loop,),

self.loop, None)

self.loop._process_events = mock.Mock()

self.loop._scheduled.append(h)

self.loop._run_once()

self.assertTrue(processed)

self.assertEqual([handle], list(self.loop._ready))

def test__run_once_cancelled_event_cleanup(self):

self.loop._process_events = mock.Mock()

self.assertTrue(

0 < base_events._MIN_CANCELLED_TIMER_HANDLES_FRACTION < 1.0)

def cb():

pass

# Set up one "blocking" event that will not be cancelled to

# ensure later cancelled events do not make it to the head

# of the queue and get cleaned.

not_cancelled_count = 1

self.loop.call_later(3000, cb)

# Add less than threshold (base_events._MIN_SCHEDULED_TIMER_HANDLES)

# cancelled handles, ensure they aren't removed

cancelled_count = 2

for x in range(2):

h = self.loop.call_later(3600, cb)

h.cancel()

# Add some cancelled events that will be at head and removed

cancelled_count += 2

for x in range(2):

h = self.loop.call_later(100, cb)

h.cancel()

# This test is invalid if _MIN_SCHEDULED_TIMER_HANDLES is too low

self.assertLessEqual(cancelled_count + not_cancelled_count,

base_events._MIN_SCHEDULED_TIMER_HANDLES)

self.assertEqual(self.loop._timer_cancelled_count, cancelled_count)

self.loop._run_once()

cancelled_count -= 2

self.assertEqual(self.loop._timer_cancelled_count, cancelled_count)

self.assertEqual(len(self.loop._scheduled),

cancelled_count + not_cancelled_count)

# Need enough events to pass _MIN_CANCELLED_TIMER_HANDLES_FRACTION

# so that deletion of cancelled events will occur on next _run_once

add_cancel_count = int(math.ceil(

base_events._MIN_SCHEDULED_TIMER_HANDLES *

base_events._MIN_CANCELLED_TIMER_HANDLES_FRACTION)) + 1

add_not_cancel_count = max(base_events._MIN_SCHEDULED_TIMER_HANDLES -

add_cancel_count, 0)

# Add some events that will not be cancelled

not_cancelled_count += add_not_cancel_count

for x in range(add_not_cancel_count):

self.loop.call_later(3600, cb)

# Add enough cancelled events

cancelled_count += add_cancel_count

for x in range(add_cancel_count):

h = self.loop.call_later(3600, cb)

h.cancel()

# Ensure all handles are still scheduled

self.assertEqual(len(self.loop._scheduled),

cancelled_count + not_cancelled_count)

self.loop._run_once()

# Ensure cancelled events were removed

self.assertEqual(len(self.loop._scheduled), not_cancelled_count)

# Ensure only uncancelled events remain scheduled

self.assertTrue(all([not x._cancelled for x in self.loop._scheduled]))

def test_run_until_complete_type_error(self):

self.assertRaises(TypeError,

self.loop.run_until_complete, 'blah')

def test_run_until_complete_loop(self):

task = self.loop.create_future()

other_loop = self.new_test_loop()

self.addCleanup(other_loop.close)

self.assertRaises(ValueError,

other_loop.run_until_complete, task)

def test_run_until_complete_loop_orphan_future_close_loop(self):

class ShowStopper(SystemExit):

pass

async def foo(delay):

await asyncio.sleep(delay)

def throw():

raise ShowStopper

self.loop._process_events = mock.Mock()

self.loop.call_soon(throw)

with self.assertRaises(ShowStopper):

self.loop.run_until_complete(foo(0.1))

# This call fails if run_until_complete does not clean up

# done-callback for the previous future.

self.loop.run_until_complete(foo(0.2))

def test_subprocess_exec_invalid_args(self):

args = [sys.executable, '-c', 'pass']

# missing program parameter (empty args)

self.assertRaises(TypeError,

self.loop.run_until_complete, self.loop.subprocess_exec,

asyncio.SubprocessProtocol)

# expected multiple arguments, not a list

self.assertRaises(TypeError,

self.loop.run_until_complete, self.loop.subprocess_exec,

asyncio.SubprocessProtocol, args)

# program arguments must be strings, not int

self.assertRaises(TypeError,

self.loop.run_until_complete, self.loop.subprocess_exec,

asyncio.SubprocessProtocol, sys.executable, 123)

# universal_newlines, shell, bufsize must not be set

self.assertRaises(TypeError,

self.loop.run_until_complete, self.loop.subprocess_exec,

asyncio.SubprocessProtocol, *args, universal_newlines=True)

self.assertRaises(TypeError,

self.loop.run_until_complete, self.loop.subprocess_exec,

asyncio.SubprocessProtocol, *args, shell=True)

self.assertRaises(TypeError,

self.loop.run_until_complete, self.loop.subprocess_exec,

asyncio.SubprocessProtocol, *args, bufsize=4096)

def test_subprocess_shell_invalid_args(self):

# expected a string, not an int or a list

self.assertRaises(TypeError,

self.loop.run_until_complete, self.loop.subprocess_shell,

asyncio.SubprocessProtocol, 123)

self.assertRaises(TypeError,

self.loop.run_until_complete, self.loop.subprocess_shell,

asyncio.SubprocessProtocol, [sys.executable, '-c', 'pass'])

# universal_newlines, shell, bufsize must not be set

self.assertRaises(TypeError,

self.loop.run_until_complete, self.loop.subprocess_shell,

asyncio.SubprocessProtocol, 'exit 0', universal_newlines=True)

self.assertRaises(TypeError,

self.loop.run_until_complete, self.loop.subprocess_shell,

asyncio.SubprocessProtocol, 'exit 0', shell=True)

self.assertRaises(TypeError,

self.loop.run_until_complete, self.loop.subprocess_shell,

asyncio.SubprocessProtocol, 'exit 0', bufsize=4096)

def test_default_exc_handler_callback(self):

self.loop._process_events = mock.Mock()

def zero_error(fut):

fut.set_result(True)

1/0

# Test call_soon (events.Handle)

with mock.patch('asyncio.base_events.logger') as log:

fut = self.loop.create_future()

self.loop.call_soon(zero_error, fut)

fut.add_done_callback(lambda fut: self.loop.stop())

self.loop.run_forever()

log.error.assert_called_with(

test_utils.MockPattern('Exception in callback.*zero'),

exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY))

# Test call_later (events.TimerHandle)

with mock.patch('asyncio.base_events.logger') as log:

fut = self.loop.create_future()

self.loop.call_later(0.01, zero_error, fut)

fut.add_done_callback(lambda fut: self.loop.stop())

self.loop.run_forever()

log.error.assert_called_with(

test_utils.MockPattern('Exception in callback.*zero'),

exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY))

def test_default_exc_handler_coro(self):

self.loop._process_events = mock.Mock()

async def zero_error_coro():

await asyncio.sleep(0.01)

1/0

# Test Future.__del__

with mock.patch('asyncio.base_events.logger') as log:

fut = asyncio.ensure_future(zero_error_coro(), loop=self.loop)

fut.add_done_callback(lambda *args: self.loop.stop())

self.loop.run_forever()

fut = None # Trigger Future.__del__ or futures._TracebackLogger

support.gc_collect()

# Future.__del__ in logs error with an actual exception context

log.error.assert_called_with(

test_utils.MockPattern('.*exception was never retrieved'),

exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY))

def test_set_exc_handler_invalid(self):

with self.assertRaisesRegex(TypeError, 'A callable object or None'):

self.loop.set_exception_handler('spam')

def test_set_exc_handler_custom(self):

def zero_error():

1/0

def run_loop():

handle = self.loop.call_soon(zero_error)

self.loop._run_once()

return handle

self.loop.set_debug(True)

self.loop._process_events = mock.Mock()

self.assertIsNone(self.loop.get_exception_handler())

mock_handler = mock.Mock()

self.loop.set_exception_handler(mock_handler)

self.assertIs(self.loop.get_exception_handler(), mock_handler)

handle = run_loop()

mock_handler.assert_called_with(self.loop, {

'exception': MOCK_ANY,

'message': test_utils.MockPattern(

'Exception in callback.*zero_error'),

'handle': handle,

'source_traceback': handle._source_traceback,

})

mock_handler.reset_mock()

self.loop.set_exception_handler(None)

with mock.patch('asyncio.base_events.logger') as log:

run_loop()

log.error.assert_called_with(

test_utils.MockPattern(

'Exception in callback.*zero'),

exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY))

self.assertFalse(mock_handler.called)

def test_set_exc_handler_broken(self):

def run_loop():

def zero_error():

1/0

self.loop.call_soon(zero_error)

self.loop._run_once()

def handler(loop, context):

raise AttributeError('spam')

self.loop._process_events = mock.Mock()

self.loop.set_exception_handler(handler)

with mock.patch('asyncio.base_events.logger') as log:

run_loop()

log.error.assert_called_with(

test_utils.MockPattern(

'Unhandled error in exception handler'),

exc_info=(AttributeError, MOCK_ANY, MOCK_ANY))

def test_default_exc_handler_broken(self):

_context = None

class Loop(base_events.BaseEventLoop):

_selector = mock.Mock()

_process_events = mock.Mock()

def default_exception_handler(self, context):

nonlocal _context

_context = context

# Simulates custom buggy "default_exception_handler"

raise ValueError('spam')

loop = Loop()

self.addCleanup(loop.close)

asyncio.set_event_loop(loop)

def run_loop():

def zero_error():

1/0

loop.call_soon(zero_error)

loop._run_once()

with mock.patch('asyncio.base_events.logger') as log:

run_loop()

log.error.assert_called_with(

'Exception in default exception handler',

exc_info=True)

def custom_handler(loop, context):

raise ValueError('ham')

_context = None

loop.set_exception_handler(custom_handler)

with mock.patch('asyncio.base_events.logger') as log:

run_loop()

log.error.assert_called_with(

test_utils.MockPattern('Exception in default exception.*'

'while handling.*in custom'),

exc_info=True)

# Check that original context was passed to default

# exception handler.

self.assertIn('context', _context)

self.assertIs(type(_context['context']['exception']),

ZeroDivisionError)

def test_set_task_factory_invalid(self):

with self.assertRaisesRegex(

TypeError, 'task factory must be a callable or None'):

self.loop.set_task_factory(1)

self.assertIsNone(self.loop.get_task_factory())

def test_set_task_factory(self):

self.loop._process_events = mock.Mock()

class MyTask(asyncio.Task):

pass

async def coro():

pass

factory = lambda loop, coro: MyTask(coro, loop=loop)

self.assertIsNone(self.loop.get_task_factory())

self.loop.set_task_factory(factory)

self.assertIs(self.loop.get_task_factory(), factory)

task = self.loop.create_task(coro())

self.assertTrue(isinstance(task, MyTask))

self.loop.run_until_complete(task)

self.loop.set_task_factory(None)

self.assertIsNone(self.loop.get_task_factory())

task = self.loop.create_task(coro())

self.assertTrue(isinstance(task, asyncio.Task))

self.assertFalse(isinstance(task, MyTask))

self.loop.run_until_complete(task)

def test_env_var_debug(self):

code = '\n'.join((

'import asyncio',

'loop = asyncio.new_event_loop()',

'print(loop.get_debug())'))

# Test with -E to not fail if the unit test was run with

# PYTHONASYNCIODEBUG set to a non-empty string

sts, stdout, stderr = assert_python_ok('-E', '-c', code)

self.assertEqual(stdout.rstrip(), b'False')

sts, stdout, stderr = assert_python_ok('-c', code,

PYTHONASYNCIODEBUG='',

PYTHONDEVMODE='')

self.assertEqual(stdout.rstrip(), b'False')

sts, stdout, stderr = assert_python_ok('-c', code,

PYTHONASYNCIODEBUG='1',

PYTHONDEVMODE='')

self.assertEqual(stdout.rstrip(), b'True')

sts, stdout, stderr = assert_python_ok('-E', '-c', code,

PYTHONASYNCIODEBUG='1')

self.assertEqual(stdout.rstrip(), b'False')

# -X dev

sts, stdout, stderr = assert_python_ok('-E', '-X', 'dev',

'-c', code)

self.assertEqual(stdout.rstrip(), b'True')

def test_create_task(self):

class MyTask(asyncio.Task):

pass

async def test():

pass

class EventLoop(base_events.BaseEventLoop):

def create_task(self, coro):

return MyTask(coro, loop=loop)

loop = EventLoop()

self.set_event_loop(loop)

coro = test()

task = asyncio.ensure_future(coro, loop=loop)

self.assertIsInstance(task, MyTask)

# make warnings quiet

task._log_destroy_pending = False

coro.close()

def test_create_task_error_closes_coro(self):

async def test():

pass

loop = asyncio.new_event_loop()

loop.close()

with warnings.catch_warnings(record=True) as w:

with self.assertRaises(RuntimeError):

asyncio.ensure_future(test(), loop=loop)

self.assertEqual(len(w), 0)

def test_create_named_task_with_default_factory(self):

async def test():

pass

loop = asyncio.new_event_loop()

task = loop.create_task(test(), name='test_task')

try:

self.assertEqual(task.get_name(), 'test_task')

finally:

loop.run_until_complete(task)

loop.close()

def test_create_named_task_with_custom_factory(self):

def task_factory(loop, coro, **kwargs):

return asyncio.Task(coro, loop=loop, **kwargs)

async def test():

pass

loop = asyncio.new_event_loop()

loop.set_task_factory(task_factory)

task = loop.create_task(test(), name='test_task')

try:

self.assertEqual(task.get_name(), 'test_task')

finally:

loop.run_until_complete(task)

loop.close()

def test_run_forever_keyboard_interrupt(self):

# Python issue #22601: ensure that the temporary task created by

# run_forever() consumes the KeyboardInterrupt and so don't log

# a warning

async def raise_keyboard_interrupt():

raise KeyboardInterrupt

self.loop._process_events = mock.Mock()

self.loop.call_exception_handler = mock.Mock()

try:

self.loop.run_until_complete(raise_keyboard_interrupt())

except KeyboardInterrupt:

pass

self.loop.close()

support.gc_collect()

self.assertFalse(self.loop.call_exception_handler.called)

def test_run_until_complete_baseexception(self):

# Python issue #22429: run_until_complete() must not schedule a pending

# call to stop() if the future raised a BaseException

async def raise_keyboard_interrupt():

raise KeyboardInterrupt

self.loop._process_events = mock.Mock()

with self.assertRaises(KeyboardInterrupt):

self.loop.run_until_complete(raise_keyboard_interrupt())

def func():

self.loop.stop()

func.called = True

func.called = False

self.loop.call_soon(self.loop.call_soon, func)

self.loop.run_forever()

self.assertTrue(func.called)

def test_single_selecter_event_callback_after_stopping(self):

# Python issue #25593: A stopped event loop may cause event callbacks

# to run more than once.

event_sentinel = object()

callcount = 0

doer = None

def proc_events(event_list):

nonlocal doer

if event_sentinel in event_list:

doer = self.loop.call_soon(do_event)

def do_event():

nonlocal callcount

callcount += 1

self.loop.call_soon(clear_selector)

def clear_selector():

doer.cancel()

self.loop._selector.select.return_value = ()

self.loop._process_events = proc_events

self.loop._selector.select.return_value = (event_sentinel,)

for i in range(1, 3):

with self.subTest('Loop %d/2' % i):

self.loop.call_soon(self.loop.stop)

self.loop.run_forever()

self.assertEqual(callcount, 1)

def test_run_once(self):

# Simple test for test_utils.run_once(). It may seem strange

# to have a test for this (the function isn't even used!) but

# it's a de-factor standard API for library tests. This tests

# the idiom: loop.call_soon(loop.stop); loop.run_forever().

count = 0

def callback():

nonlocal count

count += 1

self.loop._process_events = mock.Mock()

self.loop.call_soon(callback)

test_utils.run_once(self.loop)

self.assertEqual(count, 1)

def test_run_forever_pre_stopped(self):

# Test that the old idiom for pre-stopping the loop works.

self.loop._process_events = mock.Mock()

self.loop.stop()

self.loop.run_forever()

self.loop._selector.select.assert_called_once_with(0)

def test_custom_run_forever_integration(self):

# Test that the run_forever_setup() and run_forever_cleanup() primitives

# can be used to implement a custom run_forever loop.

self.loop._process_events = mock.Mock()

count = 0

def callback():

nonlocal count

count += 1

self.loop.call_soon(callback)

# Set up the custom event loop

self.loop._run_forever_setup()

# Confirm the loop has been started

self.assertEqual(asyncio.get_running_loop(), self.loop)

self.assertTrue(self.loop.is_running())

# Our custom "event loop" just iterates 10 times before exiting.

for i in range(10):

self.loop._run_once()

# Clean up the event loop

self.loop._run_forever_cleanup()