assertNotNull(customResponse);
        assertEquals(SmbComTransaction.TRANS2_SET_FILE_INFORMATION, customResponse.getSubCommand());
    }

    @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];

        logStream.close();
        // After close, the stream should not accept more writes
        // but PrintStream doesn't throw exceptions on write after close
    }

    @Test
    void testConcurrentAccess() throws InterruptedException {
        // Test thread safety of getInstance
        LogStream.setInstance(testStream);

        final LogStream[] instances = new LogStream[10];

            // Expected in test environment without proper server setup
        }

        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(() -> {

            // Then
            assertEquals(4, bytesRead);
        }

        @Test
        @DisplayName("Should handle concurrent access safely")
        void testConcurrentAccess() throws InterruptedException {
            // Given
            byte[] buffer1 = new byte[10];
            byte[] buffer2 = new byte[10];
            SMBUtil.writeInt2(4, buffer1, 0);

        assertArrayEquals(context.getLeaseKey().getKey(), decodedContext.getLeaseKey().getKey());
    }

    @Test
    public void testConcurrentAccess() throws Exception {
        String directoryPath = "/test/concurrent";

        directoryLeaseManager.requestDirectoryLease(directoryPath, DirectoryLeaseState.DIRECTORY_READ_HANDLE,

            // Then
            assertEquals(4, bytesRead);
        }

        @Test
        @DisplayName("Should handle concurrent access safely")
        void testConcurrentAccess() throws InterruptedException {
            // Given
            int threadCount = 10;
            Thread[] threads = new Thread[threadCount];
            boolean[] success = new boolean[threadCount];

        }, "EmptyIterator should work with manual iteration");
    }

    @Test
    @DisplayName("EmptyIterator should handle concurrent access safely")
    void testConcurrentAccess() throws InterruptedException, CIFSException {
        // Given
        final int threadCount = 10;
        final Thread[] threads = new Thread[threadCount];
        final boolean[] results = new boolean[threadCount];

        for (int i = 0; i < 3; i++) {
            assertTrue(rateLimiter.checkAttempt(username, ip));
            rateLimiter.recordFailure(username, ip);
        }
    }

    @Test
    public void testConcurrentAccess() throws Exception {
        // Test thread safety with concurrent access
        // Use a separate rate limiter instance with higher limits for this test

        assertTrue(context instanceof AbstractCIFSContext, "BaseContext should extend AbstractCIFSContext");
    }

    @Test
    @DisplayName("Context should handle concurrent access safely")
    void testConcurrentAccess() throws InterruptedException {
        // Given
        final int threadCount = 10;
        final Thread[] threads = new Thread[threadCount];
        final boolean[] results = new boolean[threadCount];

        assertNotNull(trans2QueryFSInfo);
    }

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

        final int THREAD_COUNT = 10;