*
 */
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"));
    }

    /**

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

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

            } 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);

    @Override
    public void setUp() throws Exception {
        super.setUp();
        scriptExecutor = new ScriptExecutor();
        scriptEngineFactory = new ScriptEngineFactory();
        testScriptEngine = new TestScriptEngine();
        ComponentUtil.register(scriptEngineFactory, "scriptEngineFactory");
    }

    @Override
    public void tearDown() throws Exception {

        int dataLen = outputBuffer.length + 100; // Exceeds outputBuffer size

        SMBProtocolDecodingException exception =
                assertThrows(SMBProtocolDecodingException.class, () -> response.readDataWireFormat(buffer, 0, dataLen));

        assertEquals("Payload exceeds buffer size", exception.getMessage());
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 10, 100, 500, 1024 })

                        BufferCache.releaseBuffer(buffer);
                        successCount.incrementAndGet();
                    }
                } catch (Exception e) {
                    synchronized (exceptions) {
                        exceptions.add(e);
                    }
                } finally {
                    endLatch.countDown();
                }
            });
        }

          // by a previous one in the queue being interrupted.
          interruptedDuringTask |= Thread.interrupted();
          try {
            task.run();
          } catch (Exception e) { // sneaky checked exception
            log.get().log(Level.SEVERE, "Exception while executing runnable " + task, e);
          } finally {
            task = null;
          }
        }
      } finally {

import org.codelibs.fess.crawler.entity.RequestData;
import org.codelibs.fess.crawler.entity.ResponseData;
import org.codelibs.fess.crawler.exception.CrawlerSystemException;
import org.codelibs.fess.crawler.exception.MultipleCrawlingAccessException;
import org.dbflute.utflute.core.PlainTestCase;

/**
 * @author shinsuke
 *
 */
public class FaultTolerantClientTest extends PlainTestCase {