import org.codelibs.core.exception.ClIllegalArgumentException;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;

/**
 * @author wyukawa
 *
 */
public class BinaryConversionUtilTest {

    /**
     * @see org.junit.rules.ExpectedException
     */
    @Rule
    public ExpectedException exception = ExpectedException.none();

    /**

    }

    @Test
    public void test_serialVersionUID() {
        // Test that the exception is serializable
        ParseException parseException = new ParseException("Serialization test");
        QueryParseException queryParseException = new QueryParseException(parseException);

        // Verify that the exception can be created and has serialVersionUID
        assertNotNull(queryParseException);

    }

    // Test register with null factory throws exception
    @Test
    public void test_register_nullFactory() {
        ComponentUtil.register(null, "scriptEngineFactory");

        try {
            testScriptEngine.register();
            fail("Should throw exception when factory is null");
        } catch (NullPointerException e) {
            // Expected exception
        }
    }

        throw e;
      }
    };
  }

  /** Returns a {@link CacheLoader} that throws the given exception for every request. */
  static <K, V> CacheLoader<K, V> exceptionLoader(Exception e) {
    checkNotNull(e);
    return new CacheLoader<K, V>() {
      @Override
      public V load(K key) throws Exception {
        throw e;
      }
    };
  }

    response: Response,
    hostname: String,
    results: MutableList<InetAddress>,
    failures: MutableList<Exception>,
  ) {
    try {
      val addresses = readResponse(hostname, response)
      synchronized(results) {
        results.addAll(addresses)
      }
    } catch (e: Exception) {
      synchronized(failures) {
        failures.add(e)
      }
    }
  }

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

import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotEmpty;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.util.Map;

import org.codelibs.core.exception.ClIllegalArgumentException;
import org.codelibs.core.message.MessageFormatter;
import org.codelibs.core.misc.DisposableUtil;

/**
 * Logger interface.
 *
 * @author higa
 */
public class Logger {

    @Mock
    private FilterChain filterChain;

    @Mock
    private HttpSession httpSession;

    @Mock
    private ServletOutputStream servletOutputStream;

    @BeforeEach
    void setUp() throws Exception {
        filter = new NtlmHttpFilter();

        // Setup lenient stubs for common mock interactions
        lenient().when(request.getSession()).thenReturn(httpSession);

 */
@GwtCompatible
@NullMarked
public class EvictingQueueTest extends TestCase {

  public void testCreateWithNegativeSize() throws Exception {
    assertThrows(IllegalArgumentException.class, () -> EvictingQueue.create(-1));
  }

  public void testCreateWithZeroSize() throws Exception {
    EvictingQueue<String> queue = EvictingQueue.create(0);
    assertEquals(0, queue.size());

    assertTrue(queue.add("hi"));

import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * @author ricebin
 */
@NullUnmarked
public class MultiReaderTest extends TestCase {

  public void testOnlyOneOpen() throws Exception {
    String testString = "abcdefgh";
    CharSource source = newCharSource(testString);
    int[] counter = new int[1];
    CharSource reader =
        new CharSource() {
          @Override