}

    // Test isUseTimeZoneHandling() method
    public void test_isUseTimeZoneHandling() {
        // Verify that time zone handling is disabled
        assertFalse(provider.isUseTimeZoneHandling());
    }

    // Test isAcceptCookieTimeZone() method
    public void test_isAcceptCookieTimeZone() {
        // Verify that cookie time zone is not accepted
        assertFalse(provider.isAcceptCookieTimeZone());
    }

        int bytesConsumed = response.decode(buffer, 0, 28);

        // Verify
        assertEquals(28, bytesConsumed, "Should consume exactly 28 bytes");

        byte[] resumeKey = response.getResumeKey();
        assertNotNull(resumeKey, "Resume key should not be null");
        assertEquals(24, resumeKey.length, "Resume key should be 24 bytes");

        // Verify resume key content
        for (int i = 0; i < 24; i++) {

        // Verify search attributes (masked with 0x37)
        assertEquals(0x37, SMBUtil.readInt2(buffer, 0));

        // Verify max items
        assertEquals(100, SMBUtil.readInt2(buffer, 2));

        // Verify flags (should be 0x00)
        assertEquals(0x00, SMBUtil.readInt2(buffer, 4));

        // Verify information level (SMB_FILE_BOTH_DIRECTORY_INFO)

        // Assert: delegate interactions occur when usage transitions happen
        verify(delegate, times(1)).acquire();
        verify(delegate, times(1)).release();
    }

    @Test
    @DisplayName("finalize() invokes checkRelease exactly once")
    void finalize_invokes_checkRelease() throws Throwable {
        // Arrange: spy to verify internal interaction with checkRelease()
        CIFSContext ctx = mock(CIFSContext.class);

            ace.getAccessMask();

            // Different methods called
            ace.isAllow();
            ace.getFlags();

            verify(ace, times(2)).getAccessMask();
            verify(ace, times(1)).isAllow();
            verify(ace, times(1)).getFlags();
        }
    }

    @Nested
    @DisplayName("Real-world Usage Scenarios")
    class RealWorldUsageTests {

        @Test

        Assertions.assertEquals(19L, s);

        Mockito.verify(mock, Mockito.times(1)).getAttributes();
        Mockito.verify(mock, Mockito.times(1)).getCreateTime();
        Mockito.verify(mock, Mockito.times(1)).getLastWriteTime();
        Mockito.verify(mock, Mockito.times(1)).getLastAccessTime();
        Mockito.verify(mock, Mockito.times(1)).getSize();
        Mockito.verifyNoMoreInteractions(mock);
    }

        System.arraycopy(testData, 0, buffer, bufferIndex + 16, testData.length);

        // Decode
        int bytesDecoded = response.decode(buffer, bufferIndex, buffer.length);

        // Verify results
        assertEquals(namedPipeState, response.getNamedPipeState());
        assertEquals(readDataAvailable, response.getReadDataAvailable());
        assertEquals(numberOfMessages, response.getNumberOfMessages());

    }

    @Test
    @DisplayName("Test constructor with Configuration")
    void testConstructor() {
        assertNotNull(response);
        // Verify configuration is set through parent constructor
        verify(mockConfig, atLeastOnce()).getPid();
    }

    @Test
    @DisplayName("Test readParameterWordsWireFormat with zero setup count")

        // Verify bytes written
        assertEquals(24, written);

        // Verify structure size (should be 24)
        assertEquals(24, SMBUtil.readInt2(buffer, offset));

        // Verify close flags (2 bytes at offset+2, should be 0 by default)
        assertEquals(0, SMBUtil.readInt2(buffer, offset + 2));

        // Verify Reserved (4 bytes at offset+4, should be 0)

        // Verify lengths
        assertEquals(2, setupWritten);
        assertEquals(6, paramWritten);
        assertEquals(56, dataWritten); // 50 + 6 padding

        // Verify setup content
        assertEquals(SmbComTransaction.TRANS2_SET_FILE_INFORMATION, setupBuffer[0]);
        assertEquals(0x00, setupBuffer[1]);

        // Verify parameter content