String wagon, final Exception exception, final int requestType, ArtifactTransferResource artifact) {
        this(wagon, TRANSFER_ERROR, requestType, artifact);

        this.exception = exception;
    }

    public ArtifactTransferResource getResource() {
        return artifact;
    }

    /**
     * @return Returns the exception.
     */
    public Exception getException() {

                assertNotNull(result);
            } catch (Exception e) {
                // Expected behavior when components are not fully initialized
                Throwable cause = e.getCause();
                assertNotNull(cause);
            }
        } catch (Exception e) {
            // Test setup exception is acceptable
            assertNotNull(e);
        }

 *
 */
public class LongConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToLong() throws Exception {
        assertEquals(Long.valueOf("1000"), LongConversionUtil.toLong("1,000"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveLong() throws Exception {
        assertEquals(1000, LongConversionUtil.toPrimitiveLong("1,000"));
    }

    /**

 */
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) {

     */
    public <T> T executeWithRetry(RdmaOperation<T> operation, RdmaConnection connection) throws IOException {
        Exception lastError = null;
        int retryCount = 0;

        while (retryCount <= maxRetries) {
            try {
                return operation.execute();
            } catch (Exception error) {
                lastError = error;
                statistics.recordError();

    private int count;

    private String names = "";

    /**
     * @throws Exception
     */
    @Before
    public void setUp() throws Exception {
        DisposableUtil.dispose();
    }

    /**
     * @throws Exception
     */
    @Test
    public void test1() throws Exception {
        DisposableUtil.add(new TestDisposable("a"));
        assertThat(DisposableUtil.disposables.size(), is(1));

        // When & Then
        SMBProtocolDecodingException exception =
                assertThrows(SMBProtocolDecodingException.class, () -> response.readBytesWireFormat(buffer, 0));
        assertEquals("Expected structureSize = 9", exception.getMessage());
    }

    @Test
    @DisplayName("Should handle empty notification list")
    void testEmptyNotificationList() throws Exception {
        // Given

            logger.debug("Crawling Access Exception at {}", urlQueue.getUrl(), e);
        } else if (e.isInfoEnabled()) {
            logger.info(e.getMessage());
        } else if (e.isWarnEnabled()) {
            logger.warn("Crawling Access Exception at " + urlQueue.getUrl(), e);
        } else if (e.isErrorEnabled()) {
            logger.error("Crawling Access Exception at " + urlQueue.getUrl(), e);
        }
    }

        assertEquals(unicodeFileName, notifications.get(0).getFileName());
    }

    @Test
    @DisplayName("Test readParametersWireFormat with non-aligned nextEntryOffset throws exception")
    void testReadParametersWireFormatNonAlignedOffset() throws Exception {
        ByteBuffer buffer = ByteBuffer.allocate(100);
        buffer.order(ByteOrder.LITTLE_ENDIAN);

        // Create notification with non-aligned nextEntryOffset

            } catch (Exception e) {
                // Expected due to missing dependencies in test environment
                assertTrue(true);
                return;
            }
            // Should handle null keywords gracefully
            assertNotNull(functionBuilders);
        } catch (Exception e) {
            // May throw exception due to null handling
            assertNotNull(e);