*/
    public SecretKey getSessionKey(String sessionId) {
        checkNotClosed();

        SecretKey key = sessionKeys.get(sessionId);

        // Try to load from KeyStore if not in memory
        if (key == null && keyStore != null) {
            try {
                KeyStore.ProtectionParameter protection = new KeyStore.PasswordProtection(keyStorePassword);

  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 (plan.isReady) return ConnectResult(plan)

        final int pos = path.lastIndexOf("/");
        final String baseDirectory = path.substring(0, pos);
        ResourceTraversalUtil.forEach(rootDir, baseDirectory, (ResourceHandler) (path1, is) -> {
            try {
                if (count < 10) {
                    System.out.println(path1);
                }
                assertThat(path1, is(notNullValue()));
                assertThat(is, is(notNullValue()));

    try {
      getMap().replace(k0(), v3(), v4());
    } catch (UnsupportedOperationException tolerated) {
      // the operation would be a no-op, so exceptions are allowed but not required
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testReplaceEntry_unsupportedAbsentKey() {
    try {
      getMap().replace(k3(), v3(), v4());

  private void assertSetCountIncreasingFailure(E element, int count) {
    try {
      setCountNoCheckReturnValue(element, count);
      fail("a call to multiset.setCount() to increase an element's count should throw");
    } catch (UnsupportedOperationException expected) {
    }
  }

  private void assertSetCountDecreasingFailure(E element, int count) {
    try {
      setCountNoCheckReturnValue(element, count);

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

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

        ExtensionDescriptor extensionDescriptor = null;

        if (extensionJar.isFile()) {
            try (JarFile pluginJar = new JarFile(extensionJar, false)) {
                ZipEntry pluginDescriptorEntry = pluginJar.getEntry(getExtensionDescriptorLocation());

                if (pluginDescriptorEntry != null) {
                    try (InputStream is = pluginJar.getInputStream(pluginDescriptorEntry)) {

     * @return An {@link InputStream} to read the resource represented by the URL.
     */
    public static InputStream openStream(final URL url) {
        assertArgumentNotNull("url", url);

        try {
            final URLConnection connection = url.openConnection();
            connection.setUseCaches(false);
            return connection.getInputStream();
        } catch (final IOException e) {

        final List<Exception> exceptions = new ArrayList<>();

        // Create multiple threads that all try to connect simultaneously
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    startLatch.await(); // Wait for signal to start
                    conn.connect();
                    successCount.incrementAndGet();

                }
                finalUrl = url + urlBuf.toString();
            } else {
                finalUrl = url;
            }

            HttpURLConnection connection = null;
            try {
                logger.fine(() -> ">>> " + method + " " + finalUrl);
                final URL u = new URL(finalUrl);
                connection = open(u);
                connection.setRequestMethod(method.toString());