public void testRoundIntegralDoubleToInt() {
    for (double d : INTEGRAL_DOUBLE_CANDIDATES) {
      for (RoundingMode mode : ALL_SAFE_ROUNDING_MODES) {
        BigDecimal expected = new BigDecimal(d).setScale(0, mode);
        boolean isInBounds =
            expected.compareTo(MAX_INT_AS_BIG_DECIMAL) <= 0
                & expected.compareTo(MIN_INT_AS_BIG_DECIMAL) >= 0;

        try {

    //                                                                         ===========
    @Override
    public boolean hasPrimaryKey() {
        return false;
    }

    @Override
    public boolean hasCompoundPrimaryKey() {
        return false;
    }

    @Override
    protected UniqueInfo cpui() {
        return null;
    }

            logger.debug("Initializing {}", HcHttpClient.class.getName());
        }

        super.init();

        // robots.txt parser
        final Boolean robotsTxtEnabled = getInitParameter(ROBOTS_TXT_ENABLED_PROPERTY, Boolean.TRUE, Boolean.class);
        if (robotsTxtHelper != null) {
            robotsTxtHelper.setEnabled(robotsTxtEnabled);
        }

        // httpclient

     *
     * @param connection RDMA connection that encountered error
     * @param error the error that occurred
     * @return true if error was handled and connection recovered, false if fallback needed
     */
    public boolean handleRdmaError(RdmaConnection connection, Exception error) {
        log.warn("RDMA error occurred: {}", error.getMessage());
        statistics.recordError();

        if (isRecoverableError(error)) {

        // Test that accessTimeoutTask null check prevents NPE
        S3Client client = new S3Client() {
            @Override
            protected ResponseData processRequest(final String uri, final boolean includeContent) {
                // Skip init() and directly test timeout handling
                org.codelibs.fess.crawler.client.AccessTimeoutTarget accessTimeoutTarget = null;

        }

        public void decrementConnections() {
            activeConnections.decrementAndGet();
        }

        public boolean isHealthy() {
            return isHealthy;
        }

        public void setHealthy(boolean healthy) {
            this.isHealthy = healthy;
            this.lastHealthCheck = System.currentTimeMillis();
        }

     * Checks if the response is successful based on configured HTTP status codes.
     *
     * @param responseData the response data to check
     * @return true if successful, false otherwise
     */
    protected boolean isSuccessful(final ResponseData responseData) {
        if (successfulHttpCodes == null) {
            return true;
        }
        final int httpStatusCode = responseData.getHttpStatusCode();

         * remove() method would remove one of the skipped elements instead of
         * throwing an IllegalStateException.
         */
        return new Iterator<T>() {
          boolean atStart = true;

          @Override
          public boolean hasNext() {
            return iterator.hasNext();
          }

          @Override
          @ParametricNullness
          public T next() {

  private val retryOnConnectionFailure: Boolean,
  private val call: RealCall,
  private val routePlanner: RealRoutePlanner,
  // Specifics to this plan.
  override val route: Route,
  internal val routes: List<Route>?,
  private val attempt: Int,
  private val tunnelRequest: Request?,
  internal val connectionSpecIndex: Int,
  internal val isTlsFallback: Boolean,
) : RoutePlanner.Plan,
  ExchangeCodec.Carrier {

  private val requestQueue = LinkedBlockingQueue<RecordedRequest>()
  private val openClientSockets =
    Collections.newSetFromMap(ConcurrentHashMap<Socket, Boolean>())
  private val openConnections =
    Collections.newSetFromMap(ConcurrentHashMap<Http2Connection, Boolean>())

  private val atomicRequestCount = AtomicInteger()

  private var serverSocketFactory_: ServerSocketFactory? = null