@J2ktIncompatible
public class ThreadFactoryBuilderTest extends TestCase {
  private final Runnable monitoredRunnable = () -> completed = true;

  private static final UncaughtExceptionHandler UNCAUGHT_EXCEPTION_HANDLER =
      (thread, throwable) -> {};

  private ThreadFactoryBuilder builder;
  private volatile boolean completed = false;

  @Override
  public void setUp() {
    builder = new ThreadFactoryBuilder();
  }

            }
        };

        CountDownLatch latch = new CountDownLatch(1);
        AtomicReference<SuggestIndexResponse> responseRef = new AtomicReference<>();
        AtomicReference<Throwable> errorRef = new AtomicReference<>();

        Deferred<SuggestIndexResponse>.Promise promise = suggester.indexer().indexFromQueryLog(emptyReader, 10, 0);

        promise.then(response -> {

     * @param error the error that triggered renewal
     * @return whether new credentials are obtained
     */
    boolean renewCredentials(String locationHint, Throwable error);

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

    @Test
    public void test_serialVersionUID() {
        // Test that the exception has a serialVersionUID field
        FessUserNotFoundException exception1 = new FessUserNotFoundException("user1");

  ) : InvocationHandler {
    /** Set when remote peer notifies ALPN is unsupported. */
    var unsupported: Boolean = false

    /** The protocol the server selected. */
    var selected: String? = null

    @Throws(Throwable::class)
    override fun invoke(
      proxy: Any,
      method: Method,
      args: Array<Any>?,
    ): Any? {
      val callArgs = args ?: arrayOf<Any?>()
      val methodName = method.name

            fail("Should have thrown an exception for unregistered class");
        } catch (Exception e) {
            // Find the root cause - it should be related to unregistered class
            Throwable rootCause = e;
            while (rootCause.getCause() != null && rootCause.getCause() != rootCause) {
                rootCause = rootCause.getCause();
            }
            String message = rootCause.getMessage();

            return null;
        }

        @Override
        public void log(String msg) {
        }

        @Override
        public void log(String message, Throwable throwable) {
        }

        @Override
        public String getServerInfo() {
            return null;
        }

        @Override
        public String getInitParameter(String name) {

        response.closeQuietly()
        throw IOException("Canceled")
      }
      return response
    } catch (e: IOException) {
      calledNoMoreExchanges = true
      throw noMoreExchanges(e) as Throwable
    } finally {
      if (!calledNoMoreExchanges) {
        noMoreExchanges(null)
      }
    }
  }

  /**

            events.add(new LogNotificationEvent(((Number) source.get("timestamp")).longValue(), (String) source.get("level"),
                    (String) source.get("loggerName"), (String) source.get("message"), (String) source.get("throwable")));
            docIds.add(hit.getId());
        }

        final int maxDetailsLength = fessConfig.getLogNotificationMaxDetailsLengthAsInteger();

      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 {