if (object == null) {
      return false;
    }
    try {
      @SuppressWarnings("unchecked") // The worst case is usually CCE, which we catch.
      C c = (C) object;
      return range.contains(c);
    } catch (ClassCastException e) {
      return false;
    }
  }

  @Override
  public boolean containsAll(Collection<?> targets) {

  private static void executeListener(Runnable runnable, Executor executor) {
    try {
      executor.execute(runnable);
    } catch (Exception e) { // sneaky checked exception
      // Log it and keep going -- bad runnable and/or executor. Don't punish the other runnables if
      // we're given a bad one. We only catch Exception because we want Errors to propagate up.
      log.get()
          .log(
              Level.SEVERE,

    try {
      expectedResult = expected.apply(input);
    } catch (RuntimeException e) {
      expectedRuntimeException = e;
    }

    Boolean actualResult = null;
    RuntimeException actualRuntimeException = null;
    try {
      actualResult = actual.apply(input);
    } catch (RuntimeException e) {
      actualRuntimeException = e;
    }

            try (Reader reader = IOUtils.getDecodingReader(new FileInputStream(suffixWordsFile), StandardCharsets.UTF_8)) {
                suffixWords = WordlistLoader.getWordSet(reader);
            } catch (final IOException e) {
                throw new IllegalArgumentException("Could not load " + suffixWordsFile.getAbsolutePath(), e);
            }
        } else {
            suffixWords = new CharArraySet(0, false);

                            this.type = SmbConstants.TYPE_WORKGROUP;
                            return this.type;
                        }
                    }
                } catch (final CIFSException e) {
                    if (!(e.getCause() instanceof UnknownHostException)) {
                        throw e;
                    }
                    log.debug("Unknown host", e);

            try {
                final Instant instant = Instant.from(DateTimeFormatter.ISO_INSTANT.parse(value.toString()));
                return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
            } catch (final DateTimeParseException e) {
                logger.debug("Invalid date format: {}", value, e);
            }
        }
        return DfTypeUtil.toLocalDateTime(value);
    }

) {
  /** Returns a possibly-empty list of certificates that identify the remote peer. */
  @get:JvmName("peerCertificates")
  val peerCertificates: List<Certificate> by lazy {
    try {
      peerCertificatesFn()
    } catch (spue: SSLPeerUnverifiedException) {
      listOf()
    }
  }

  @JvmName("-deprecated_tlsVersion")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "tlsVersion"),

   * its connection.
   */
  private fun launchTcpConnect(): ConnectResult? {
    val plan =
      when {
        routePlanner.hasNext() -> {
          try {
            routePlanner.plan()
          } catch (e: Throwable) {
            FailedPlan(e)
          }
        }
        else -> return null // Nothing further to try.
      }

    // Already connected. Return it immediately.

            if (reloadableFile != null) {
                lastModified = reloadableFile.lastModified();
            } else {
                lastModified = System.currentTimeMillis();
            }

        } catch (final Exception e) {
            throw new IllegalArgumentException("failed to build synonyms", e);
        }
    }

    private Reader getReader(final boolean reload) throws IOException {
        if (reload) {

            // Since the real method will propagate the exception from handle.close(),
            // we need to catch it to verify that pipe.close() was still called
            try {
                handle.close();
                fail("Expected IOException to be thrown");
            } catch (IOException e) {
                assertEquals("Handle close failed", e.getMessage());
            }