import jcifs.dcerpc.rpc;

/**
 * MSRPC implementation for opening a domain handle.
 * This class provides functionality to open a handle to a SAM domain
 * using the SAMR RPC interface.
 */
public class MsrpcSamrOpenDomain extends samr.SamrOpenDomain {

    /**
     * Creates a new request to open a domain handle.
     *
     * @param handle the SAM policy handle
     * @param access the desired access rights

event.replace(stripNameRegex, '')\n  return customEvents[event] || event\n}\n\nconst EventHandler = {\n  on(element, event, handler, delegationFunction) {\n    addHandler(element, event, handler, delegationFunction, false)\n  },\n\n  one(element, event, handler, delegationFunction) {\n    addHandler(element, event, handler, delegationFunction, true)\n  },\n\n  off(element, originalTypeEvent, handler, delegationFunction) {\n    if (typeof originalTypeEvent !== 'string' || !element) {\n      return\n    }\n\n ...

    }

    @Test
    @DisplayName("Should handle null file ID")
    void testSetNullFileId() {
        // Given
        RequestWithFileId request = new Smb2CloseRequest(mockConfig, testFileId);

        // When & Then - should handle null gracefully (implementation dependent)
        assertDoesNotThrow(() -> request.setFileId(null), "Should handle null file ID without throwing exception");
    }

    @Test

/**
 * Microsoft RPC SAM close handle request.
 * This class implements the SAMR close handle operation.
 *
 * @author mbechler
 */
public class MsrpcSamrCloseHandle extends samr.SamrCloseHandle {

    /**
     * Creates a new request to close a SAM handle.
     *
     * @param handle the policy handle to close
     */
    public MsrpcSamrCloseHandle(final policy_handle handle) {
        super(handle);

     */
    public static final int SMB2_LEASE_READ_CACHING = 0x01;

    /**
     * Handle caching lease (H)
     */
    public static final int SMB2_LEASE_HANDLE_CACHING = 0x02;

    /**
     * Write caching lease (W)
     */
    public static final int SMB2_LEASE_WRITE_CACHING = 0x04;

    /**
     * Read and Handle caching (RH)
     */
    public static final int SMB2_LEASE_READ_HANDLE = 0x03;

    /**

        }
    }

  fun enable(
    loggerClass: String,
    handler: Handler = logHandler(),
  ): Closeable {
    val logger = Logger.getLogger(loggerClass)
    if (configuredLoggers.add(logger)) {
      logger.addHandler(handler)
      logger.level = Level.FINEST
    }
    return Closeable {
      logger.removeHandler(handler)
    }
  }

  fun enable(loggerClass: KClass<*>) = enable(loggerClass.java.name)

package jcifs.dcerpc.msrpc;

/**
 * MSRPC implementation for opening an alias handle.
 * This class provides functionality to open a handle to a SAM alias
 * (local group) using the SAMR RPC interface.
 */
public class MsrpcSamrOpenAlias extends samr.SamrOpenAlias {

    /**
     * Creates a new request to open an alias handle.
     *
     * @param handle the domain handle
     * @param access the desired access rights

        @Test
        @DisplayName("Should handle null hash algorithms")
        void testNullHashAlgorithms() {
            context = new PreauthIntegrityNegotiateContext(mockConfig, null, new byte[16]);

            assertNull(context.getHashAlgos());
            assertEquals(20, context.size()); // 4 header + 16 salt
        }

        @Test
        @DisplayName("Should handle null salt")
        void testNullSalt() {

package jcifs.internal.smb2.persistent;

/**
 * Enumeration of SMB2/3 handle types supporting durability and persistence.
 */
public enum HandleType {
    /**
     * No durability - standard handle
     */
    NONE(0),

    /**
     * SMB 2.1 durable handle - survives network loss
     */
    DURABLE_V1(1),

    /**
     * SMB 3.0 durable handle V2 - with timeout configuration
     */
    DURABLE_V2(2),

     * @param handler
     *            The SAX {@link DefaultHandler} to use. Must not be {@literal null}.
     */
    public static void parse(final SAXParser parser, final InputSource inputSource, final DefaultHandler handler) {
        assertArgumentNotNull("parser", parser);
        assertArgumentNotNull("inputSource", inputSource);
        assertArgumentNotNull("handler", handler);

        try {