*/
package jcifs.smb;

/**
 * Exception thrown when SMB message signature validation fails.
 * Indicates that the integrity of an SMB message could not be verified.
 *
 * @author mbechler
 *
 */
public class SMBSignatureValidationException extends SmbException {

    /**
     * Default constructor for SMB signature validation exception.
     */
    public SMBSignatureValidationException() {
    }

 *
 */
public class URLUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testEncode() throws Exception {
        assertEquals("Program+Files", URLUtil.encode("Program Files", "UTF-8"));
    }

    /**
     * @throws Exception
     */
    public void testDecode() throws Exception {
        assertEquals("Program Files", URLUtil.decode("Program+Files", "UTF-8"));
    }

    RuntimeException exception = new RuntimeException();
    T proxy =
        Reflection.newProxy(
            interfaceType,
            new AbstractInvocationHandler() {
              @Override
              protected Object handleInvocation(Object p, Method m, @Nullable Object[] args)
                  throws Throwable {
                throw exception;
              }
            });

     *
     * @param actionListener the action listener for handling the response
     * @param exceptionListener the exception listener for handling exceptions
     */
    public void connect(final Consumer<HttpURLConnection> actionListener, final Consumer<Exception> exceptionListener) {
        final Runnable task = () -> {
            final String finalUrl;
            if (paramList != null) {

        final MavenExecutionException exception = assertThrows(
                MavenExecutionException.class,
                () -> sut.getRequiredProjectsBySelectors(mavenExecutionRequest, listOfProjects, selectors));
        assertTrue(exception.getMessage().contains("Could not find"));
        assertTrue(exception.getMessage().contains(":required"));
    }

    @Test

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.core.io.CloseableUtil;
import org.codelibs.fess.Constants;
import org.codelibs.fess.exception.JobNotFoundException;
import org.codelibs.fess.exception.JobProcessingException;
import org.codelibs.fess.util.InputStreamThread;
import org.codelibs.fess.util.JobProcess;

import jakarta.annotation.PreDestroy;

/**

  public void testBuildTesterRequirements_class_notAnnotated() throws Exception {
    class Tester {}

    TesterRequirements requirements = buildTesterRequirements(Tester.class);

    assertThat(requirements.getPresentFeatures()).isEmpty();
    assertThat(requirements.getAbsentFeatures()).isEmpty();
  }

  public void testBuildTesterRequirements_class_empty() throws Exception {
    @Require
    class Tester {}

            int expectedLength = (Math.min(65536, 65536) - Smb2QueryInfoResponse.OVERHEAD) & ~0x7;
            assertEquals(expectedLength, actualOutputBufferLength);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    @DisplayName("Test constructor with Configuration and FileId")
    void testConstructorWithConfigAndFileId() {

 */
package org.codelibs.fess.exception;

/**
 * This exception is thrown when a script engine error occurs.
 */
public class ScriptEngineException extends FessSystemException {

    private static final long serialVersionUID = 1L;

    /**
     * Constructor.
     * @param message The exception message.
     */
    public ScriptEngineException(final String message) {

            try {
                listener.onSuccess(this);
            } catch (Exception ex) {
                log.warn("Listener threw exception", ex);
            }
        }
    }

    private void onFailure(Exception e) {
        onFailure(e, 0);
    }

    private void onFailure(Exception e, long responseTimeMs) {
        State currentState = state.get();