Da

✏️ Editing: test_locks.py

"""Tests for lock.py"""

import unittest
from unittest import mock
import re

import asyncio
import collections

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)

def tearDownModule():
    asyncio.set_event_loop_policy(None)

class LockTests(unittest.IsolatedAsyncioTestCase):

async def test_repr(self):
        lock = asyncio.Lock()
        self.assertTrue(repr(lock).endswith('[unlocked]>'))
        self.assertTrue(RGX_REPR.match(repr(lock)))

await lock.acquire()
        self.assertTrue(repr(lock).endswith('[locked]>'))
        self.assertTrue(RGX_REPR.match(repr(lock)))

async def test_lock(self):
        lock = asyncio.Lock()

with self.assertWarns(DeprecationWarning):
            @asyncio.coroutine
            def acquire_lock():
                return (yield from lock)

with self.assertRaisesRegex(
            TypeError,
            "object is not iterable"
        ):
            await acquire_lock()

self.assertFalse(lock.locked())

async def test_lock_doesnt_accept_loop_parameter(self):
        primitives_cls = [
            asyncio.Lock,
            asyncio.Condition,
            asyncio.Event,
            asyncio.Semaphore,
            asyncio.BoundedSemaphore,
        ]

loop = asyncio.get_running_loop()

for cls in primitives_cls:
            with self.assertRaisesRegex(
                TypeError,
                rf'As of 3.10, the \*loop\* parameter was removed from '
                rf'{cls.__name__}\(\) since it is no longer necessary'
            ):
                cls(loop=loop)

async def test_lock_by_with_statement(self):
        primitives = [
            asyncio.Lock(),
            asyncio.Condition(),
            asyncio.Semaphore(),
            asyncio.BoundedSemaphore(),
        ]

with self.assertWarns(DeprecationWarning):
            @asyncio.coroutine
            def test(lock):
                yield from asyncio.sleep(0.01)
                self.assertFalse(lock.locked())
                with self.assertRaisesRegex(
                    TypeError,
                    "object is not iterable"
                ):
                    with (yield from lock):
                        pass
                self.assertFalse(lock.locked())

for lock in primitives:
            await test(lock)
            self.assertFalse(lock.locked())

async def test_acquire(self):
        lock = asyncio.Lock()
        result = []

self.assertTrue(await lock.acquire())

async def c1(result):
            if await lock.acquire():
                result.append(1)
            return True

async def c2(result):
            if await lock.acquire():
                result.append(2)
            return True

async def c3(result):
            if await lock.acquire():
                result.append(3)
            return True

t1 = asyncio.create_task(c1(result))
        t2 = asyncio.create_task(c2(result))

await asyncio.sleep(0)
        self.assertEqual([], result)

lock.release()
        await asyncio.sleep(0)
        self.assertEqual([1], result)

await asyncio.sleep(0)
        self.assertEqual([1], result)

t3 = asyncio.create_task(c3(result))

lock.release()
        await asyncio.sleep(0)
        self.assertEqual([1, 2], result)

lock.release()
        await asyncio.sleep(0)
        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())

async def test_acquire_cancel(self):
        lock = asyncio.Lock()
        self.assertTrue(await lock.acquire())

task = asyncio.create_task(lock.acquire())
        asyncio.get_running_loop().call_soon(task.cancel)
        with self.assertRaises(asyncio.CancelledError):
            await task
        self.assertFalse(lock._waiters)

async def test_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()

async def lockit(name, blocker):
            await lock.acquire()
            try:
                if blocker is not None:
                    await blocker
            finally:
                lock.release()

fa = asyncio.get_running_loop().create_future()
        ta = asyncio.create_task(lockit('A', fa))
        await asyncio.sleep(0)
        self.assertTrue(lock.locked())
        tb = asyncio.create_task(lockit('B', None))
        await asyncio.sleep(0)
        self.assertEqual(len(lock._waiters), 1)
        tc = asyncio.create_task(lockit('C', None))
        await asyncio.sleep(0)
        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())
        await asyncio.sleep(0)
        self.assertFalse(lock.locked())
        self.assertTrue(ta.done())
        self.assertTrue(tb.cancelled())
        await tc

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

async def lockit():
            nonlocal lock_count
            nonlocal call_count
            call_count += 1
            await lock.acquire()
            lock_count += 1

def trigger():
            t1.cancel()
            lock.release()

await lock.acquire()

t1 = asyncio.create_task(lockit())
        t2 = asyncio.create_task(lockit())
        t3 = asyncio.create_task(lockit())

