totalValidations.incrementAndGet();

        if (buffer == null) {
            failedValidations.incrementAndGet();
            throw new SmbException("Response buffer is null");
        }

        if (buffer.length < expectedSize) {
            failedValidations.incrementAndGet();
            bufferOverflowsPrevented.incrementAndGet();

  }

  private static void insertIntoReplica(Map<Integer, AtomicInteger> replica, int newValue) {
    if (replica.containsKey(newValue)) {
      replica.get(newValue).incrementAndGet();
    } else {
      replica.put(newValue, new AtomicInteger(1));
    }
  }

  private static void removeMinFromReplica(
      SortedMap<Integer, AtomicInteger> replica, int minValue) {

     * Record an RDMA operation error
     */
    public void recordError() {
        operationErrors.incrementAndGet();
    }

    /**
     * Record a new RDMA connection creation
     */
    public void recordConnectionCreated() {
        connectionsCreated.incrementAndGet();
        connectionsActive.incrementAndGet();
    }

    /**
     * Record RDMA connection closure
     */

        deferred.promise().then(response -> {
            callbackCount.incrementAndGet();
            latch.countDown();
        }).then(response -> {
            callbackCount.incrementAndGet();
            latch.countDown();
        }).then(response -> {
            callbackCount.incrementAndGet();
            latch.countDown();
        });

  }

  private static void insertIntoReplica(Map<Integer, AtomicInteger> replica, int newValue) {
    if (replica.containsKey(newValue)) {
      replica.get(newValue).incrementAndGet();
    } else {
      replica.put(newValue, new AtomicInteger(1));
    }
  }

  private static void removeMinFromReplica(
      SortedMap<Integer, AtomicInteger> replica, int minValue) {

        while ((region = availableSendRegions.poll()) != null) {
            region.close();
            totalReleased.incrementAndGet();
        }

        while ((region = availableReceiveRegions.poll()) != null) {
            region.close();
            totalReleased.incrementAndGet();
        }

            if (ip.isBlocked()) {
                if (ip.getBlockExpiry().isAfter(Instant.now())) {
                    totalAttemptsBlocked.incrementAndGet();
                    totalIpsBlocked.incrementAndGet();
                    log.warn("IP {} is blocked due to excessive attempts", sourceIp);
                    return false;
                } else {
                    // Block expired, reset

                totalBackpressureRejections.incrementAndGet();
                throw new CIFSException("Circuit breaker '" + name + "' rejected request due to backpressure");
            }
        }

        long startTime = System.nanoTime();
        boolean semaphoreAcquired = backpressureEnabled && requestSemaphore != null;

        try {
            activeRequests.incrementAndGet();

            @Override
            public void store(DataStoreParams paramMap, Map<String, Object> dataMap) {
                assertNotNull(paramMap);
                assertNotNull(dataMap);
                docSize.incrementAndGet();
                execTime.addAndGet(100);
            }

            @Override
            public long getDocumentSize() {
                return docSize.get();
            }

            @Override

     */
    public <T> T call(Callable<T> callable, Callable<T> fallback) throws Exception {
        totalCalls.incrementAndGet();

        State currentState = evaluateState();

        if (currentState == State.OPEN) {
            rejectedCalls.incrementAndGet();
            if (fallback != null) {
                log.debug("Circuit breaker {} is open, using fallback", name);