test_locks.py

"""Tests for lock.py"""

importunittest
fromunittestimportmock
importre

importasyncio
fromtest.test_asyncioimportutilsastest_utils

STR_RGX_REPR= (
r'^<(?P<class>.*?) object at (?P<address>.*?)'
r'\[(?P<extras>'
r'(set|unset|locked|unlocked)(, value:\d)?(, waiters:\d+)?'
r')\]>\Z'
)
RGX_REPR=re.compile(STR_RGX_REPR)


classLockTests(test_utils.TestCase):

defsetUp(self):
super().setUp()
self.loop=self.new_test_loop()

deftest_ctor_loop(self):
loop=mock.Mock()
lock=asyncio.Lock(loop=loop)
self.assertIs(lock._loop, loop)

lock=asyncio.Lock(loop=self.loop)
self.assertIs(lock._loop, self.loop)

deftest_ctor_noloop(self):
asyncio.set_event_loop(self.loop)
lock=asyncio.Lock()
self.assertIs(lock._loop, self.loop)

deftest_repr(self):
lock=asyncio.Lock(loop=self.loop)
self.assertTrue(repr(lock).endswith('[unlocked]>'))
self.assertTrue(RGX_REPR.match(repr(lock)))

@asyncio.coroutine
defacquire_lock():
withself.assertWarns(DeprecationWarning):
yieldfromlock

self.loop.run_until_complete(acquire_lock())
self.assertTrue(repr(lock).endswith('[locked]>'))
self.assertTrue(RGX_REPR.match(repr(lock)))

deftest_lock(self):
lock=asyncio.Lock(loop=self.loop)

@asyncio.coroutine
defacquire_lock():
withself.assertWarns(DeprecationWarning):
return (yieldfromlock)

res=self.loop.run_until_complete(acquire_lock())

self.assertTrue(res)
self.assertTrue(lock.locked())

lock.release()
self.assertFalse(lock.locked())

deftest_lock_by_with_statement(self):
loop=asyncio.new_event_loop() # don't use TestLoop quirks
self.set_event_loop(loop)
primitives= [
asyncio.Lock(loop=loop),
asyncio.Condition(loop=loop),
asyncio.Semaphore(loop=loop),
asyncio.BoundedSemaphore(loop=loop),
 ]

@asyncio.coroutine
deftest(lock):
yieldfromasyncio.sleep(0.01, loop=loop)
self.assertFalse(lock.locked())
withself.assertWarns(DeprecationWarning):
with (yieldfromlock) as_lock:
self.assertIs(_lock, None)
self.assertTrue(lock.locked())
yieldfromasyncio.sleep(0.01, loop=loop)
self.assertTrue(lock.locked())
self.assertFalse(lock.locked())

forprimitiveinprimitives:
loop.run_until_complete(test(primitive))
self.assertFalse(primitive.locked())

deftest_acquire(self):
lock=asyncio.Lock(loop=self.loop)
result= []

self.assertTrue(self.loop.run_until_complete(lock.acquire()))

asyncdefc1(result):
ifawaitlock.acquire():
result.append(1)
returnTrue

asyncdefc2(result):
ifawaitlock.acquire():
result.append(2)
returnTrue

asyncdefc3(result):
ifawaitlock.acquire():
result.append(3)
returnTrue

t1=asyncio.Task(c1(result), loop=self.loop)
t2=asyncio.Task(c2(result), loop=self.loop)

test_utils.run_briefly(self.loop)
self.assertEqual([], result)

lock.release()
test_utils.run_briefly(self.loop)
self.assertEqual([1], result)

test_utils.run_briefly(self.loop)
self.assertEqual([1], result)

t3=asyncio.Task(c3(result), loop=self.loop)

lock.release()
test_utils.run_briefly(self.loop)
self.assertEqual([1, 2], result)

lock.release()
test_utils.run_briefly(self.loop)
self.assertEqual([1, 2, 3], result)

self.assertTrue(t1.done())
self.assertTrue(t1.result())
self.assertTrue(t2.done())
self.assertTrue(t2.result())
self.assertTrue(t3.done())
self.assertTrue(t3.result())

