} catch (Exception e) {
            fail("Should not throw exception in test setup");
        }

        // Execute and verify ChildUrlsException is thrown
        try {
            processor.process(responseData);
            fail("Should throw ChildUrlsException");
        } catch (ChildUrlsException e) {
            // Expected exception

                responseData.setCharSet(charset);
                responseData.setContentLength(0);
            }
        } catch (final CrawlerSystemException e) {
            CloseableUtil.closeQuietly(responseData);
            throw e;
        } catch (final SmbException e) {
            CloseableUtil.closeQuietly(responseData);
            throw new CrawlingAccessException("Could not access " + uri, e);

            } catch (NumberFormatException e) {
                // Invalid value ignored
            }
        }

        value = props.getProperty("jcifs.smb.client.soTimeout");
        if (value != null) {
            try {
                this.smbSocketTimeout = Integer.parseInt(value);
            } catch (NumberFormatException e) {
                // Invalid value ignored

      putMethod.invoke(null, sslSocket, alpnProvider)
    } catch (e: InvocationTargetException) {
      throw AssertionError("failed to set ALPN", e)
    } catch (e: IllegalAccessException) {
      throw AssertionError("failed to set ALPN", e)
    }
  }

  override fun afterHandshake(sslSocket: SSLSocket) {
    try {
      removeMethod.invoke(null, sslSocket)
    } catch (e: IllegalAccessException) {

      fail();
    } catch (TimeoutException expected) {
    } catch (ExecutionException e) {
      throw new AssertionError(e);
    }
  }

  static void verifyTimedGetOnPendingFuture(Future<?> future) {
    try {
      getUninterruptibly(future, 0, SECONDS);
      fail();
    } catch (TimeoutException expected) {
    } catch (ExecutionException e) {
      throw new AssertionError(e);
    }

      fail();
    } catch (NumberFormatException expected) {
    } catch (IllegalArgumentException expected) {
      // Kotlin native, see above
    }

    try {
      UnsignedInts.parseUnsignedInt("0", Character.MAX_RADIX + 1);
      fail();
    } catch (NumberFormatException expected) {
    } catch (IllegalArgumentException expected) {
      // Kotlin native, see above

    IOException exception = new IOException();

    try {
      try {
        throw exception;
      } catch (Throwable e) {
        throw closer.rethrow(e);
      } finally {
        closer.close();
      }
    } catch (Throwable expected) {
      assertSame(exception, expected);
    }

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());

      } catch (NoSuchElementException success) {
      }
      try {
        q.iterator().next();
        fail("Should throw exception");
      } catch (NoSuchElementException success) {
      }
      try {
        q.remove();
        fail("Should throw exception");
      } catch (NoSuchElementException success) {
      }
    } catch (InterruptedException ie) {

        this.connectionState.set(2); // connected

        try {
            validateNegotiation(transport, sess);
        } catch (final CIFSException se) {
            try {
                transport.disconnect(true);
            } catch (final IOException e) {
                log.warn("Failed to disconnect transport", e);
                se.addSuppressed(e);
            }
            throw se;

                try {
                    trans.ensureConnected();
                } catch (final IOException e) {
                    removeTransport(trans);
                    throw e;
                }
                return trans.acquire();
            } catch (final IOException e) {
                final String hostAddress = addr.getHostAddress();