} catch (InterruptedException ignore) {}
            deferred.reject(new Exception());
        });
        th.start();

        final CountDownLatch latch = new CountDownLatch(1);
        deferred.promise().error(error -> latch.countDown());
        assertTrue(latch.await(10, TimeUnit.SECONDS));
    }

    @Test
    public void test_doneAfterReject() throws Exception {

    private final byte[] in;
    private int inLen;

    /**
     * Creates a new MimeMap instance by loading MIME type mappings from the resource file.
     *
     * @throws IOException if there is an error reading the mime.map resource file
     */
    public MimeMap() throws IOException {
        int n;

        in = new byte[IN_SIZE];

                        tempFile.getAbsolutePath());
            }
        } catch (final IOException e) {
            logger.warn("Failed to upload backup file: fileName={}, error={}", fileName, e.getMessage(), e);
            if (tempFile.exists() && !tempFile.delete()) {
                logger.warn("Failed to delete temporary file: {}", tempFile.getAbsolutePath());
            }

            state = RdmaConnectionState.CONNECTED;
            log.debug("TCP RDMA connection established to {}", remoteAddress);

        } catch (IOException e) {
            state = RdmaConnectionState.ERROR;
            throw new IOException("TCP RDMA connection failed", e);
        }
    }

    @Override
    public void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException {

 */
package org.codelibs.fess.exception;

import org.apache.lucene.queryparser.classic.ParseException;

/**
 * Exception thrown when a query parsing error occurs.
 * This exception wraps Lucene's ParseException to provide consistent error handling
 * within the Fess search framework.
 *
 */
public class QueryParseException extends FessSystemException {

    /** Serial version UID for serialization compatibility */

                entry.updateState(Smb2LeaseState.SMB2_LEASE_NONE);
            }
            releaseLease(key);
        } catch (Exception e) {
            log.error("Error handling lease break for key: " + key, e);
            // On error, ensure we're in safe state
            LeaseEntry entry = leases.get(key);
            if (entry != null) {
                entry.updateState(Smb2LeaseState.SMB2_LEASE_NONE);

        final String s = props.getProperty(key);
        if (s != null) {
            try {
                def = Integer.parseInt(s);
            } catch (final NumberFormatException nfe) {
                log.error("Not a number", nfe);
            }
        }
        return def;
    }

    /**
     * Retrieve an <code>int</code>. If the property is not found, <code>-1</code> is returned.
     *

     * @param serverChallenge the server challenge bytes
     * @param clientChallenge the client challenge bytes
     * @return the calculated response
     * @throws GeneralSecurityException if a cryptographic error occurs
     */
    public static byte[] getNTLM2Response(final byte[] passwordHash, final byte[] serverChallenge, final byte[] clientChallenge)
            throws GeneralSecurityException {

     * @throws IOException
     *             if a network error occurs
     */

    @Override
    public int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    /**
     * Reads up to len bytes of data from this input stream into an array of bytes.
     *
     * @throws IOException
     *             if a network error occurs
     */

    @Override

     *            taking place.
     * @param flags the flags to use for the Type-3 message
     * @throws GeneralSecurityException if a cryptographic error occurs
     * @throws CIFSException if a CIFS protocol error occurs
     */
    public Type3Message(final CIFSContext tc, final Type2Message type2, final String targetName, final String password, final String domain,