# Start scheduled tasks
        await asyncio.sleep(0)

loop.call_soon(trigger)
        with self.assertRaises(asyncio.CancelledError):
            # Wait for cancellation
            await t1

# 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() and t2.done())

# Cleanup the task that is stuck on acquire.
        t3.cancel()
        await asyncio.sleep(0)
        self.assertTrue(t3.cancelled())

async def test_finished_waiter_cancelled(self):
        lock = asyncio.Lock()

await lock.acquire()
        self.assertTrue(lock.locked())

tb = asyncio.create_task(lock.acquire())
        await asyncio.sleep(0)
        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.create_task(lock.acquire())
        tb.cancel()
        lock.release()
        await asyncio.sleep(0)

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

# Cleanup
        await tc

async def test_release_not_acquired(self):
        lock = asyncio.Lock()

self.assertRaises(RuntimeError, lock.release)

async def test_release_no_waiters(self):
        lock = asyncio.Lock()
        await lock.acquire()
        self.assertTrue(lock.locked())

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

async def test_context_manager(self):
        lock = asyncio.Lock()
        self.assertFalse(lock.locked())

async with lock:
            self.assertTrue(lock.locked())

self.assertFalse(lock.locked())

class EventTests(unittest.IsolatedAsyncioTestCase):

def test_repr(self):
        ev = asyncio.Event()
        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' in repr(ev))
        self.assertTrue(RGX_REPR.match(repr(ev)))

async def test_wait(self):
        ev = asyncio.Event()
        self.assertFalse(ev.is_set())

result = []

async def c1(result):
            if await ev.wait():
                result.append(1)

async def c2(result):
            if await ev.wait():
                result.append(2)

async def c3(result):
            if await ev.wait():
                result.append(3)

t1 = asyncio.create_task(c1(result))
        t2 = asyncio.create_task(c2(result))

await asyncio.sleep(0)
        self.assertEqual([], result)

t3 = asyncio.create_task(c3(result))

ev.set()
        await asyncio.sleep(0)
        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())

async def test_wait_on_set(self):
        ev = asyncio.Event()
        ev.set()

res = await ev.wait()
        self.assertTrue(res)

async def test_wait_cancel(self):
        ev = asyncio.Event()

wait = asyncio.create_task(ev.wait())
        asyncio.get_running_loop().call_soon(wait.cancel)
        with self.assertRaises(asyncio.CancelledError):
            await wait
        self.assertFalse(ev._waiters)

async def test_clear(self):
        ev = asyncio.Event()
        self.assertFalse(ev.is_set())

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

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

async def test_clear_with_waiters(self):
        ev = asyncio.Event()
        result = []

async def c1(result):
            if await ev.wait():
                result.append(1)
            return True

t = asyncio.create_task(c1(result))
        await asyncio.sleep(0)
        self.assertEqual([], result)

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

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

await asyncio.sleep(0)
        self.assertEqual([1], result)
        self.assertEqual(0, len(ev._waiters))

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

class ConditionTests(unittest.IsolatedAsyncioTestCase):

async def test_wait(self):
        cond = asyncio.Condition()
        result = []

async def c1(result):
            await cond.acquire()
            if await cond.wait():
                result.append(1)
            return True

async def c2(result):
            await cond.acquire()
            if await cond.wait():
                result.append(2)
            return True

async def c3(result):
            await cond.acquire()
            if await cond.wait():
                result.append(3)
            return True

t1 = asyncio.create_task(c1(result))
        t2 = asyncio.create_task(c2(result))
        t3 = asyncio.create_task(c3(result))

await asyncio.sleep(0)
        self.assertEqual([], result)
        self.assertFalse(cond.locked())

self.assertTrue(await cond.acquire())
        cond.notify()
        await asyncio.sleep(0)
        self.assertEqual([], result)
        self.assertTrue(cond.locked())

cond.release()
        await asyncio.sleep(0)
        self.assertEqual([1], result)
        self.assertTrue(cond.locked())

cond.notify(2)
        await asyncio.sleep(0)
        self.assertEqual([1], result)
        self.assertTrue(cond.locked())

cond.release()
        await asyncio.sleep(0)
        self.assertEqual([1, 2], result)
        self.assertTrue(cond.locked())

cond.release()
        await asyncio.sleep(0)
        self.assertEqual([1, 2, 3], result)
        self.assertTrue(cond.locked())

async def test_wait_cancel(self):
        cond = asyncio.Condition()
        await cond.acquire()

