assertTrue(ex.getMessage().contains("failure"));
        verify(session).getSessionKey();
    }

    // Happy path: transport is returned and verified
    @Test
    @DisplayName("getTransport returns mocked transport")
    void getTransport_happy() {
        when(session.getTransport()).thenReturn(transport);
        assertSame(transport, session.getTransport());
        verify(session).getTransport();
    }

        verify(mockDeferredNdrBuffer).enc_ndr_long(0);
        verify(mockDeferredNdrBuffer).enc_ndr_long(trustInfo.name.length / 2);
        verify(mockDeferredNdrBuffer).advance(2 * (trustInfo.name.length / 2));
        // Verify the derive call
        verify(mockDeferredNdrBuffer).derive(anyInt());
        verify(mockDeferredNdrBuffer, times(5)).enc_ndr_short(0); // Writing 5 shorts with value 0

            // Verify that user information is stored in the session
            verify(session).setAttribute("NtlmHttpAuth", ntlmAuth);
            verify(session).setAttribute("ntlmuser", "user");
            verify(session).setAttribute("ntlmdomain", "TEST_DOMAIN");

            // Verify that the chain continues
            verify(response, never()).setStatus(HttpServletResponse.SC_UNAUTHORIZED);

        // Act
        aliasHandle.close();

        // Assert
        // Verify that sendrecv was called with MsrpcSamrCloseHandle
        verify(mockDcerpcHandle).sendrecv(any(MsrpcSamrCloseHandle.class));
        // Verify that close was called only once on the mockDcerpcHandle for MsrpcSamrCloseHandle
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcSamrCloseHandle.class));
    }

    @Test

        assertTrue(mockResponse.isReceived());

        // Verify the method was called
        verify(mockResponse, times(2)).isReceived();
    }

    @Test
    void testReceived() {
        // Call the method
        mockResponse.received();

        // Verify that the method was called
        verify(mockResponse, times(1)).received();
    }

    @Test
    void testClearReceived() {

        // Then - verify the body was written correctly
        int bodyOffset = headerStart + Smb2Constants.SMB2_HEADER_LENGTH;

        // Verify structure size (25)
        assertEquals(25, SMBUtil.readInt2(buffer, bodyOffset));

        // Verify session binding flag (0x1)
        assertEquals(0x1, buffer[bodyOffset + 2]);

        // Verify security mode

        assertEquals(48, value.length);

        // Verify the size field (first 4 bytes)
        assertEquals(48, (value[0] & 0xFF) | ((value[1] & 0xFF) << 8) | ((value[2] & 0xFF) << 16) | ((value[3] & 0xFF) << 24));
        // Verify the zero field (next 4 bytes)
        assertEquals(0, (value[4] & 0xFF) | ((value[5] & 0xFF) << 8) | ((value[6] & 0xFF) << 16) | ((value[7] & 0xFF) << 24));

        // Verify customData part

        int bytesWritten = info.encode(buffer, 0);

        // Verify replaceIfExists flag
        assertEquals(1, buffer[0]);

        // Verify file name length
        int nameLength = SMBUtil.readInt4(buffer, 16);
        assertEquals(fileName.getBytes(StandardCharsets.UTF_16LE).length, nameLength);

        // Verify file name
        byte[] nameBytes = new byte[nameLength];

        decodedInfo.decode(decodeBuffer);

        // Verify the decoded data matches
        assertEquals(domainInfo.name.length, decodedInfo.name.length);
        assertEquals(domainInfo.name.maximum_length, decodedInfo.name.maximum_length);
        assertNotNull(decodedInfo.name.buffer);
        assertEquals(domainInfo.name.maximum_length / 2, decodedInfo.name.buffer.length);

        // Verify SID
        assertNotNull(decodedInfo.sid);

  }

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

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

    verify(hasher).putByte((byte) 'y');
    verify(hashFunction).newHasher();
    verifyNoMoreInteractions(hashFunction, hasher);
  }

  public void testRead_putByteArray() throws Exception {