deftest_acquire_cancel(self):
lock=asyncio.Lock(loop=self.loop)
self.assertTrue(self.loop.run_until_complete(lock.acquire()))

task=asyncio.Task(lock.acquire(), loop=self.loop)
self.loop.call_soon(task.cancel)
self.assertRaises(
asyncio.CancelledError,
self.loop.run_until_complete, task)
self.assertFalse(lock._waiters)

deftest_cancel_race(self):
# Several tasks:
# - A acquires the lock
# - B is blocked in acquire()
# - C is blocked in acquire()
#
# Now, concurrently:
# - B is cancelled
# - A releases the lock
#
# If B's waiter is marked cancelled but not yet removed from
# _waiters, A's release() call will crash when trying to set
# B's waiter; instead, it should move on to C's waiter.

# Setup: A has the lock, b and c are waiting.
lock=asyncio.Lock(loop=self.loop)

asyncdeflockit(name, blocker):
awaitlock.acquire()
try:
ifblockerisnotNone:
awaitblocker
finally:
lock.release()

fa=asyncio.Future(loop=self.loop)
ta=asyncio.Task(lockit('A', fa), loop=self.loop)
test_utils.run_briefly(self.loop)
self.assertTrue(lock.locked())
tb=asyncio.Task(lockit('B', None), loop=self.loop)
test_utils.run_briefly(self.loop)
self.assertEqual(len(lock._waiters), 1)
tc=asyncio.Task(lockit('C', None), loop=self.loop)
test_utils.run_briefly(self.loop)
self.assertEqual(len(lock._waiters), 2)

# Create the race and check.
# Without the fix this failed at the last assert.
fa.set_result(None)
tb.cancel()
self.assertTrue(lock._waiters[0].cancelled())
test_utils.run_briefly(self.loop)
self.assertFalse(lock.locked())
self.assertTrue(ta.done())
self.assertTrue(tb.cancelled())
self.assertTrue(tc.done())

deftest_cancel_release_race(self):
# Issue 32734
# Acquire 4 locks, cancel second, release first
# and 2 locks are taken at once.
lock=asyncio.Lock(loop=self.loop)
lock_count=0
call_count=0

asyncdeflockit():
nonlocallock_count
nonlocalcall_count
call_count+=1
awaitlock.acquire()
lock_count+=1

asyncdeflockandtrigger():
awaitlock.acquire()
self.loop.call_soon(trigger)

deftrigger():
t1.cancel()
lock.release()

t0=self.loop.create_task(lockandtrigger())
t1=self.loop.create_task(lockit())
t2=self.loop.create_task(lockit())
t3=self.loop.create_task(lockit())

# First loop acquires all
test_utils.run_briefly(self.loop)
self.assertTrue(t0.done())

# Second loop calls trigger
test_utils.run_briefly(self.loop)
# Third loop calls cancellation
test_utils.run_briefly(self.loop)

# Make sure only one lock was taken
self.assertEqual(lock_count, 1)
# While 3 calls were made to lockit()
self.assertEqual(call_count, 3)
self.assertTrue(t1.cancelled() andt2.done())

# Cleanup the task that is stuck on acquire.
t3.cancel()
test_utils.run_briefly(self.loop)
self.assertTrue(t3.cancelled())

deftest_finished_waiter_cancelled(self):
lock=asyncio.Lock(loop=self.loop)

ta=asyncio.Task(lock.acquire(), loop=self.loop)
test_utils.run_briefly(self.loop)
self.assertTrue(lock.locked())

tb=asyncio.Task(lock.acquire(), loop=self.loop)
test_utils.run_briefly(self.loop)
self.assertEqual(len(lock._waiters), 1)

# Create a second waiter, wake up the first, and cancel it.
# Without the fix, the second was not woken up.
tc=asyncio.Task(lock.acquire(), loop=self.loop)
lock.release()
tb.cancel()
test_utils.run_briefly(self.loop)

self.assertTrue(lock.locked())
self.assertTrue(ta.done())
self.assertTrue(tb.cancelled())

deftest_release_not_acquired(self):
lock=asyncio.Lock(loop=self.loop)

self.assertRaises(RuntimeError, lock.release)

