*   // do stuff
 * } catch (Throwable e) {
 *   // ensure that any checked exception types other than IOException that could be thrown are
 *   // provided here, e.g. throw closer.rethrow(e, CheckedException.class);
 *   throw closer.rethrow(e);
 * } finally {
 *   closer.close();
 * }
 * }
 *
 * <p>Note that this try-catch-finally block is not equivalent to a try-catch-finally block using

    private final char match;

    Is(char match) {
      this.match = match;
    }

    @Override
    public boolean matches(char c) {
      return c == match;
    }

    @Override
    public String replaceFrom(CharSequence sequence, char replacement) {
      return sequence.toString().replace(match, replacement);
    }

    @Override

            assertNotNull(result);
        } catch (Exception e) {
            assertTrue(true);
        }
    }

    public void test_createHighlightInfo() {
        ViewHelper viewHelper = new ViewHelper();
        viewHelper.init();

        try {
            assertNotNull(viewHelper.createHighlightInfo());
        } catch (Exception e) {
            assertTrue(true);
        }
    }

        try {
          testEqualsUsing(factory);
          return;
        } catch (ParameterNotInstantiableException e) {
          paramErrors.add(e);
        } catch (ParameterHasNoDistinctValueException e) {
          distinctValueErrors.add(e);
        } catch (InvocationTargetException e) {
          instantiationExceptions.add(e);
        } catch (FactoryMethodReturnsNullException e) {
          nullErrors.add(e);
        }

                    return item;
                } catch (final IOException e) {
                    throw new DictionaryException("Failed to write: " + item, e);
                }
            }
            return null;
        }

        @Override
        public void close() {
            try {
                writer.flush();
            } catch (final IOException e) {
                // ignore

                log.info("RDMA connection established to {}", delegate.getRemoteAddress());
            } catch (IOException e) {
                log.warn("Failed to establish RDMA connection: {}", e.getMessage());
                throw e;
            }
        }
    }

    /**
     * Checks if RDMA connection is available.

                }
            }

            messageBuffer.flip();
            return messageBuffer;

        } catch (SocketTimeoutException e) {
            return null; // Timeout
        } catch (IOException e) {
            state = RdmaConnectionState.ERROR;
            throw new IOException("TCP RDMA receive failed", e);
        }
    }

    @Override

En ajoutant une étoile, les autres utilisateurs pourront la trouver plus facilement et constater qu'elle a déjà été utile à d'autres.

## Watch le dépôt GitHub pour les releases

Vous pouvez "watch" FastAPI dans GitHub (en cliquant sur le bouton "watch" en haut à droite) : <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀

      try {
        helper = new UnsafeAtomicHelper();
      } catch (Exception | Error unsafeFailure) { // sneaky checked exception
        thrownUnsafeFailure = unsafeFailure;
        // Catch absolutely everything and fall through to AtomicReferenceFieldUpdaterAtomicHelper.
        try {
          helper = new AtomicReferenceFieldUpdaterAtomicHelper();
        } catch (Exception // sneaky checked exception

        } catch (final NoSuchAlgorithmException e) {
            throw new CIFSUnsupportedCryptoException(e);
        }
    }

    /**
     * Get an MD5 message digest instance.
     * @return MD5 digest instance
     */
    public static MessageDigest getMD5() {
        try {
            return MessageDigest.getInstance("MD5");
        } catch (final NoSuchAlgorithmException e) {