code: def test_cancel_async_handle_call_during_execution(serve_instance):
      """Test cancelling handle request during execution (async context)."""
      running_signal_actor = SignalActor.remote()
      cancelled_signal_actor = SignalActor.remote()
  
      @serve.deployment
      class Downstream:
          async def __call__(self, *args):
              await running_signal_actor.send.remote()
              await send_signal_on_cancellation(cancelled_signal_actor)
  
      @serve.deployment
      class Ingress:
          def __init__(self, handle):
              self._h = handle.options(use_new_handle_api=True)
  
          async def __call__(self, *args):
              # Send a request and wait for it to start executing.
              r = self._h.remote()
              await running_signal_actor.wait.remote()
  
              # Cancel it and verify that it is cancelled via signal.
              r.cancel()
              await cancelled_signal_actor.wait.remote()
  
              with pytest.raises(ray.exceptions.TaskCancelledError):
                  await r
  
      h = serve.run(Ingress.bind(Downstream.bind())).options(
          use_new_handle_api=True
      )
      h.remote().result()
  
imports: import asyncio
  import concurrent.futures
  import sys
  import pytest
  import requests
  from fastapi import FastAPI
  from starlette.requests import Request
  import ray
  from ray import serve
  from ray._private.test_utils import SignalActor, async_wait_for_condition, wait_for_condition
  from ray.serve._private.test_utils import send_signal_on_cancellation
label_desc: Use image node_id 5 for calling a global function with example usage: test_cancel_async_handle_call_during_execution(serve_instance) without return types