deftest_release_no_waiters(self):
lock=asyncio.Lock(loop=self.loop)
self.loop.run_until_complete(lock.acquire())
self.assertTrue(lock.locked())

lock.release()
self.assertFalse(lock.locked())

deftest_context_manager(self):
lock=asyncio.Lock(loop=self.loop)

@asyncio.coroutine
defacquire_lock():
withself.assertWarns(DeprecationWarning):
return (yieldfromlock)

withself.loop.run_until_complete(acquire_lock()):
self.assertTrue(lock.locked())

self.assertFalse(lock.locked())

deftest_context_manager_cant_reuse(self):
lock=asyncio.Lock(loop=self.loop)

@asyncio.coroutine
defacquire_lock():
withself.assertWarns(DeprecationWarning):
return (yieldfromlock)

# This spells "yield from lock" outside a generator.
cm=self.loop.run_until_complete(acquire_lock())
withcm:
self.assertTrue(lock.locked())

self.assertFalse(lock.locked())

withself.assertRaises(AttributeError):
withcm:
pass

deftest_context_manager_no_yield(self):
lock=asyncio.Lock(loop=self.loop)

try:
withlock:
self.fail('RuntimeError is not raised in with expression')
exceptRuntimeErroraserr:
self.assertEqual(
str(err),
'"yield from" should be used as context manager expression')

self.assertFalse(lock.locked())


classEventTests(test_utils.TestCase):

defsetUp(self):
super().setUp()
self.loop=self.new_test_loop()

deftest_ctor_loop(self):
loop=mock.Mock()
ev=asyncio.Event(loop=loop)
self.assertIs(ev._loop, loop)

ev=asyncio.Event(loop=self.loop)
self.assertIs(ev._loop, self.loop)

deftest_ctor_noloop(self):
asyncio.set_event_loop(self.loop)
ev=asyncio.Event()
self.assertIs(ev._loop, self.loop)

deftest_repr(self):
ev=asyncio.Event(loop=self.loop)
self.assertTrue(repr(ev).endswith('[unset]>'))
match=RGX_REPR.match(repr(ev))
self.assertEqual(match.group('extras'), 'unset')

ev.set()
self.assertTrue(repr(ev).endswith('[set]>'))
self.assertTrue(RGX_REPR.match(repr(ev)))

ev._waiters.append(mock.Mock())
self.assertTrue('waiters:1'inrepr(ev))
self.assertTrue(RGX_REPR.match(repr(ev)))

deftest_wait(self):
ev=asyncio.Event(loop=self.loop)
self.assertFalse(ev.is_set())

result= []

asyncdefc1(result):
ifawaitev.wait():
result.append(1)

asyncdefc2(result):
ifawaitev.wait():
result.append(2)

asyncdefc3(result):
ifawaitev.wait():
result.append(3)

t1=asyncio.Task(c1(result), loop=self.loop)
t2=asyncio.Task(c2(result), loop=self.loop)

test_utils.run_briefly(self.loop)
self.assertEqual([], result)

t3=asyncio.Task(c3(result), loop=self.loop)

ev.set()
test_utils.run_briefly(self.loop)
self.assertEqual([3, 1, 2], result)

self.assertTrue(t1.done())
self.assertIsNone(t1.result())
self.assertTrue(t2.done())
self.assertIsNone(t2.result())
self.assertTrue(t3.done())
self.assertIsNone(t3.result())

deftest_wait_on_set(self):
ev=asyncio.Event(loop=self.loop)
ev.set()

res=self.loop.run_until_complete(ev.wait())
self.assertTrue(res)

deftest_wait_cancel(self):
ev=asyncio.Event(loop=self.loop)

wait=asyncio.Task(ev.wait(), loop=self.loop)
self.loop.call_soon(wait.cancel)
self.assertRaises(
asyncio.CancelledError,
self.loop.run_until_complete, wait)
self.assertFalse(ev._waiters)

deftest_clear(self):
ev=asyncio.Event(loop=self.loop)
self.assertFalse(ev.is_set())

ev.set()
self.assertTrue(ev.is_set())

ev.clear()
self.assertFalse(ev.is_set())

