ri += 4;
            if (id == 0 || ri + len > type2token.length) {
                break;
            }
            if (id == id0) {
                try {
                    return new String(type2token, ri, len, SmbConstants.UNI_ENCODING);
                } catch (final java.io.UnsupportedEncodingException uee) {
                    break;
                }
            }

 */
class SpnegoContext implements SSPContext {

    private static final Logger log = LoggerFactory.getLogger(SpnegoContext.class);

    private static ASN1ObjectIdentifier SPNEGO_MECH_OID;

    static {
        try {
            SPNEGO_MECH_OID = new ASN1ObjectIdentifier("1.3.6.1.5.5.2");
        } catch (final IllegalArgumentException e) {
            log.error("Failed to initialize OID", e);
        }
    }

        // Mock DFS resolver
        when(ctx.getDfs()).thenReturn(dfsResolver);
    }

    // Helper to set private field 'tree'
    private static void setTree(SmbTreeConnection c, SmbTreeImpl tree) {
        try {
            Field f = SmbTreeConnection.class.getDeclaredField("tree");
            f.setAccessible(true);
            f.set(c, tree);
        } catch (Exception e) {
            throw new AssertionError(e);
        }

     */
    protected Class<?> dataClass = null;

    @Override
    protected void storeData(final ResponseData responseData, final ResultData resultData) {
        final DOMParser parser = getDomParser();
        try (final InputStream in = responseData.getResponseBody()) {
            final InputSource is = new InputSource(in);
            if (responseData.getCharSet() != null) {
                is.setEncoding(responseData.getCharSet());

public class GetExample {
  final OkHttpClient client = new OkHttpClient();

  String run(String url) throws IOException {
    Request request = new Request.Builder()
        .url(url)
        .build();

    try (Response response = client.newCall(request).execute()) {
      return response.body().string();
    }
  }

  public static void main(String[] args) throws IOException {
    GetExample example = new GetExample();

                return webApiManager;
            }
        };
        ComponentUtil.register(factory, "webApiManagerFactory");

        // Execute and expect IOException
        try {
            webApiFilter.doFilter(request, response, chain);
            fail("Expected IOException");
        } catch (IOException e) {
            assertEquals("Test IOException", e.getMessage());

/// tip

You can use `async` or regular functions.

**FastAPI** will do the right thing with each, the same as with normal dependencies.

///

## A dependency with `yield` and `try` { #a-dependency-with-yield-and-try }

If you use a `try` block in a dependency with `yield`, you'll receive any exception that was thrown when using the dependency.

    server.setDispatcher(this);
    server.start(port);
  }

  @Override public MockResponse dispatch(RecordedRequest request) {
    String path = request.getPath();
    try {
      if (!path.startsWith("/") || path.contains("..")) throw new FileNotFoundException();

      File file = new File(root + path);
      return file.isDirectory()
          ? directoryToResponse(path, file)

            expressionDocumentation = new HashMap<>();

            ClassLoader docLoader = initializeDocLoader();

            for (String root : EXPRESSION_ROOTS) {
                try (InputStream docStream =
                        docLoader.getResourceAsStream(EXPRESSION_DOCO_ROOTPATH + root + ".paramdoc.xml")) {
                    if (docStream != null) {

 *
 * For synchronous calls, the easiest way to make sure a response body is closed is with a `try`
 * block. With this structure the compiler inserts an implicit `finally` clause that calls
 * [close()][Response.close] for you.
 *
 * ```java
 * Call call = client.newCall(request);
 * try (Response response = call.execute()) {
 * ... // Use the response.
 * }
 * ```
 *