AtomicBoolean actualIsOccupied = new AtomicBoolean();
    AtomicBoolean actualIsOccupiedByCurrentThread = new AtomicBoolean();
    AtomicInteger actualOccupiedDepth = new AtomicInteger();
    AtomicReference<Throwable> thrown = new AtomicReference<>();
    joinUninterruptibly(
        startThread(
            new Runnable() {
              @Override
              public void run() {
                try {

    AtomicBoolean actualIsOccupied = new AtomicBoolean();
    AtomicBoolean actualIsOccupiedByCurrentThread = new AtomicBoolean();
    AtomicInteger actualOccupiedDepth = new AtomicInteger();
    AtomicReference<Throwable> thrown = new AtomicReference<>();
    joinUninterruptibly(
        startThread(
            new Runnable() {
              @Override
              public void run() {
                try {

        ParseException parseException = new ParseException("Query parsing failed");
        QueryParseException queryParseException = new QueryParseException(parseException);

        Throwable cause = queryParseException.getCause();
        assertNotNull(cause);
        assertTrue(cause instanceof ParseException);
        assertEquals(parseException, cause);

    /**
     * Extracts and returns the stack trace from a throwable as a string.
     * The stack trace is abbreviated if it exceeds the configured maximum length.
     *
     * @param t the throwable to extract the stack trace from
     * @return the stack trace as a string, or empty string if extraction fails
     */
    private String getStackTrace(final Throwable t) {

     */
    public ClUnsupportedOperationException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Creates a {@link ClUnsupportedOperationException}.
     *
     * @param cause the underlying exception
     */
    public ClUnsupportedOperationException(final Throwable cause) {
        super(cause);
    }

   * @param executor the executor that runs {@code fallback} if the input fails
   */
  @J2ktIncompatible
  @Partially.GwtIncompatible("AVAILABLE but requires exceptionType to be Throwable.class")
  public final <X extends Throwable> FluentFuture<V> catching(
      Class<X> exceptionType, Function<? super X, ? extends V> fallback, Executor executor) {
    return (FluentFuture<V>) Futures.catching(this, exceptionType, fallback, executor);

import org.codelibs.fess.unit.UnitFessTestCase;

public class JobProcessingExceptionTest extends UnitFessTestCase {

    public void test_constructor_withCause() {
        // Test constructor with Throwable cause
        final Exception cause = new RuntimeException("Root cause");
        final JobProcessingException exception = new JobProcessingException(cause);

        assertNotNull(exception);

        assertThat(clIllegalStateException.getMessage(), is("hoge"));
    }

    /**
     * Test method for
     * {@link org.codelibs.core.exception.ClIllegalStateException#SIllegalStateException(java.lang.String, java.lang.Throwable)}
     * .
     */
    @Test
    public void testSIllegalStateExceptionStringThrowable() {
        final ClIllegalStateException clIllegalStateException = new ClIllegalStateException("hoge", new NullPointerException());

     * @param message the detail message
     * @param cause the cause of this exception
     */
    public SpnegoException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new SpnegoException with the specified detail message
     * @param message the detail message
     */

     *
     * @param msg the detail message
     * @param rootCause the cause of the exception
     */
    public RequestTimeoutException(final String msg, final Throwable rootCause) {
        super(msg, rootCause);
    }

    /**
     * Constructs a new RequestTimeoutException with the specified detail message.
     *
     * @param msg the detail message
     */