You can override these exception handlers with your own.

### Override request validation exceptions { #override-request-validation-exceptions }

When a request contains invalid data, **FastAPI** internally raises a `RequestValidationError`.

And it also includes a default exception handler for it.

        assertNull(queryParseException.getCause());
        // getMessage() may return null when constructed with null
        // This is expected behavior for exceptions with null cause
    }

    @Test
    public void test_nestedCause() {
        // Test with nested exceptions
        RuntimeException rootCause = new RuntimeException("Root cause");
        ParseException parseException = new ParseException("Parse error");

 */

package jcifs.smb;

/**
 * This class can be extended by applications that wish to trap authentication related exceptions and automatically
 * retry the exceptional operation with different credentials. Read <a href="../../../authhandler.html">jCIFS Exceptions
 * and NtlmAuthenticator</a> for complete details.
 */

/**
 * An abstract class for NTLM authentication.

 *   <li>{@link org.apache.maven.api.model.Build} - Contains build configuration information</li>
 *   <li>{@link org.apache.maven.api.model.Profile} - Represents a build profile for conditional execution</li>
 * </ul>
 *
 * @since 4.0.0
 */

 * under the License.
 */
package org.apache.maven.lifecycle.internal;

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;

import org.apache.maven.execution.ProjectDependencyGraph;
import org.apache.maven.lifecycle.internal.builder.BuilderCommon;
import org.apache.maven.project.MavenProject;

/**
 * Contains status information that is global to an entire reactor build.
 *

 * under the License.
 */

/**
 * Defines core service interfaces that provide essential Maven functionality such as
 * artifact resolution, dependency management, and build execution. These services
 * form the backbone of Maven's extensible architecture.
 *
 * @since 4.0.0
 */

   *   }
   * }
   * }
   *
   * @param closeable the {@code Closeable} object to be closed, or null, in which case this method
   *     does nothing
   * @param swallowIOException if true, don't propagate IO exceptions thrown by the {@code close}
   *     methods
   * @throws IOException if {@code swallowIOException} is false and {@code close} throws an {@code
   *     IOException}.
   */
  /*

    PLATFORM {
      @GwtIncompatible
      @J2ktIncompatible
      @Override
      // returns the types available in "normal" environments
      ImmutableMap<Class<? extends Throwable>, Predicate<Throwable>> exceptions() {
        return ImmutableMap.of(
            InvocationTargetException.class,
            e -> e instanceof InvocationTargetException,
            StackOverflowError.class,

        // Should not throw - errors should be logged but not propagated
        try {
            method.invoke(authenticator, null, groups, roles, groupIds);
            Thread.sleep(200); // Wait for async execution
        } catch (Exception e) {
            // Exception in async task is expected and should be caught internally
        }

        assertTrue("Method should handle errors gracefully", true);
    }

 */
package org.codelibs.fess.util;

import java.util.function.Consumer;

import org.codelibs.fess.Constants;

/**
 * A wrapper class that manages a system process for job execution.
 * This class provides access to the underlying process and manages
 * the input stream thread for capturing process output.
 */
public class JobProcess {
    /**
     * The underlying system process.
     */