wait = asyncio.create_task(cond.wait())
        asyncio.get_running_loop().call_soon(wait.cancel)
        with self.assertRaises(asyncio.CancelledError):
            await wait
        self.assertFalse(cond._waiters)
        self.assertTrue(cond.locked())

async def test_wait_cancel_contested(self):
        cond = asyncio.Condition()

await cond.acquire()
        self.assertTrue(cond.locked())

wait_task = asyncio.create_task(cond.wait())
        await asyncio.sleep(0)
        self.assertFalse(cond.locked())

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

try:
            await wait_task
        except asyncio.CancelledError:
            # Should not happen, since no cancellation points
            pass

self.assertTrue(cond.locked())

async def test_wait_cancel_after_notify(self):
        # See bpo-32841
        waited = False

cond = asyncio.Condition()

async def wait_on_cond():
            nonlocal waited
            async with cond:
                waited = True  # Make sure this area was reached
                await cond.wait()

waiter = asyncio.create_task(wait_on_cond())
        await asyncio.sleep(0)  # Start waiting

await cond.acquire()
        cond.notify()
        await asyncio.sleep(0)  # Get to acquire()
        waiter.cancel()
        await asyncio.sleep(0)  # Activate cancellation
        cond.release()
        await asyncio.sleep(0)  # Cancellation should occur

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

async def test_wait_unacquired(self):
        cond = asyncio.Condition()
        with self.assertRaises(RuntimeError):
            await cond.wait()

async def test_wait_for(self):
        cond = asyncio.Condition()
        presult = False

def predicate():
            return presult

result = []

async def c1(result):
            await cond.acquire()
            if await cond.wait_for(predicate):
                result.append(1)
                cond.release()
            return True

t = asyncio.create_task(c1(result))

await asyncio.sleep(0)
        self.assertEqual([], result)

await cond.acquire()
        cond.notify()
        cond.release()
        await asyncio.sleep(0)
        self.assertEqual([], result)

presult = True
        await cond.acquire()
        cond.notify()
        cond.release()
        await asyncio.sleep(0)
        self.assertEqual([1], result)

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

async def test_wait_for_unacquired(self):
        cond = asyncio.Condition()

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

with self.assertRaises(RuntimeError):
            await cond.wait_for(lambda: False)

async def test_notify(self):
        cond = asyncio.Condition()
        result = []

async def c1(result):
            await cond.acquire()
            if await cond.wait():
                result.append(1)
                cond.release()
            return True

async def c2(result):
            await cond.acquire()
            if await cond.wait():
                result.append(2)
                cond.release()
            return True

async def c3(result):
            await cond.acquire()
            if await cond.wait():
                result.append(3)
                cond.release()
            return True

t1 = asyncio.create_task(c1(result))
        t2 = asyncio.create_task(c2(result))
        t3 = asyncio.create_task(c3(result))

await asyncio.sleep(0)
        self.assertEqual([], result)

await cond.acquire()
        cond.notify(1)
        cond.release()
        await asyncio.sleep(0)
        self.assertEqual([1], result)

await cond.acquire()
        cond.notify(1)
        cond.notify(2048)
        cond.release()
        await asyncio.sleep(0)
        self.assertEqual([1, 2, 3], result)

async def test_notify_all(self):
        cond = asyncio.Condition()

result = []

async def c1(result):
            await cond.acquire()
            if await cond.wait():
                result.append(1)
                cond.release()
            return True

async def c2(result):
            await cond.acquire()
            if await cond.wait():
                result.append(2)
                cond.release()
            return True

t1 = asyncio.create_task(c1(result))
        t2 = asyncio.create_task(c2(result))

await asyncio.sleep(0)
        self.assertEqual([], result)

await cond.acquire()
        cond.notify_all()
        cond.release()
        await asyncio.sleep(0)
        self.assertEqual([1, 2], result)

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

def test_notify_unacquired(self):
        cond = asyncio.Condition()
        self.assertRaises(RuntimeError, cond.notify)

def test_notify_all_unacquired(self):
        cond = asyncio.Condition()
        self.assertRaises(RuntimeError, cond.notify_all)

async def test_repr(self):
        cond = asyncio.Condition()
        self.assertTrue('unlocked' in repr(cond))
        self.assertTrue(RGX_REPR.match(repr(cond)))

await cond.acquire()
        self.assertTrue('locked' in repr(cond))

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

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

async def test_context_manager(self):
        cond = asyncio.Condition()
        self.assertFalse(cond.locked())
        async with cond:
            self.assertTrue(cond.locked())
        self.assertFalse(cond.locked())

