this["okhttp3.mockwebserver.MockWebServer"] = "okhttp.MockWebServer"
      }.toMap()

  internal fun androidLog(
    loggerName: String,
    logLevel: Int,
    message: String,
    t: Throwable? = null,
  ) {
    val tag = loggerTag(loggerName)

    if (Log.isLoggable(tag, logLevel)) {
      var logMessage = message
      if (t != null) logMessage = logMessage + '\n'.toString() + Log.getStackTraceString(t)

                    .addBuildSummary(new BuildSuccess(currentProject, Duration.between(buildStartTime, buildEndTime)));

            eventCatapult.fire(ExecutionEvent.Type.ProjectSucceeded, session, null);
        } catch (Throwable t) {
            builderCommon.handleBuildError(reactorContext, rootSession, session, currentProject, t, buildStartTime);

            projectExecutionListener.afterProjectExecutionFailure(

        try {
            helper = ComponentUtil.getLogNotificationHelper();
        } catch (final Exception e) {
            return;
        }

        String throwableStr = null;
        final Throwable thrown = event.getThrown();
        if (thrown != null) {
            final StringWriter sw = new StringWriter();
            thrown.printStackTrace(new PrintWriter(sw));
            throwableStr = sw.toString();

        initRepoSession(configuration);

        try {
            return projectBuilder.build(pom, configuration).getProject();
        } catch (Exception e) {
            Throwable cause = e.getCause();
            if (cause instanceof ModelBuildingException modelBuildingException) {
                StringBuilder message = new StringBuilder("In: " + pom + "\n\n");

        }
    }

    private static void assertThrows(final Class<? extends Throwable> expectedType, final Runnable runnable) {
        try {
            runnable.run();
            throw new AssertionError("Expected " + expectedType.getSimpleName() + " to be thrown");
        } catch (final Throwable t) {
            if (!expectedType.isInstance(t)) {

        assertTrue(exception instanceof FessSystemException);
        assertTrue(exception instanceof RuntimeException);
        assertTrue(exception instanceof Exception);
        assertTrue(exception instanceof Throwable);
    }

    @Test
    public void test_stackTrace() {
        // Test that stack trace is generated properly
        LdapConfigurationException exception = new LdapConfigurationException("Stack trace test");

      V value, @Nullable Exception except, CountDownLatch waitOn);

  /** Tests that the {@link Future#get()} method blocks until a value is available. */
  public void testGetBlocksUntilValueAvailable() throws Throwable {

    assertFalse(future.isDone());
    assertFalse(future.isCancelled());

    ExecutorService executor = newSingleThreadExecutor();

    try {

@defaultMessage Stopping threads explicitly leads to inconsistent states. Use interrupt() instead.
java.lang.Thread#stop()
# uncomment when https://github.com/elastic/elasticsearch/issues/31715 is fixed
# java.lang.Thread#stop(java.lang.Throwable)

@defaultMessage Please do not terminate the application
java.lang.System#exit(int)
java.lang.Runtime#exit(int)
java.lang.Runtime#halt(int)

@defaultMessage Treat system properties as immutable

    ExecutorService executor = Executors.newFixedThreadPool(threadCount);
    for (int i = 0; i < threadCount; i++) {
      executor.execute(() -> {
        try {
          drainQueue();
        } catch (Throwable e) {
          e.printStackTrace();
        }
      });
    }
    executor.shutdown();
  }

  private void drainQueue() throws Exception {
    for (HttpUrl url; (url = queue.take()) != null; ) {

    DelegatingInvocationHandler(Object delegate) {
      this.delegate = checkNotNull(delegate);
    }

    @Override
    protected Object handleInvocation(Object proxy, Method method, Object[] args) throws Throwable {
      return method.invoke(delegate, args);
    }

    @Override
    public String toString() {
      return "some arbitrary string";
    }
  }