deftest_clear_with_waiters(self):
ev=asyncio.Event(loop=self.loop)
result= []

asyncdefc1(result):
ifawaitev.wait():
result.append(1)
returnTrue

t=asyncio.Task(c1(result), loop=self.loop)
test_utils.run_briefly(self.loop)
self.assertEqual([], result)

ev.set()
ev.clear()
self.assertFalse(ev.is_set())

ev.set()
ev.set()
self.assertEqual(1, len(ev._waiters))

test_utils.run_briefly(self.loop)
self.assertEqual([1], result)
self.assertEqual(0, len(ev._waiters))

self.assertTrue(t.done())
self.assertTrue(t.result())


classConditionTests(test_utils.TestCase):

defsetUp(self):
super().setUp()
self.loop=self.new_test_loop()

deftest_ctor_loop(self):
loop=mock.Mock()
cond=asyncio.Condition(loop=loop)
self.assertIs(cond._loop, loop)

cond=asyncio.Condition(loop=self.loop)
self.assertIs(cond._loop, self.loop)

deftest_ctor_noloop(self):
asyncio.set_event_loop(self.loop)
cond=asyncio.Condition()
self.assertIs(cond._loop, self.loop)

deftest_wait(self):
cond=asyncio.Condition(loop=self.loop)
result= []

asyncdefc1(result):
awaitcond.acquire()
ifawaitcond.wait():
result.append(1)
returnTrue

asyncdefc2(result):
awaitcond.acquire()
ifawaitcond.wait():
result.append(2)
returnTrue

asyncdefc3(result):
awaitcond.acquire()
ifawaitcond.wait():
result.append(3)
returnTrue

t1=asyncio.Task(c1(result), loop=self.loop)
t2=asyncio.Task(c2(result), loop=self.loop)
t3=asyncio.Task(c3(result), loop=self.loop)

test_utils.run_briefly(self.loop)
self.assertEqual([], result)
self.assertFalse(cond.locked())

self.assertTrue(self.loop.run_until_complete(cond.acquire()))
cond.notify()
test_utils.run_briefly(self.loop)
self.assertEqual([], result)
self.assertTrue(cond.locked())

cond.release()
test_utils.run_briefly(self.loop)
self.assertEqual([1], result)
self.assertTrue(cond.locked())

cond.notify(2)
test_utils.run_briefly(self.loop)
self.assertEqual([1], result)
self.assertTrue(cond.locked())

cond.release()
test_utils.run_briefly(self.loop)
self.assertEqual([1, 2], result)
self.assertTrue(cond.locked())

cond.release()
test_utils.run_briefly(self.loop)
self.assertEqual([1, 2, 3], result)
self.assertTrue(cond.locked())

self.assertTrue(t1.done())
self.assertTrue(t1.result())
self.assertTrue(t2.done())
self.assertTrue(t2.result())
self.assertTrue(t3.done())
self.assertTrue(t3.result())

deftest_wait_cancel(self):
cond=asyncio.Condition(loop=self.loop)
self.loop.run_until_complete(cond.acquire())

wait=asyncio.Task(cond.wait(), loop=self.loop)
self.loop.call_soon(wait.cancel)
self.assertRaises(
asyncio.CancelledError,
self.loop.run_until_complete, wait)
self.assertFalse(cond._waiters)
self.assertTrue(cond.locked())

deftest_wait_cancel_contested(self):
cond=asyncio.Condition(loop=self.loop)

self.loop.run_until_complete(cond.acquire())
self.assertTrue(cond.locked())

wait_task=asyncio.Task(cond.wait(), loop=self.loop)
test_utils.run_briefly(self.loop)
self.assertFalse(cond.locked())

# Notify, but contest the lock before cancelling
self.loop.run_until_complete(cond.acquire())
self.assertTrue(cond.locked())
cond.notify()
self.loop.call_soon(wait_task.cancel)
self.loop.call_soon(cond.release)

try:
self.loop.run_until_complete(wait_task)
exceptasyncio.CancelledError:
# Should not happen, since no cancellation points
pass

self.assertTrue(cond.locked())

