super.setUp();
    hasher = mock(Hasher.class);
    hashFunction = mock(HashFunction.class);
    buffer = new ByteArrayInputStream(testBytes);

    when(hashFunction.newHasher()).thenReturn(hasher);
  }

  public void testRead_putSingleByte() throws Exception {
    HashingInputStream in = new HashingInputStream(hashFunction, buffer);

    int b = in.read();
    assertEquals('y', b);

        // Test that an IOException is thrown if the input stream does not provide enough bytes.
        // Simulate reading less than 6 bytes.
        when(mockInputStream.read(any(byte[].class), anyInt(), anyInt())).thenReturn(5); // Simulate reading only 5 bytes

        SessionRetargetResponsePacket packet = new SessionRetargetResponsePacket();
        byte[] buffer = new byte[6];

        // Create a mock SmbTransportInternal for RdmaTransport
        SmbTransportInternal mockTransport = mock(SmbTransportInternal.class);
        when(mockTransport.isDisconnected()).thenReturn(true);
        when(mockTransport.toString()).thenReturn("MockTransport");

        try (RdmaTransport transport = new RdmaTransport(mockTransport, testContext)) {
            assertNotNull(transport, "Transport should not be null");

        @Test
        @DisplayName("Should return configured file system information class")
        void testGetFileSystemInformationClass() {
            when(mockFileSystemInfo.getFileSystemInformationClass()).thenReturn(FileSystemInformation.FS_SIZE_INFO);

            byte result = mockFileSystemInfo.getFileSystemInformationClass();

            assertEquals(FileSystemInformation.FS_SIZE_INFO, result);

        int decodedValue = 54321;
        // Configure the mock to return a specific value when dec_ndr_long is called
        when(mockNdrBuffer.dec_ndr_long()).thenReturn(decodedValue);

        NdrLong ndrLong = new NdrLong(0); // Initialize with a dummy value

        // Call the decode method
        ndrLong.decode(mockNdrBuffer);

        }
    }

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        when(mockConfig.getMaximumBufferSize()).thenReturn(65535);
        when(mockConfig.getPid()).thenReturn(1234);
        response = new TestSmbComTransactionResponse(mockConfig);
    }

    @Test
    @DisplayName("Test constructor initialization with config only")

    @DisplayName("filter can use SmbFile directory for decision logic")
    void filterCanUseSmbFileForDecision() throws Exception {
        // Stub the getPath method to return a specific value
        when(mockDir.getPath()).thenReturn("/share/folder/");

        // Implementation uses dir.getPath() to check if file should be in that path
        SmbFilenameFilter filter = (dir, name) -> {
            if (dir == null)
                return false;

            // Mock the calculateMac method to return a valid checksum
            byte[] mockChecksum = new byte[16];
            pacMacMock.when(() -> PacMac.calculateMac(anyInt(), any(), any())).thenReturn(mockChecksum);

            // Create a minimal valid PAC structure
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            writeLittleEndianInt(baos, 3); // bufferCount = 3 (minimum required)

        @Mock
        CIFSContext mockCtx;

        @Mock
        SidResolver mockResolver;

        @BeforeEach
        void setup() {
            lenient().when(mockCtx.getSIDResolver()).thenReturn(mockResolver);
        }

        @Test
        @DisplayName("Manual resolve calls resolver with this SID")
        void testResolveManual() throws Exception {
            // Arrange

    }

    @Test
    @DisplayName("initResponse prepares a response instance")
    void initResponseCreatesResponse() {
        SmbComNTCreateAndX req = createRequest(0, 0);
        when(mockContext.getConfig()).thenReturn(mockConfig);
        SmbComNTCreateAndXResponse resp = req.initResponse(mockContext);
        assertNotNull(resp, "Response should not be null after init");
        // getResponse should now return the same instance