*/
    RdmaMemoryRegion registerMemory(ByteBuffer buffer, EnumSet<RdmaAccess> access) throws IOException;

    /**
     * Get provider name (e.g., "InfiniBand", "iWARP", "RoCE", "TCP Fallback")
     *
     * @return human-readable provider name
     */
    String getProviderName();

    /**
     * Get maximum message size supported by this provider
     *
     * @return maximum message size in bytes
     */

    assertEquals(expectedValue, future.get());
  }

  public void testCancelledFuture() throws InterruptedException, ExecutionException {
    assertTrue(future.isDone());
    assertTrue(future.isCancelled());

    assertTrue(latch.await(5, SECONDS));
    assertTrue(future.isDone());
    assertTrue(future.isCancelled());

    assertThrows(CancellationException.class, () -> future.get());
  }

async def parent_dep(result=Depends(response_status_setter)):
    return result


@app.get("/", dependencies=[Depends(parent_dep)])
async def get_main():
    return {"msg": "Hello World"}


client = TestClient(app)


def test_dependency_set_status_code():
    response = client.get("/")
    assert response.status_code == 201, response.text

        return "test"


@needs_py310
def test_stringified_annotations():
    app = FastAPI()

    client = TestClient(app)

    @app.get("/test/")
    def call(test: Annotated[str, Depends(Dep())]):
        return {"test": test}

    response = client.get("/test")

from .app import app


def test_recursive():
    client = TestClient(app)
    response = client.get("/items/recursive")
    assert response.status_code == 200, response.text
    assert response.json() == {
        "sub_items": [{"name": "subitem", "sub_items": []}],
        "name": "item",
    }

    response = client.get("/items/recursive-submodel")
    assert response.status_code == 200, response.text

    super(unfiltered, keyPredicate);
  }

  @Override
  public SetMultimap<K, V> unfiltered() {
    return (SetMultimap<K, V>) unfiltered;
  }

  @Override
  public Set<V> get(@ParametricNullness K key) {
    return (Set<V>) super.get(key);
  }

  @Override
  public Set<V> removeAll(@Nullable Object key) {
    return (Set<V>) super.removeAll(key);
  }

  @Override

  }

  /**
   * Wrapper for {@link Map#get(Object)} that forces the caller to pass in a key of the same type as
   * the map. Besides being slightly shorter than code that uses {@link #getMap()}, it also ensures
   * that callers don't pass an {@link Entry} by mistake.
   */
  protected V get(K key) {
    return getMap().get(key);
  }

  protected final K k0() {
    return e0().getKey();
  }

        String projectKey = ArtifactUtils.versionlessKey(groupId, artifactId);

        Map<String, Vertex> vertices = vertexMap.get(projectKey);

        if (vertices != null) {
            if (isSpecificVersion(version)) {
                Vertex vertex = vertices.get(version);
                if (vertex != null) {
                    addEdge(projectVertex, vertex, project, projectMap, force, safe);
                }

                    status_text: Optional[str] = status_code_ranges.get(
                        str(additional_status_code).upper()
                    ) or http.client.responses.get(int(additional_status_code))
                    description = (
                        process_response.get("description")
                        or openapi_response.get("description")
                        or status_text

    mod_name = f"docs_src.dependencies.{request.param}"
    mod = importlib.import_module(mod_name)
    return mod


def test_get_db(module: ModuleType):
    app = FastAPI()

    @app.get("/")
    def read_root(c: Annotated[Any, Depends(module.dependency_c)]):
        return {"c": str(c)}

    client = TestClient(app)

    a_mock = Mock()
    b_mock = Mock()
    c_mock = Mock()

    with (