deftest_wait_cancel_after_notify(self):
# See bpo-32841
cond=asyncio.Condition(loop=self.loop)
waited=False

asyncdefwait_on_cond():
nonlocalwaited
asyncwithcond:
waited=True# Make sure this area was reached
awaitcond.wait()

waiter=asyncio.ensure_future(wait_on_cond(), loop=self.loop)
test_utils.run_briefly(self.loop) # Start waiting

self.loop.run_until_complete(cond.acquire())
cond.notify()
test_utils.run_briefly(self.loop) # Get to acquire()
waiter.cancel()
test_utils.run_briefly(self.loop) # Activate cancellation
cond.release()
test_utils.run_briefly(self.loop) # Cancellation should occur

self.assertTrue(waiter.cancelled())
self.assertTrue(waited)

deftest_wait_unacquired(self):
cond=asyncio.Condition(loop=self.loop)
self.assertRaises(
RuntimeError,
self.loop.run_until_complete, cond.wait())

deftest_wait_for(self):
cond=asyncio.Condition(loop=self.loop)
presult=False

defpredicate():
returnpresult

result= []

asyncdefc1(result):
awaitcond.acquire()
ifawaitcond.wait_for(predicate):
result.append(1)
cond.release()
returnTrue

t=asyncio.Task(c1(result), loop=self.loop)

test_utils.run_briefly(self.loop)
self.assertEqual([], result)

self.loop.run_until_complete(cond.acquire())
cond.notify()
cond.release()
test_utils.run_briefly(self.loop)
self.assertEqual([], result)

presult=True
self.loop.run_until_complete(cond.acquire())
cond.notify()
cond.release()
test_utils.run_briefly(self.loop)
self.assertEqual([1], result)

self.assertTrue(t.done())
self.assertTrue(t.result())

deftest_wait_for_unacquired(self):
cond=asyncio.Condition(loop=self.loop)

# predicate can return true immediately
res=self.loop.run_until_complete(cond.wait_for(lambda: [1, 2, 3]))
self.assertEqual([1, 2, 3], res)

self.assertRaises(
RuntimeError,
self.loop.run_until_complete,
cond.wait_for(lambda: False))

deftest_notify(self):
cond=asyncio.Condition(loop=self.loop)
result= []

asyncdefc1(result):
awaitcond.acquire()
ifawaitcond.wait():
result.append(1)
cond.release()
returnTrue

asyncdefc2(result):
awaitcond.acquire()
ifawaitcond.wait():
result.append(2)
cond.release()
returnTrue

asyncdefc3(result):
awaitcond.acquire()
ifawaitcond.wait():
result.append(3)
cond.release()
returnTrue

t1=asyncio.Task(c1(result), loop=self.loop)
t2=asyncio.Task(c2(result), loop=self.loop)
t3=asyncio.Task(c3(result), loop=self.loop)

test_utils.run_briefly(self.loop)
self.assertEqual([], result)

self.loop.run_until_complete(cond.acquire())
cond.notify(1)
cond.release()
test_utils.run_briefly(self.loop)
self.assertEqual([1], result)

self.loop.run_until_complete(cond.acquire())
cond.notify(1)
cond.notify(2048)
cond.release()
test_utils.run_briefly(self.loop)
self.assertEqual([1, 2, 3], result)

self.assertTrue(t1.done())
self.assertTrue(t1.result())
self.assertTrue(t2.done())
self.assertTrue(t2.result())
self.assertTrue(t3.done())
self.assertTrue(t3.result())

deftest_notify_all(self):
cond=asyncio.Condition(loop=self.loop)

result= []

asyncdefc1(result):
awaitcond.acquire()
ifawaitcond.wait():
result.append(1)
cond.release()
returnTrue

asyncdefc2(result):
awaitcond.acquire()
ifawaitcond.wait():
result.append(2)
cond.release()
returnTrue

t1=asyncio.Task(c1(result), loop=self.loop)
t2=asyncio.Task(c2(result), loop=self.loop)

test_utils.run_briefly(self.loop)
self.assertEqual([], result)

self.loop.run_until_complete(cond.acquire())
cond.notify_all()
cond.release()
test_utils.run_briefly(self.loop)
self.assertEqual([1, 2], result)

