*/
public class DisniMemoryRegion extends RdmaMemoryRegion {

    private static final Logger log = LoggerFactory.getLogger(DisniMemoryRegion.class);
    private static final AtomicInteger keyGenerator = new AtomicInteger(2000);
    private static final AtomicLong addressCounter = new AtomicLong(0x10000000L);
    private static final Map<ByteBuffer, Long> bufferAddresses = new ConcurrentHashMap<>();

        Client client = runner.client();
        SuggestSettings settings = suggester.settings();
        int num = 9999;

        addDocument(indexName, client, num);

        AtomicInteger count = new AtomicInteger(0);
        Set<String> valueSet = Collections.synchronizedSet(new HashSet<>());
        Thread[] threads = new Thread[threadNum];
        ESSourceReader reader = new ESSourceReader(client, settings, indexName);

        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        CountDownLatch startLatch = new CountDownLatch(1);
        CountDownLatch endLatch = new CountDownLatch(threadCount);
        AtomicInteger successCount = new AtomicInteger(0);
        List<Exception> exceptions = new ArrayList<>();

        // When - Multiple threads get and release buffers
        for (int t = 0; t < threadCount; t++) {
            executor.submit(() -> {

import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Basher test for {@link ConcurrentHashMultiset}: start a bunch of threads, have each of them do

    private final AtomicLong failedHealthChecks = new AtomicLong(0);
    private final AtomicLong connectionsRemoved = new AtomicLong(0);
    private final AtomicInteger activeConnections = new AtomicInteger(0);
    private final Map<String, ConnectionMetrics> connectionMetrics = new ConcurrentHashMap<>();

    // Proactive health monitoring
    private volatile boolean proactiveHealthCheckEnabled = true;

    private final Class<T> interfaceType;
    private final Method method;
    private final @Nullable Object[] passedArgs;
    private final @Nullable Object returnValue;
    private final AtomicInteger called = new AtomicInteger();

    InteractionTester(Class<T> interfaceType, Method method) {
      this.interfaceType = interfaceType;
      this.method = method;
      this.passedArgs = getParameterValues(method);

        final CountDownLatch startLatch = new CountDownLatch(1);
        final CountDownLatch doneLatch = new CountDownLatch(threadCount);
        final AtomicInteger successCount = new AtomicInteger(0);
        final AtomicInteger failureCount = new AtomicInteger(0);
        final List<Exception> exceptions = new ArrayList<>();

        // Create multiple threads that all try to connect simultaneously

        rule.addCondition("url", "https://.*\\.example\\.com/.*");

        final int threadCount = 10;
        final int matchesPerThread = 100;
        final AtomicInteger matchCount = new AtomicInteger(0);
        final AtomicInteger noMatchCount = new AtomicInteger(0);
        final List<Exception> exceptions = new ArrayList<>();

        Thread[] threads = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {

    private LoadBalancingStrategy strategy;
    private final AtomicInteger roundRobinCounter;

    /**
     * Create channel load balancer
     *
     * @param manager channel manager
     */
    public ChannelLoadBalancer(ChannelManager manager) {
        this.manager = manager;
        this.strategy = LoadBalancingStrategy.ADAPTIVE;
        this.roundRobinCounter = new AtomicInteger(0);
    }

    /**

     */
    public static class ChannelGroup {
        private final String sessionId;
        private final List<ChannelInfo> channels = new CopyOnWriteArrayList<>();
        private final AtomicInteger roundRobinIndex = new AtomicInteger(0);
        private volatile ChannelInfo primaryChannel;

        public ChannelGroup(String sessionId) {
            this.sessionId = sessionId;
        }

        public String getSessionId() {