assertEquals("_default:fess", clauses.get(0).query().toString());
        assertEquals(Occur.MUST, clauses.get(0).occur());
        assertEquals(TermQuery.class, clauses.get(1).query().getClass());
        assertEquals("_default:codelibs", clauses.get(1).query().toString());
        assertEquals(Occur.MUST, clauses.get(1).occur());

        query = queryParser.createDefaultFilterChain().parse("fess AND codelibs");

 *  3. Attempt plans from prior connect attempts for this call. These occur as either follow-ups to
 *     failed connect attempts (such as trying the next [ConnectionSpec]), or as attempts that lost
 *     a race in fast follow-up.
 *
 *  4. If there's no existing connection, make a list of routes (which may require blocking DNS
 *     lookups) and attempt new connections to them. When failures occur, retries iterate the
 *     list of available routes.
 *

    val responseB = client.newCall(requestB).execute()
    assertThat(responseB.body.string()).isEqualTo("b")
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)
  }

  /** Confirm suppressed exceptions that occur while connecting are returned. */
  @Test fun connectExceptionsAreReturnedAsSuppressed() {
    val proxySelector = RecordingProxySelector()
    proxySelector.proxies.add(Proxy(Proxy.Type.HTTP, TestUtil.UNREACHABLE_ADDRESS_IPV4))

            Class<? extends RootAction> actionClass2 = exception2.getActionClass();
            assertNotNull(actionClass2);

            // No ClassCastException should occur
        } catch (ClassCastException e) {
            fail("ClassCastException should not occur: " + e.getMessage());
        }
    }

    @Test
    public void test_genericTypeSafety_verifyInheritance() {

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * The SuggestWriterResult class is used to store and manage the results of a suggest writer operation.
 * It keeps track of any failures that occur during the operation.
 */
public class SuggestWriterResult {
    /**
     * Constructs a new {@link SuggestWriterResult}.
     */
    public SuggestWriterResult() {
        // nothing
    }

    /**

package jcifs.smb1.util.transport;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;

/**
 * Exception thrown when transport-level errors occur in JCIFS SMB communication.
 */
public class TransportException extends IOException {

    /** The root cause exception */
    private Throwable rootCause;

    /**
     * Constructs a new TransportException with no detail message.
     */

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs;

/**
 * Base for all checked exceptions used by this library
 *
 *
 * These should only occur under very rare circumstances.
 *
 * @author mbechler
 *
 */
public class RuntimeCIFSException extends RuntimeException {

    /**
     *
     */

import org.lastaflute.web.Execute;
import org.lastaflute.web.response.HtmlResponse;

/**
 * Action class for handling general error pages.
 * This action displays error pages when unhandled exceptions occur
 * during search operations or page navigation.
 */
public class ErrorAction extends FessSearchAction {

    /**
     * Default constructor for ErrorAction.
     */
    public ErrorAction() {
        super();

 */
package jcifs.util.transport;

import jcifs.CIFSException;

/**
 * Exception class for transport layer errors.
 * This exception is thrown when transport-related communication errors occur.
 */
public class TransportException extends CIFSException {

    /**
     *
     */
    private static final long serialVersionUID = 3743631204022885618L;

    /**

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.exception;

/**
 * Exception thrown when GSA (Google Search Appliance) configuration errors occur.
 * This exception extends FessSystemException and is used to handle specific
 * configuration-related issues when working with GSA integration.
 *
 */
public class GsaConfigException extends FessSystemException {