self.assertTrue(t1.done())
self.assertTrue(t1.result())
self.assertTrue(t2.done())
self.assertTrue(t2.result())

deftest_notify_unacquired(self):
cond=asyncio.Condition(loop=self.loop)
self.assertRaises(RuntimeError, cond.notify)

deftest_notify_all_unacquired(self):
cond=asyncio.Condition(loop=self.loop)
self.assertRaises(RuntimeError, cond.notify_all)

deftest_repr(self):
cond=asyncio.Condition(loop=self.loop)
self.assertTrue('unlocked'inrepr(cond))
self.assertTrue(RGX_REPR.match(repr(cond)))

self.loop.run_until_complete(cond.acquire())
self.assertTrue('locked'inrepr(cond))

cond._waiters.append(mock.Mock())
self.assertTrue('waiters:1'inrepr(cond))
self.assertTrue(RGX_REPR.match(repr(cond)))

cond._waiters.append(mock.Mock())
self.assertTrue('waiters:2'inrepr(cond))
self.assertTrue(RGX_REPR.match(repr(cond)))

deftest_context_manager(self):
cond=asyncio.Condition(loop=self.loop)

@asyncio.coroutine
defacquire_cond():
withself.assertWarns(DeprecationWarning):
return (yieldfromcond)

withself.loop.run_until_complete(acquire_cond()):
self.assertTrue(cond.locked())

self.assertFalse(cond.locked())

deftest_context_manager_no_yield(self):
cond=asyncio.Condition(loop=self.loop)

try:
withcond:
self.fail('RuntimeError is not raised in with expression')
exceptRuntimeErroraserr:
self.assertEqual(
str(err),
'"yield from" should be used as context manager expression')

self.assertFalse(cond.locked())

deftest_explicit_lock(self):
lock=asyncio.Lock(loop=self.loop)
cond=asyncio.Condition(lock, loop=self.loop)

self.assertIs(cond._lock, lock)
self.assertIs(cond._loop, lock._loop)

deftest_ambiguous_loops(self):
loop=self.new_test_loop()
self.addCleanup(loop.close)

lock=asyncio.Lock(loop=self.loop)
withself.assertRaises(ValueError):
asyncio.Condition(lock, loop=loop)

deftest_timeout_in_block(self):
loop=asyncio.new_event_loop()
self.addCleanup(loop.close)

asyncdeftask_timeout():
condition=asyncio.Condition(loop=loop)
asyncwithcondition:
withself.assertRaises(asyncio.TimeoutError):
awaitasyncio.wait_for(condition.wait(), timeout=0.5,
loop=loop)

loop.run_until_complete(task_timeout())


classSemaphoreTests(test_utils.TestCase):

defsetUp(self):
super().setUp()
self.loop=self.new_test_loop()

deftest_ctor_loop(self):
loop=mock.Mock()
sem=asyncio.Semaphore(loop=loop)
self.assertIs(sem._loop, loop)

sem=asyncio.Semaphore(loop=self.loop)
self.assertIs(sem._loop, self.loop)

deftest_ctor_noloop(self):
asyncio.set_event_loop(self.loop)
sem=asyncio.Semaphore()
self.assertIs(sem._loop, self.loop)

deftest_initial_value_zero(self):
sem=asyncio.Semaphore(0, loop=self.loop)
self.assertTrue(sem.locked())

deftest_repr(self):
sem=asyncio.Semaphore(loop=self.loop)
self.assertTrue(repr(sem).endswith('[unlocked, value:1]>'))
self.assertTrue(RGX_REPR.match(repr(sem)))

self.loop.run_until_complete(sem.acquire())
self.assertTrue(repr(sem).endswith('[locked]>'))
self.assertTrue('waiters'notinrepr(sem))
self.assertTrue(RGX_REPR.match(repr(sem)))

sem._waiters.append(mock.Mock())
self.assertTrue('waiters:1'inrepr(sem))
self.assertTrue(RGX_REPR.match(repr(sem)))

sem._waiters.append(mock.Mock())
self.assertTrue('waiters:2'inrepr(sem))
self.assertTrue(RGX_REPR.match(repr(sem)))