async def test_explicit_lock(self):
        async def f(lock=None, cond=None):
            if lock is None:
                lock = asyncio.Lock()
            if cond is None:
                cond = asyncio.Condition(lock)
            self.assertIs(cond._lock, lock)
            self.assertFalse(lock.locked())
            self.assertFalse(cond.locked())
            async with cond:
                self.assertTrue(lock.locked())
                self.assertTrue(cond.locked())
            self.assertFalse(lock.locked())
            self.assertFalse(cond.locked())
            async with lock:
                self.assertTrue(lock.locked())
                self.assertTrue(cond.locked())
            self.assertFalse(lock.locked())
            self.assertFalse(cond.locked())

# All should work in the same way.
        await f()
        await f(asyncio.Lock())
        lock = asyncio.Lock()
        await f(lock, asyncio.Condition(lock))

async def test_ambiguous_loops(self):
        loop = asyncio.new_event_loop()
        self.addCleanup(loop.close)

async def wrong_loop_in_lock():
            with self.assertRaises(TypeError):
                asyncio.Lock(loop=loop)  # actively disallowed since 3.10
            lock = asyncio.Lock()
            lock._loop = loop  # use private API for testing
            async with lock:
                # acquired immediately via the fast-path
                # without interaction with any event loop.
                cond = asyncio.Condition(lock)
                # cond.acquire() will trigger waiting on the lock
                # and it will discover the event loop mismatch.
                with self.assertRaisesRegex(
                    RuntimeError,
                    "is bound to a different event loop",
                ):
                    await cond.acquire()

async def wrong_loop_in_cond():
            # Same analogy here with the condition's loop.
            lock = asyncio.Lock()
            async with lock:
                with self.assertRaises(TypeError):
                    asyncio.Condition(lock, loop=loop)
                cond = asyncio.Condition(lock)
                cond._loop = loop
                with self.assertRaisesRegex(
                    RuntimeError,
                    "is bound to a different event loop",
                ):
                    await cond.wait()

await wrong_loop_in_lock()
        await wrong_loop_in_cond()

async def test_timeout_in_block(self):
        condition = asyncio.Condition()
        async with condition:
            with self.assertRaises(asyncio.TimeoutError):
                await asyncio.wait_for(condition.wait(), timeout=0.5)

class SemaphoreTests(unittest.IsolatedAsyncioTestCase):

def test_initial_value_zero(self):
        sem = asyncio.Semaphore(0)
        self.assertTrue(sem.locked())

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

await sem.acquire()
        self.assertTrue(repr(sem).endswith('[locked]>'))
        self.assertTrue('waiters' not in repr(sem))
        self.assertTrue(RGX_REPR.match(repr(sem)))

if sem._waiters is None:
            sem._waiters = collections.deque()

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

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

async def test_semaphore(self):
        sem = asyncio.Semaphore()
        self.assertEqual(1, sem._value)

with self.assertWarns(DeprecationWarning):
            @asyncio.coroutine
            def acquire_lock():
                return (yield from sem)

with self.assertRaisesRegex(
            TypeError,
            "'Semaphore' object is not iterable",
        ):
            await acquire_lock()

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

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

async def test_acquire(self):
        sem = asyncio.Semaphore(3)
        result = []

self.assertTrue(await sem.acquire())
        self.assertTrue(await sem.acquire())
        self.assertFalse(sem.locked())

async def c1(result):
            await sem.acquire()
            result.append(1)
            return True

async def c2(result):
            await sem.acquire()
            result.append(2)
            return True

async def c3(result):
            await sem.acquire()
            result.append(3)
            return True

async def c4(result):
            await sem.acquire()
            result.append(4)
            return True

t1 = asyncio.create_task(c1(result))
        t2 = asyncio.create_task(c2(result))
        t3 = asyncio.create_task(c3(result))

await asyncio.sleep(0)
        self.assertEqual([1], result)
        self.assertTrue(sem.locked())
        self.assertEqual(2, len(sem._waiters))
        self.assertEqual(0, sem._value)

t4 = asyncio.create_task(c4(result))

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

await asyncio.sleep(0)
        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 = [t for t in race_tasks if t.done() and t.result()]
        self.assertEqual(2, len(done_tasks))

# cleanup locked semaphore
        sem.release()
        await asyncio.gather(*race_tasks)

async def test_acquire_cancel(self):
        sem = asyncio.Semaphore()
        await sem.acquire()

