double overallTimeMs = (overallEnd - overallStart) / 1_000_000.0;
        double avgThreadTimeMs = totalTime.get() / (threadCount * 1_000_000.0);

        System.out.printf("Connection Pool Performance: %d ops in %.2f ms (%.2f ms avg per thread)%n", successCount.get(), overallTimeMs,
                avgThreadTimeMs);

        // Verify performance improvements

      fail("a call to multiset.setCount() to decrease an element's count should throw");
    } catch (UnsupportedOperationException expected) {
    }
  }

  // Unconditional setCount no-ops.

  private void assertZeroToZero() {
    assertSetCount(e3(), 0);
  }

  private void assertOneToOne() {
    assertSetCount(e0(), 1);
  }

  private void assertThreeToThree() {

            IpAttempts ip = entry.getValue();
            return !ip.isBlocked() && ip.getLastAttempt().plus(cleanupInterval).isBefore(now);
        });

        log.debug("Cleaned up rate limiter entries. Accounts: {}, IPs: {}", accountAttempts.size(), ipAttempts.size());
    }

    /**
     * Manually unlock an account
     *
     * @param username the username to unlock

     * started nor stopped.
     */
    FAILED,
  }

  /**
   * A listener for the various state changes that a {@link Service} goes through in its lifecycle.
   *
   * <p>All methods are no-ops by default, implementors should override the ones they care about.
   *
   * @author Luke Sandberg
   * @since 15.0 (present as an interface in 13.0)
   */
  abstract class Listener {

    @Test
    public void testDifferentIpsIndependent() throws Exception {
        // Different IPs should have independent limits
        for (int i = 1; i <= 3; i++) {
            assertTrue(rateLimiter.checkAttempt("user1", "192.168.1." + i));
            rateLimiter.recordFailure("user1", "192.168.1." + i);
        }

        // All different IPs should still be allowed
        for (int i = 1; i <= 3; i++) {

        private final AtomicLong latencyTotal = new AtomicLong();
        
        public double getAverageLatency() {
            long ops = operations.get();
            if (ops == 0) return 0;
            return (double) latencyTotal.get() / ops;
        }
        
        public long getThroughput() {
            return bytesSent.get() + bytesReceived.get();
        }
    }
    

      fail("a call to multiset.setCount() to decrease an element's count should throw");
    } catch (UnsupportedOperationException expected) {
    }
  }

  // Unconditional setCount no-ops.

  private void assertZeroToZero() {
    assertSetCount(e3(), 0);
  }

  private void assertOneToOne() {
    assertSetCount(e0(), 1);
  }

  private void assertThreeToThree() {

                    }
                } finally {
                    latch.countDown();
                }
            });
        }

        assertTrue(latch.await(10, TimeUnit.SECONDS), "Concurrent ops should complete");
        executor.shutdown();

        assertEquals(threadCount * operationsPerThread, successCount.get(), "All operations should succeed");
    }

    @Test

      // otherwise have another task queued on to it. Note the exception to this, cancellation, is
      // specially handled in execute() - execute() calls triggered by cancellation are no-ops, and
      // thus don't count.
      requireNonNull(sequencer).latestTaskQueue = executingTaskQueue;
      sequencer = null;
      try {
        // requireNonNull is safe, as discussed above.

     * started nor stopped.
     */
    FAILED,
  }

  /**
   * A listener for the various state changes that a {@link Service} goes through in its lifecycle.
   *
   * <p>All methods are no-ops by default, implementors should override the ones they care about.
   *
   * @author Luke Sandberg
   * @since 15.0 (present as an interface in 13.0)
   */
  abstract class Listener {