} else if (logger.isInfoEnabled()) {
                logger.info("ThumbnailGenerator is stopped.");
            }
            exitCode = Constants.EXIT_FAIL;
        } catch (final Throwable t) {
            logger.error("ThumbnailGenerator terminated unexpectedly.", t);
            exitCode = Constants.EXIT_FAIL;
        } finally {
            if (systemMonitorTask != null) {

            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) {

@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();
  }

        /**
         * Create exception with cause
         *
         * @param message error message
         * @param cause underlying cause
         */
        public NoAvailableChannelException(String message, Throwable cause) {
            super(message, cause);
        }
    }

        assertNotNull(details);
        assertTrue(details.contains("Total: 1 event(s)"));
        assertTrue(details.contains("Something went wrong"));
        // Throwable is no longer included in summary-oriented format
        // Only log message is shown per event line
    }

    @Test
    public void test_formatDetails_emptyList() {

        }
    }

    @Test
    @DisplayName("Should pass null for SmbAuthException when error is not SmbAuthException")
    void testRenewCredentials_WithErrorNotSmbAuthException() {
        Throwable genericError = new RuntimeException("Generic Error");
        try (MockedStatic<NtlmAuthenticator> mockedNtlmAuthenticator = mockStatic(NtlmAuthenticator.class)) {

            task = withLock {
              afterRun(task, delayNanos, true)
              awaitTaskToRun()
            } ?: return
          }
        } catch (thrown: Throwable) {
          // A task failed. Update execution state and re-throw the exception.
          withLock {
            afterRun(task, -1L, false)
          }
          if (thrown is InterruptedException) {

        public void stop() {
            /* No-op */ }
    }

    private static class FastMockFailureUrlService extends FailureUrlService {
        public void store(DataConfig dataConfig, String errorName, String url, Throwable e) {
            /* No-op */ }
    }

    private static class FastMockSearchEngineClient extends SearchEngineClient {
        @Override
        public long deleteByQuery(String index, QueryBuilder queryBuilder) {

            } else if (logger.isInfoEnabled()) {
                logger.info("Crawler is stopped.");
            }
            exitCode = Constants.EXIT_FAIL;
        } catch (final Throwable t) {
            logger.error("Crawler terminated unexpectedly.", t);
            exitCode = Constants.EXIT_FAIL;
        } finally {
            if (commandThread != null && commandThread.isAlive()) {

    )
    val e = RuntimeException("boom")
    clientListener.setNextEventDelegate(
      object : WebSocketListener() {
        override fun onFailure(
          webSocket: WebSocket,
          t: Throwable,
          response: Response?,
        ): Unit = throw e
      },
    )
    newWebSocket()
    assertThat(testLogHandler.take()).isEqualTo("INFO: [WS client] onFailure")
  }

  @Test