}

    public void test_constructor_withMessageAndCause() {
        // Test constructor with message and cause
        String message = "Test exception message with cause";
        Throwable cause = new RuntimeException("Root cause");
        FessSystemException exception = new FessSystemException(message, cause);

        assertEquals(message, exception.getMessage());
        assertEquals(cause, exception.getCause());
    }

    }

    @Override
    public void uncaughtException(Thread t, Throwable e) {
      try {
        logger
            .get()
            .log(
                SEVERE,
                String.format(Locale.ROOT, "Caught an exception in %s.  Shutting down.", t),
                e);
      } catch (Throwable errorInLogging) { // sneaky checked exception
        // If logging fails, e.g. due to missing memory, at least try to log the

            final Map<String, List<String>> map = new HashMap<>();
            headers.entrySet().stream().filter(e -> e.getKey() != null)
                    .forEach(e -> map.put(e.getKey().toLowerCase(Locale.ROOT), e.getValue()));
            this.headers = map;
        }
    }

    /**
     * Gets the headers of the response.
     *
     * @return the headers.
     */

 */
@GwtCompatible
final class Platform {

  /** Format the template with args, only supports the placeholder {@code %s}. */
  static String format(String template, Object... args) {
    return String.format(Locale.ROOT, template, args);
  }

  /** See {@link ListListIteratorTester} */
  static int listListIteratorTesterNumIterations() {
    return 4;
  }

  /** See {@link CollectionIteratorTester} */

 */
public class ScheduledJobException extends FessSystemException {

    private static final long serialVersionUID = 1L;

    /**
     * Constructor.
     * @param message Exception message.
     * @param cause Root cause for this exception.
     */
    public ScheduledJobException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructor.

        }
        assertTrue("CurlException should have serialVersionUID field", hasSerialVersionUID);
    }

    @Test
    public void testExceptionChaining() {
        IOException rootCause = new IOException("Root cause");
        RuntimeException intermediateCause = new RuntimeException("Intermediate", rootCause);
        CurlException exception = new CurlException("Final message", intermediateCause);

       * something. Try to treat it like a RuntimeException. If we overflow the stack again, the
       * resulting Error will propagate upward up to the root call to set().
       */
      setException(e);
      return;
    }

    T transformResult;
    try {
      transformResult = doTransform(localFunction, sourceResult);
    } catch (Throwable t) {

    }

    @Override
    public void uncaughtException(Thread t, Throwable e) {
      try {
        logger
            .get()
            .log(
                SEVERE,
                String.format(Locale.ROOT, "Caught an exception in %s.  Shutting down.", t),
                e);
      } catch (Throwable errorInLogging) { // sneaky checked exception
        // If logging fails, e.g. due to missing memory, at least try to log the

import okhttp3.Request
import okhttp3.tls.HandshakeCertificates
import okhttp3.tls.decodeCertificatePem
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test

/**
 * Test for new Let's Encrypt Root Certificate.
 */
@Tag("Remote")
class LetsEncryptClientTest {
  @Test fun get() {
    // These tests wont actually run before Android 8.0 as per
    // https://github.com/mannodermaus/android-junit5

    assertFalse(Files.isFile().apply(dir));

    assertFalse(Files.isDirectory().apply(asciiFile));
    assertTrue(Files.isFile().apply(asciiFile));
  }

  /** Returns a root path for the file system. */
  private static File root() {
    return File.listRoots()[0];
  }

  /** Returns a {@code File} object for the given path parts. */
  private static File file(String first, String... more) {