CountDownLatch latch = new CountDownLatch(threadCount);
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        AtomicInteger successCount = new AtomicInteger(0);
        AtomicInteger failureCount = new AtomicInteger(0);

        for (int t = 0; t < threadCount; t++) {
            final int threadId = t;
            executor.submit(() -> {
                try {

    private final Map<String, AccountAttempts> accountAttempts = new ConcurrentHashMap<>();
    private final Map<String, IpAttempts> ipAttempts = new ConcurrentHashMap<>();
    private final AtomicInteger globalAttemptsInCurrentWindow = new AtomicInteger(0);
    private final AtomicLong currentWindowStart = new AtomicLong(System.currentTimeMillis());

    // Cleanup scheduler
    private final ScheduledExecutorService cleanupScheduler;

      }
    };

    abstract Executor executor();
  }

  @Param Impl impl;
  Executor executor;

  static final class CountingRunnable implements Runnable {
    AtomicInteger integer = new AtomicInteger();

    @Override
    public void run() {
      integer.incrementAndGet();
    }
  }

  CountingRunnable countingRunnable = new CountingRunnable();

        coordinatorHelper.dispatchEvent(event);

        assertTrue(called.get());
    }

    @Test
    public void test_addEventHandler_multipleHandlers() {
        final AtomicInteger count = new AtomicInteger(0);
        coordinatorHelper.addEventHandler("config_updated", event -> count.incrementAndGet());
        coordinatorHelper.addEventHandler("config_updated", event -> count.incrementAndGet());

   * it can fail here.
   */
  public void testAnonymous() {
    AtomicReference<String> holder = new AtomicReference<>();
    AtomicInteger deliveries = new AtomicInteger();
    EventBus bus = new EventBus();
    bus.register(
        new Object() {
          @Subscribe
          public void accept(String str) {
            holder.set(str);

 */
public class TcpMemoryRegion extends RdmaMemoryRegion {

    private static final AtomicInteger keyGenerator = new AtomicInteger(1000);

    /**
     * Create new TCP memory region
     *
     * @param buffer memory buffer
     * @param access access permissions (ignored for TCP)
     */
    public TcpMemoryRegion(ByteBuffer buffer, EnumSet<RdmaAccess> access) {

            final int attemptsPerThread = 5;

            Thread[] threads = new Thread[numThreads];
            final AtomicInteger successfulThreads = new AtomicInteger(0);
            final AtomicInteger blockedAttempts = new AtomicInteger(0);
            final AtomicInteger exceptionCount = new AtomicInteger(0);

            for (int i = 0; i < numThreads; i++) {
                final int threadId = i;

   * it can fail here.
   */
  public void testAnonymous() {
    AtomicReference<String> holder = new AtomicReference<>();
    AtomicInteger deliveries = new AtomicInteger();
    EventBus bus = new EventBus();
    bus.register(
        new Object() {
          @Subscribe
          public void accept(String str) {
            holder.set(str);

   * access to the most-recently received one.
   */
  static class CountingRemovalListener<K, V> implements RemovalListener<K, V> {
    private final AtomicInteger count = new AtomicInteger();
    private volatile @Nullable RemovalNotification<K, V> lastNotification;

    @Override
    public void onRemoval(RemovalNotification<K, V> notification) {
      count.incrementAndGet();

  public void testRunIdempotency() throws Exception {
    int numThreads = 10;
    ExecutorService executor = newFixedThreadPool(numThreads);
    for (int i = 0; i < 1000; i++) {
      AtomicInteger counter = new AtomicInteger();
      TrustedListenableFutureTask<Integer> task =
          TrustedListenableFutureTask.create(counter::incrementAndGet);
      CyclicBarrier barrier = new CyclicBarrier(numThreads + 1);