} else {
						stopFn(exp, err)
						success = true
						break
					}
				}
				ri.trackMultipleObjectVersions(exp, success)
			}

			// DeleteMultiple objects
			toDelCopy := make([]ObjectToDelete, len(toDel))
			for attempts := 1; attempts <= retryAttempts; attempts++ {
				select {
				case <-ctx.Done():

    @BeforeEach
    public void setUp() {
        // Create rate limiter with test-friendly settings
        rateLimiter = new AuthenticationRateLimiter(3, // max attempts per account
                5, // max attempts per IP
                20, // max global attempts per minute
                Duration.ofSeconds(2), // short lockout for testing
                Duration.ofMinutes(1) // cleanup interval
        );
    }

            } catch (Exception recoveryError) {
                log.warn("RDMA recovery attempt {} failed: {}", retryCount, recoveryError.getMessage());

                // If this was the last attempt, log the full error
                if (retryCount >= maxRetries) {
                    log.error("All RDMA recovery attempts failed", recoveryError);
                }
            }
        }

    }
    assertEquals(expected, actual);
  }

  public void testCorrectOrdering_smallHeapsPollFirst() {
    for (int size = 2; size < 16; size++) {
      for (int attempts = 0; attempts < size * (size - 1); attempts++) {
        ArrayList<Integer> elements = createOrderedList(size);
        List<Integer> expected = ImmutableList.copyOf(elements);
        MinMaxPriorityQueue<Integer> q = MinMaxPriorityQueue.create();

    }

    /**
     * Create rate limiter with custom settings
     *
     * @param maxAttemptsPerAccount max failed attempts per account before lockout
     * @param maxAttemptsPerIp max attempts from single IP
     * @param maxGlobalAttemptsPerMinute max global attempts per minute
     * @param lockoutDuration duration to lock out account/IP
     * @param cleanupInterval interval for cleaning up old entries
     */

            }

            totalRequests.incrementAndGet();

            // Check half-open attempt limit
            if (currentState == State.HALF_OPEN) {
                int attempts = halfOpenAttempts.incrementAndGet();
                if (attempts > halfOpenMaxAttempts) {
                    log.warn("[{}] Exceeded max attempts in HALF_OPEN state, reopening circuit", name);
                    transitionTo(State.OPEN);

        // When/Then - Should retry for attempts 1 and 2
        assertTrue(exception.shouldRetry(1));
        assertTrue(exception.shouldRetry(2));
        assertFalse(exception.shouldRetry(3)); // Max attempts reached

        // Verify exponential backoff
        assertEquals(1000, exception.getRetryDelayMs(1));

    )

    val call = client.newCall(Request(url))
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("hello from IPv6")

    // In the process we made two connection attempts including one failure.
    assertThat(listener.recordedEventTypes().filter { it == "ConnectStart" }).hasSize(1)
    assertThat(listener.recordedEventTypes().filter { it == "ConnectEnd" }).hasSize(1)

T:$MINIO_PORT" ; MC_COMMAND="${MC} config host add myminio $SCHEME://$MINIO_ENDPOINT:$MINIO_PORT $ACCESS $SECRET" ; $MC_COMMAND ; STATUS=$? ; until [ $STATUS = 0 ] do ATTEMPTS=`expr $ATTEMPTS + 1` ; echo \"Failed attempts: $ATTEMPTS\" ; if [ $ATTEMPTS -gt $LIMIT ]; then exit 1 ; fi ; sleep 2 ; # 1 second intervals between attempts $MC_COMMAND ; STATUS=$? ; done ; set -e ; # reset `e` as active return 0 } # checkBucketExists ($bucket) # Check if the bucket exists, by using the exit code of `mc ls`...

T:$MINIO_PORT" ; MC_COMMAND="${MC} config host add myminio $SCHEME://$MINIO_ENDPOINT:$MINIO_PORT $ACCESS $SECRET" ; $MC_COMMAND ; STATUS=$? ; until [ $STATUS = 0 ] do ATTEMPTS=`expr $ATTEMPTS + 1` ; echo \"Failed attempts: $ATTEMPTS\" ; if [ $ATTEMPTS -gt $LIMIT ]; then exit 1 ; fi ; sleep 2 ; # 1 second intervals between attempts $MC_COMMAND ; STATUS=$? ; done ; set -e ; # reset `e` as active return 0 } # checkBucketExists ($bucket) # Check if the bucket exists, by using the exit code of `mc ls`...