this.typeVariableImpl = typeVariableImpl;
    }

    @Override
    public @Nullable Object invoke(Object proxy, Method method, @Nullable Object @Nullable [] args)
        throws Throwable {
      String methodName = method.getName();
      Method typeVariableMethod = typeVariableMethods.get(methodName);
      if (typeVariableMethod == null) {
        throw new UnsupportedOperationException(methodName);

                    }
                } catch (final DataStoreCrawlingException e) {
                    crawlerStatsHelper.record(keyObj, StatsAction.ACCESS_EXCEPTION);
                    final Throwable cause = e.getCause();
                    if (cause instanceof ChildUrlsException) {
                        if (maxDepth == -1 || crawlRequest.getDepth() < maxDepth) {

    public void test_run_containerNotAvailable() throws Exception {
        final List<String> sessionIdList = Arrays.asList("session1");
        indexUpdater.setSessionIdList(sessionIdList);

        final AtomicReference<Throwable> caughtException = new AtomicReference<>();
        indexUpdater.setUncaughtExceptionHandler((t, e) -> caughtException.set(e));

        // Make dataService throw ContainerNotAvailableException

        }
        return artifactRepositoryFactory.createArtifactRepository(
                repositoryId, url, repositoryLayout, snapshots, releases);
    }

    private static String getMessage(Throwable error, String def) {
        if (error == null) {
            return def;
        }
        String msg = error.getMessage();
        if (msg != null && !msg.isEmpty()) {
            return msg;
        }

    }
    Object arg = generator.generateFresh(param.getType());
    if (arg == null) {
      throw new ParameterNotInstantiableException(param);
    }
    return arg;
  }

  private static <X extends Throwable> void throwFirst(List<X> exceptions) throws X {
    if (!exceptions.isEmpty()) {
      throw exceptions.get(0);
    }
  }

  /** Factories with the least number of parameters are listed first. */

        if (StringUtil.isEmpty(className)) {
            return null;
        }
        try {
            return (Class<T>) Class.forName(className, true, loader);
        } catch (final Throwable ignore) {
            return null;
        }
    }

    /**
     * If the class is a primitive type, returns its wrapper class.
     *
     * @param className

## Version 3.14.4

_2019-09-29_

 *  Fix: Cancel calls that fail due to unexpected exceptions. We had a bug where an enqueued call
    would never call back if it crashed with an unchecked throwable, such as a
    `NullPointerException` or `OutOfMemoryError`. We now call `Callback.onFailure()` with an
    `IOException` that reports the call as canceled. The triggering exception is still delivered to

          webSocket: WebSocket,
          code: Int,
          reason: String,
        ) = TODO()

        override fun onFailure(
          webSocket: WebSocket,
          t: Throwable,
          response: Response?,
        ) = TODO()
      }
  }

  private fun newCookieHandler(): CookieHandler =
    object : CookieHandler() {
      override fun put(
        uri: URI?,

            servletContext.setSessionTrackingModes(
                    fessConfig.getSessionTrackingModesAsSet().stream().map(SessionTrackingMode::valueOf).collect(Collectors.toSet()));
        } catch (final Throwable t) {
            logger.warn("Failed to set SessionTrackingMode.", t);
        }

        split(fessConfig.getQueryFacetQueries(), "\n").of(stream -> stream.map(String::trim).filter(StringUtil::isNotEmpty).forEach(s -> {

    }

    taskRunner.newQueue().execute(toString(), cancelable = false) {
      try {
        logger.fine("$this starting to accept connections")
        acceptConnections()
      } catch (e: Throwable) {
        logger.log(Level.WARNING, "$this failed unexpectedly", e)
      }

      // Release all sockets and all threads, even if any close fails.
      serverSocket?.closeQuietly()