ImmutableMap<K, V> empty = (ImmutableMap<K, V>) EMPTY;
      return empty;
    }
    try {
      return fromEntryArrayCheckingBucketOverflow(n, entryArray, throwIfDuplicateKeys);
    } catch (BucketOverflowException e) {
      // probable hash flooding attack, fall back to j.u.HM based implementation and use its
      // implementation of hash flooding protection

      executor.execute(
          () -> {
            try {
              closeable.close();
            } catch (Exception e) {
              restoreInterruptIfIsInterruptedException(e);
              logger.get().log(WARNING, "thrown by close()", e);
            }
          });
    } catch (RejectedExecutionException e) {
      if (logger.get().isLoggable(WARNING)) {
        logger
            .get()

    val authenticator =
      okhttp3.Authenticator { route: Route?, response: Response? ->
        responses.offer(response!!.body.string())
        try {
          latch.await()
        } catch (e: InterruptedException) {
          throw AssertionError()
        }
        response.request
      }
    val blockingAuthClient =
      client
        .newBuilder()

                    treq.setFileInformation(new FileEndOfFileInformation(0));
                    th.send(treq, RequestParam.NO_RETRY);
                }
            }
        } catch (final CIFSException e) {
            throw SmbException.wrap(e);
        }
    }

    SmbFileOutputStream(final SmbFile file, final SmbTreeHandleImpl th, final SmbFileHandleImpl handle, final int openFlags,

            // we replace the thread local of the clone to prevent write through and enforce the new default value
            clone.currentProject = ThreadLocal.withInitial(() -> current);
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException("Bug", e);
        }
    }

    @Deprecated
    public Date getStartTime() {
        return request.getStartTime();
    }

                    context.failure("Cannot upgrade from " + currentVersion + " to " + targetModelVersion);
                    errorPoms.add(pomPath);
                }
            } catch (Exception e) {
                context.failure("Model upgrade failed: " + e.getMessage());
                errorPoms.add(pomPath);
            } finally {
                context.unindent();
            }
        }

        public void connect(Consumer<HttpURLConnection> actionListener, Consumer<Exception> exceptionListener) {
            try {
                actionListener.accept(new MockHttpURLConnection(new URL(url)));
            } catch (MalformedURLException e) {
                exceptionListener.accept(e);
            }
        }
    }

    class MockHttpURLConnection extends HttpURLConnection {

        MockHttpURLConnection(URL u) {

        mockBhv.setTestData(testData);

        relatedQueryHelper.update();
        // Give a moment for async execution
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            // ignore
        }

        results = relatedQueryHelper.getRelatedQueries("test");
        assertEquals("updated", results[0]);
    }

    @Test

            java.lang.reflect.Method method = LdapUser.class.getDeclaredMethod("distinct", String[].class);
            method.setAccessible(true);
            return (String[]) method.invoke(null, (Object) values);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

        assertEquals("", DocumentUtil.encodeUrl(""));
        try {
            DocumentUtil.encodeUrl(null);
            fail("Should throw NullPointerException");
        } catch (NullPointerException e) {
            // Expected
        }
    }

    @Test
    public void test_encodeUrl_unicode() {
        assertEquals("%3F", DocumentUtil.encodeUrl("あ"));