private static void joinUninterruptibly(Thread thread, long timeout, TimeUnit unit) {
    boolean interrupted = false;
    try {
      long remainingNanos = unit.toNanos(timeout);
      long end = System.nanoTime() + remainingNanos;

      while (true) {
        try {
          // TimeUnit.timedJoin() treats negative timeouts just like zero.
          NANOSECONDS.timedJoin(thread, remainingNanos);

     * argument will be returned.
     */
    public static int getInt ( Properties props, String key, int def ) {
        String s = props.getProperty(key);
        if ( s != null ) {
            try {
                def = Integer.parseInt(s);
            }
            catch ( NumberFormatException nfe ) {
                log.error("Not a number", nfe);
            }
        }
        return def;
    }

       */
      return null;
    }
    try {
      return finalizableReferenceClass.getMethod("finalizeReferent");
    } catch (NoSuchMethodException e) {
      throw new AssertionError(e);
    }
  }

  @CheckForNull
  private static Field getInheritableThreadLocalsField() {
    try {
      Field inheritableThreadLocals = Thread.class.getDeclaredField("inheritableThreadLocals");

        try {
            final String filename = getDecodeText(bodyPart.getFileName());
            final String mimeType = mimeTypeHelper.getContentType(null, filename);
            if (mimeType != null) {
                final Extractor extractor = extractorFactory.getExtractor(mimeType);
                if (extractor != null) {
                    try (final InputStream in = bodyPart.getInputStream()) {

        try (InputStream in = createClient(fessConfig).getObject(args)) {
            out.write(in);
        } catch (final Exception e) {
            throw new StorageException("Failed to download " + objectName, e);
        }
    }

    public static void deleteObject(final String objectName) {
        try {

        FileEntry n = this.next;
        try {
            FileEntry ne = advance(false);
            if ( ne == null ) {
                doClose();
                return n;
            }
            this.next = ne;
        }
        catch ( CIFSException e ) {
            log.warn("Enumeration failed", e);
            this.next = null;
            try {
                doClose();
            }

                return xml.read(reader, request.isStrict());
            } else if (path != null) {
                try (InputStream is = Files.newInputStream(path)) {
                    return xml.read(is, request.isStrict());
                }
            } else {
                try (InputStream is = url.openStream()) {
                    return xml.read(is, request.isStrict());
                }
            }

func bytesToPrivateKey(priv []byte) (*rsa.PrivateKey, error) {
	// Try PEM
	if block, _ := pem.Decode(priv); block != nil {
		return x509.ParsePKCS1PrivateKey(block.Bytes)
	}
	// Try base 64
	dst := make([]byte, base64.StdEncoding.DecodedLen(len(priv)))
	if n, err := base64.StdEncoding.Decode(dst, priv); err == nil {
		return x509.ParsePKCS1PrivateKey(dst[:n])
	}
	// Try Raw, return error
	return x509.ParsePKCS1PrivateKey(priv)
}

  override fun afterHandshake(sslSocket: SSLSocket) {
    try {
      removeMethod.invoke(null, sslSocket)
    } catch (e: IllegalAccessException) {
      throw AssertionError("failed to remove ALPN", e)
    } catch (e: InvocationTargetException) {
      throw AssertionError("failed to remove ALPN", e)
    }
  }

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? {
    try {

/** Tolerant delete, try to clear as many files as possible even after a failure. */
internal fun FileSystem.deleteContents(directory: Path) {
  var exception: IOException? = null
  val files =
    try {
      list(directory)
    } catch (fnfe: FileNotFoundException) {
      return
    }
  for (file in files) {
    try {
      if (metadata(file).isDirectory) {
        deleteContents(file)
      }