}

  public void testBasics() {
    AtomicInteger totalCalls = new AtomicInteger();
    Runnable intCounter =
        new Runnable() {
          @Override
          public void run() {
            totalCalls.incrementAndGet();
            // Make sure that no other tasks are scheduled to run while this is running.
            assertFalse(fakePool.hasNext());
          }
        };

    assertFalse(fakePool.hasNext());

        requestsSent.incrementAndGet();
    }

    /**
     * Increment requests received counter
     */
    public void incrementRequestsReceived() {
        requestsReceived.incrementAndGet();
    }

    /**
     * Increment error counter
     */
    public void incrementErrors() {
        errors.incrementAndGet();
    }

    /**

                                blockedAttempts.incrementAndGet();
                                break; // Stop trying if account is locked
                            }

                            if (!allowed) {
                                // Rate limited but not locked out
                                blockedAttempts.incrementAndGet();
                                continue;
                            }

                                }
                                return "success";
                            });
                            successCount.incrementAndGet();
                        } catch (Exception e) {
                            failureCount.incrementAndGet();
                        }
                    }
                } finally {
                    latch.countDown();
                }
            });

        private static AtomicInteger instanceCounter = new AtomicInteger(0);
        private final int id;
        private boolean destroyed = false;

        public TestComponent() {
            this.id = instanceCounter.incrementAndGet();
        }

        public int getId() {
            return id;
        }

        public boolean isDestroyed() {
            return destroyed;
        }

        public void destroy() {

                        successCount.incrementAndGet();
                    } catch (RuntimeException e) {
                        failureCount.incrementAndGet();
                    } catch (Exception e) {
                        // Other exceptions also count as failures in this context
                        failureCount.incrementAndGet();
                    }
                });
            }

            int behavior = random.nextInt(4);
            if (behavior == 0) { // throw an exception
              exceptionCount.incrementAndGet();
              throw new RuntimeException("fake exception for test");
            } else if (behavior == 1) { // return null
              computeNullCount.incrementAndGet();
              return null;
            } else if (behavior == 2) { // slight delay before returning

        public TestTransformer(String name) {
            this.name = name;
        }

        @Override
        public ResultData transform(ResponseData responseData) {
            transformCallCount.incrementAndGet();
            lastResponseData = responseData;

            if (responseData == null) {
                return null;
            }

            ResultData resultData = new ResultData();

    
    public void recordRegistration() { registrationsActive.incrementAndGet(); }
    public void recordUnregistration() { registrationsActive.decrementAndGet(); }
    public void recordNotification() { notificationsReceived.incrementAndGet(); }
    public void recordFailover() { failoverEvents.incrementAndGet(); }
    public void recordHeartbeat() { heartbeatsSent.incrementAndGet(); }

        return (double) hits / total;
    }
    
    public void recordCacheHit() { cacheHits.incrementAndGet(); }
    public void recordCacheMiss() { cacheMisses.incrementAndGet(); }
    public void recordInvalidation() { cacheInvalidations.incrementAndGet(); }
    public void recordChangeNotification() { changeNotifications.incrementAndGet(); }
}