acquire = asyncio.create_task(sem.acquire())
        asyncio.get_running_loop().call_soon(acquire.cancel)
        with self.assertRaises(asyncio.CancelledError):
            await acquire
        self.assertTrue((not sem._waiters) or
                        all(waiter.done() for waiter in sem._waiters))

async def test_acquire_cancel_before_awoken(self):
        sem = asyncio.Semaphore(value=0)

t1 = asyncio.create_task(sem.acquire())
        t2 = asyncio.create_task(sem.acquire())
        t3 = asyncio.create_task(sem.acquire())
        t4 = asyncio.create_task(sem.acquire())

await asyncio.sleep(0)

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

await asyncio.sleep(0)
        await asyncio.sleep(0)
        num_done = sum(t.done() for t in [t3, t4])
        self.assertEqual(num_done, 1)
        self.assertTrue(t3.done())
        self.assertFalse(t4.done())

t3.cancel()
        t4.cancel()
        await asyncio.sleep(0)

async def test_acquire_hang(self):
        sem = asyncio.Semaphore(value=0)

t1 = asyncio.create_task(sem.acquire())
        t2 = asyncio.create_task(sem.acquire())
        await asyncio.sleep(0)

t1.cancel()
        sem.release()
        await asyncio.sleep(0)
        await asyncio.sleep(0)
        self.assertTrue(sem.locked())
        self.assertTrue(t2.done())

async def test_acquire_no_hang(self):

sem = asyncio.Semaphore(1)

async def c1():
            async with sem:
                await asyncio.sleep(0)
            t2.cancel()

async def c2():
            async with sem:
                self.assertFalse(True)

t1 = asyncio.create_task(c1())
        t2 = asyncio.create_task(c2())

r1, r2 = await asyncio.gather(t1, t2, return_exceptions=True)
        self.assertTrue(r1 is None)
        self.assertTrue(isinstance(r2, asyncio.CancelledError))

await asyncio.wait_for(sem.acquire(), timeout=1.0)

def test_release_not_acquired(self):
        sem = asyncio.BoundedSemaphore()

self.assertRaises(ValueError, sem.release)

async def test_release_no_waiters(self):
        sem = asyncio.Semaphore()
        await sem.acquire()
        self.assertTrue(sem.locked())

sem.release()
        self.assertFalse(sem.locked())

async def test_acquire_fifo_order(self):
        sem = asyncio.Semaphore(1)
        result = []

async def coro(tag):
            await sem.acquire()
            result.append(f'{tag}_1')
            await asyncio.sleep(0.01)
            sem.release()

await sem.acquire()
            result.append(f'{tag}_2')
            await asyncio.sleep(0.01)
            sem.release()

t1 = asyncio.create_task(coro('c1'))
        t2 = asyncio.create_task(coro('c2'))
        t3 = asyncio.create_task(coro('c3'))

await asyncio.gather(t1, t2, t3)

self.assertEqual(
            ['c1_1', 'c2_1', 'c3_1', 'c1_2', 'c2_2', 'c3_2'],
            result
        )

async def test_acquire_fifo_order_2(self):
        sem = asyncio.Semaphore(1)
        result = []

async def c1(result):
            await sem.acquire()
            result.append(1)
            return True

async def c2(result):
            await sem.acquire()
            result.append(2)
            sem.release()
            await sem.acquire()
            result.append(4)
            return True

async def c3(result):
            await sem.acquire()
            result.append(3)
            return True

t1 = asyncio.create_task(c1(result))
        t2 = asyncio.create_task(c2(result))
        t3 = asyncio.create_task(c3(result))

await asyncio.sleep(0)

sem.release()
        sem.release()

tasks = [t1, t2, t3]
        await asyncio.gather(*tasks)
        self.assertEqual([1, 2, 3, 4], result)

async def test_acquire_fifo_order_3(self):
        sem = asyncio.Semaphore(0)
        result = []

async def c1(result):
            await sem.acquire()
            result.append(1)
            return True

async def c2(result):
            await sem.acquire()
            result.append(2)
            return True

async def c3(result):
            await sem.acquire()
            result.append(3)
            return True

t1 = asyncio.create_task(c1(result))
        t2 = asyncio.create_task(c2(result))
        t3 = asyncio.create_task(c3(result))

await asyncio.sleep(0)

t1.cancel()

await asyncio.sleep(0)

sem.release()
        sem.release()

tasks = [t1, t2, t3]
        await asyncio.gather(*tasks, return_exceptions=True)
        self.assertEqual([2, 3], result)

if __name__ == '__main__':
    unittest.main()

📁 Sid Gifari File Manager