healthCheckExecutor.shutdown();
        try {
            if (!healthCheckExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                healthCheckExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            healthCheckExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // Close all connections without synchronization - concurrent collections are thread-safe

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

        try {
            latch.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            fail("Thread safety test interrupted");
        }

        // In test environment, some operations might not work due to missing request context

        private final int exitValue;

        public TestProcess(int exitValue) {
            this.exitValue = exitValue;
        }

        @Override
        public int waitFor() throws InterruptedException {
            return exitValue;
        }

        @Override
        public int exitValue() {
            return exitValue;
        }

        @Override
        public void destroy() {

                q20.start();

                while (sem.count > 0 && q1x.ans == null && q20.ans == null) {
                    sem.wait();
                }
            }
        } catch (final InterruptedException ie) {
            throw new UnknownHostException(name);
        }
        if (q1x.ans != null) {
            return q1x.ans;
        }
        if (q20.ans != null) {
            return q20.ans;

            }
        }

        @Test
        @DisplayName("Should handle concurrent size calculations")
        void testConcurrentSizeCalculations() throws InterruptedException {
            String path = "\\\\server\\share\\test";
            buffer = new DfsReferralRequestBuffer(path, 3);

            int expectedSize = buffer.size();

        assertNotNull(trans2QueryFSInfo);
    }

    @Test
    @DisplayName("Test concurrent access")
    void testConcurrentAccess() throws InterruptedException {
        trans2QueryFSInfo = new Trans2QueryFSInformation(config, FileSystemInformation.SMB_INFO_ALLOCATION);

        final int THREAD_COUNT = 10;
        Thread[] threads = new Thread[THREAD_COUNT];

        assertNotNull(trans2SetFileInfo);
    }

    @Test
    @DisplayName("Test concurrent access")
    void testConcurrentAccess() throws InterruptedException {
        // Setup mock before creating the object
        when(mockFileInfo.getFileInformationLevel()).thenReturn((byte) FileInformation.FILE_BASIC_INFO);

            val canceledException = IOException("canceled due to $t")
            canceledException.initCause(t)
            responseCallback.onFailure(this@RealCall, canceledException)
          }
          if (t is InterruptedException) {
            Thread.currentThread().interrupt()
          } else {
            throw t
          }
        } finally {
          client.dispatcher.finished(this)
        }
      }
    }

                        // Retry after delay
                        try {
                            Thread.sleep(5000);
                        } catch (InterruptedException ie) {
                            Thread.currentThread().interrupt();
                            break;
                        }
                    }
                }
            }
        });

        
        while (!rdmaConnection.canSend() && System.currentTimeMillis() < deadline) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new IOException("Interrupted waiting for send credit", e);
            }
        }