async def METHOD_NAME(uri, auth):
    class Signal:
        queried = False
        released = False
    async def fill_pool(driver_: neo4j.AsyncDriver, n=10):
        signals = [Signal() for _ in range(n)]
        await asyncio.gather(
            *(handle_session(driver_.session(), signals[i]) for i in range(n)),
            handle_signals(signals),
            return_exceptions=True,
        )
    async def handle_signals(signals):
        while any(not signal.queried for signal in signals):
            await asyncio.sleep(0.001)
        await asyncio.sleep(0.1)
        for signal in signals:
            signal.released = True
    async def handle_session(session, signal):
        async with session:
            await session.execute_read(work, signal)
    async def work(tx: neo4j.AsyncManagedTransaction, signal: Signal) -> None:
        res = await tx.run("UNWIND range(1, 10000) AS x RETURN x")
        signal.queried = True
        while not signal.released:
            await asyncio.sleep(0.001)
        await res.consume()
    def connection_count(driver_):
        return sum(len(v) for v in driver_._pool.connections.values())
    driver = neo4j.AsyncGraphDatabase.driver(uri, auth=auth)
    await fill_pool(driver)
    # sanity check, there should be some connections
    assert connection_count(driver) >= 10
    # start the close and give it some event loop iterations to kick off
    fut = asyncio.ensure_future(driver.close())
    await asyncio.sleep(0)
    # cancel in the middle of closing connections
    fut.cancel()
    # give the driver a chance to close connections forcefully
    await asyncio.sleep(0)
    # driver should be marked as closed to not emmit a ResourceWarning later
    assert driver._closed == True