deftest_semaphore(self):
sem=asyncio.Semaphore(loop=self.loop)
self.assertEqual(1, sem._value)

@asyncio.coroutine
defacquire_lock():
withself.assertWarns(DeprecationWarning):
return (yieldfromsem)

res=self.loop.run_until_complete(acquire_lock())

self.assertTrue(res)
self.assertTrue(sem.locked())
self.assertEqual(0, sem._value)

sem.release()
self.assertFalse(sem.locked())
self.assertEqual(1, sem._value)

deftest_semaphore_value(self):
self.assertRaises(ValueError, asyncio.Semaphore, -1)

deftest_acquire(self):
sem=asyncio.Semaphore(3, loop=self.loop)
result= []

self.assertTrue(self.loop.run_until_complete(sem.acquire()))
self.assertTrue(self.loop.run_until_complete(sem.acquire()))
self.assertFalse(sem.locked())

asyncdefc1(result):
awaitsem.acquire()
result.append(1)
returnTrue

asyncdefc2(result):
awaitsem.acquire()
result.append(2)
returnTrue

asyncdefc3(result):
awaitsem.acquire()
result.append(3)
returnTrue

asyncdefc4(result):
awaitsem.acquire()
result.append(4)
returnTrue

t1=asyncio.Task(c1(result), loop=self.loop)
t2=asyncio.Task(c2(result), loop=self.loop)
t3=asyncio.Task(c3(result), loop=self.loop)

test_utils.run_briefly(self.loop)
self.assertEqual([1], result)
self.assertTrue(sem.locked())
self.assertEqual(2, len(sem._waiters))
self.assertEqual(0, sem._value)

t4=asyncio.Task(c4(result), loop=self.loop)

sem.release()
sem.release()
self.assertEqual(2, sem._value)

test_utils.run_briefly(self.loop)
self.assertEqual(0, sem._value)
self.assertEqual(3, len(result))
self.assertTrue(sem.locked())
self.assertEqual(1, len(sem._waiters))
self.assertEqual(0, sem._value)

self.assertTrue(t1.done())
self.assertTrue(t1.result())
race_tasks= [t2, t3, t4]
done_tasks= [tfortinrace_tasksift.done() andt.result()]
self.assertTrue(2, len(done_tasks))

# cleanup locked semaphore
sem.release()
self.loop.run_until_complete(asyncio.gather(*race_tasks))

deftest_acquire_cancel(self):
sem=asyncio.Semaphore(loop=self.loop)
self.loop.run_until_complete(sem.acquire())

acquire=asyncio.Task(sem.acquire(), loop=self.loop)
self.loop.call_soon(acquire.cancel)
self.assertRaises(
asyncio.CancelledError,
self.loop.run_until_complete, acquire)
self.assertTrue((notsem._waiters) or
all(waiter.done() forwaiterinsem._waiters))

deftest_acquire_cancel_before_awoken(self):
sem=asyncio.Semaphore(value=0, loop=self.loop)

t1=asyncio.Task(sem.acquire(), loop=self.loop)
t2=asyncio.Task(sem.acquire(), loop=self.loop)
t3=asyncio.Task(sem.acquire(), loop=self.loop)
t4=asyncio.Task(sem.acquire(), loop=self.loop)

test_utils.run_briefly(self.loop)

sem.release()
t1.cancel()
t2.cancel()

test_utils.run_briefly(self.loop)
num_done=sum(t.done() fortin [t3, t4])
self.assertEqual(num_done, 1)

t3.cancel()
t4.cancel()
test_utils.run_briefly(self.loop)

deftest_acquire_hang(self):
sem=asyncio.Semaphore(value=0, loop=self.loop)

t1=asyncio.Task(sem.acquire(), loop=self.loop)
t2=asyncio.Task(sem.acquire(), loop=self.loop)

test_utils.run_briefly(self.loop)

sem.release()
t1.cancel()

test_utils.run_briefly(self.loop)
self.assertTrue(sem.locked())

deftest_release_not_acquired(self):
sem=asyncio.BoundedSemaphore(loop=self.loop)

self.assertRaises(ValueError, sem.release)