}

        assertDoesNotThrow(() -> channelManager.shutdown());
    }

    @Test
    void testConcurrentAccess() throws InterruptedException {
        // Test thread safety
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                channelManager.getChannels();

            assertEquals(4, written);
            assertEquals(4, SMBUtil.readInt2(largeBuffer, 5000));
        }

        @Test
        @DisplayName("Should maintain thread safety")
        void testThreadSafety() throws InterruptedException {
            int threadCount = 10;
            Thread[] threads = new Thread[threadCount];
            boolean[] success = new boolean[threadCount];

        assertEquals(0, stats.consecutiveFailures);
        assertEquals(SimpleCircuitBreaker.State.CLOSED, circuitBreaker.getState());
    }

    @RepeatedTest(10)
    @DisplayName("Test thread safety")
    void testThreadSafety() throws InterruptedException {
        SimpleCircuitBreaker breaker = new SimpleCircuitBreaker("concurrent", 5, 3, 100);
        AtomicInteger successCount = new AtomicInteger(0);

 * <pre>
 * {@code
 * String escapedXml = XmlUtil.escapeXml("<tag>value</tag>");
 * Map<String, Object> dataMap = XmlUtil.getDataMap(accessResultData);
 * }
 * </pre>
 *
 * <h2>Thread Safety:</h2>
 * <p>
 * This class is thread-safe as it does not maintain any state.
 * </p>
 *
 * <h2>Dependencies:</h2>
 * <ul>
 *   <li>org.apache.logging.log4j.Logger</li>
 *   <li>org.apache.logging.log4j.LogManager</li>

  /**
   * Not supported. Use {@link #naturalOrder}, which offers better type-safety, instead. This method
   * exists only to hide {@link ImmutableMultiset#builder} from consumers of {@code
   * ImmutableSortedMultiset}.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Use {@link ImmutableSortedMultiset#naturalOrder}, which offers better type-safety.
   */
  @DoNotCall("Use naturalOrder.")
  @Deprecated

        return ch >= 32 && ch < 127;
    }

    /**
     * Creates a new String from a char array.
     * <p>
     * Note: This method no longer uses internal JDK APIs for safety and compatibility.
     * It now uses the standard String constructor.
     * </p>
     *
     * @param chars
     *            the char array
     * @return a new String, or null if the input is null

            assertTrue(RequestWithFileId.class.isAssignableFrom(impl), impl.getSimpleName() + " should implement RequestWithFileId");
        }
    }

    @Test
    @DisplayName("Should test thread safety of setFileId")
    void testThreadSafety() throws InterruptedException {
        // Given
        RequestWithFileId request = new Smb2CloseRequest(mockConfig, emptyFileId);
        int threadCount = 10;

        byte[] fileNameBytes = fileName.getBytes(StandardCharsets.UTF_16LE);
        int totalSize = 12 + fileNameBytes.length + 50; // Extra space for safety
        byte[] buffer = new byte[totalSize];

        // Write next entry offset (4 bytes)
        SMBUtil.writeInt4(nextOffset, buffer, 0);

        // Write action (4 bytes)

    }

    @Test
    @DisplayName("Test concurrent access")
    void testConcurrentAccess() throws InterruptedException {
        // Test thread safety - multiple threads accessing the same response
        final int THREAD_COUNT = 10;
        Thread[] threads = new Thread[THREAD_COUNT];
        final boolean[] success = new boolean[THREAD_COUNT];

  /**
   * Not supported. Use {@link #naturalOrder}, which offers better type-safety, instead. This method
   * exists only to hide {@link ImmutableMultiset#builder} from consumers of {@code
   * ImmutableSortedMultiset}.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Use {@link ImmutableSortedMultiset#naturalOrder}, which offers better type-safety.
   */
  @DoNotCall("Use naturalOrder.")
  @Deprecated