// Mock successful but empty response
        when(treeHandle.send(any(), any(), (RequestParam[]) any())).thenAnswer(invocation -> {
            // The response is the second argument
            Object response = invocation.getArgument(1);
            // Return it unchanged (which will have default values = empty results)
            return response;
        });

 */
public interface SecurityInfo extends Decodable {

    /**
     * Flag indicating that owner security information is requested or being set.
     */
    int OWNER_SECURITY_INFO = 0x1;

    /**
     * Flag indicating that group security information is requested or being set.
     */
    int GROUP_SECURITY_INFO = 0x2;

    /**
     * Flag indicating that discretionary access control list (DACL) information is requested or being set.

     */
    int SID_TYPE_ALIAS = 4;

    /**
     * SID type indicating a well-known group.
     */
    int SID_TYPE_WKN_GRP = 5;

    /**
     * SID type indicating a deleted account.
     */
    int SID_TYPE_DELETED = 6;

    /**
     * SID type indicating an invalid SID.
     */
    int SID_TYPE_INVALID = 7;

    /**

        when(filterConfig.getInitParameterNames()).thenReturn(Collections.enumeration(initParams.keySet()));
        when(filterConfig.getInitParameter(anyString())).thenAnswer(invocation -> initParams.get(invocation.getArgument(0)));

        assertDoesNotThrow(() -> filter.init(filterConfig));
    }

    @Test
    void testInit_withMinimalConfig() throws ServletException {

public class Smb2Lock implements Encodable {

    /**
     * Flag indicating a shared lock that allows concurrent read access.
     */
    public static final int SMB2_LOCKFLAG_SHARED_LOCK = 0x1;

    /**
     * Flag indicating an exclusive lock that prevents any other access.
     */
    public static final int SMB2_LOCKFLAG_EXCLUSIVE_LOCK = 0x2;

    /**
     * Flag indicating an unlock operation to release a previously held lock.
     */

        // Arrange
        String server = "testServer";
        int access = 123;

        // Mock the behavior of sendrecv for MsrpcLsarOpenPolicy2
        doAnswer(invocation -> {
            MsrpcLsarOpenPolicy2 rpc = invocation.getArgument(0);
            rpc.retval = 0; // Simulate success
            return null;
        }).when(mockDcerpcHandle).sendrecv(any(MsrpcLsarOpenPolicy2.class));

        // Act

    void constructor_shouldOpenDomainSuccessfully() throws IOException {
        // Arrange
        int access = 0x01; // Example access value
        // Simulate successful RPC call
        doAnswer(invocation -> {
            MsrpcSamrOpenDomain rpc = invocation.getArgument(0);
            rpc.retval = 0; // Success
            return null;
        }).when(mockDcerpcHandle).sendrecv(any(MsrpcSamrOpenDomain.class));

        // Act

            byte[] buf = new byte[4280]; // Use maxRecv size

            // Mock initial receive with valid PDU header
            when(mockSmbPipeHandleInternal.recv(buf, 0, buf.length)).thenAnswer(invocation -> {
                byte[] buffer = invocation.getArgument(0);
                buffer[0] = 5; // Valid PDU version
                buffer[1] = 0; // Valid PDU type
                Encdec.enc_uint16le((short) 50, buffer, 8); // Fragment length

    /**
     * Named pipe status indicating the pipe is disconnected.
     */
    public static final int STATUS_DISCONNECTED = 1;

    /**
     * Named pipe status indicating the pipe is listening for connections.
     */
    public static final int STATUS_LISTENING = 2;

    /**
     * Named pipe status indicating the connection is established and operational.
     */

 */
public class NegTokenTarg extends SpnegoToken {

    /**
     * Result code indicating unspecified result
     */
    public static final int UNSPECIFIED_RESULT = -1;
    /**
     * Result code indicating authentication completed successfully
     */
    public static final int ACCEPT_COMPLETED = 0;
    /**
     * Result code indicating authentication is incomplete and additional tokens required
     */