/**
 * Represents a witness registration response as defined in MS-SWN specification.
 * Contains the result of a witness registration request.
 */
public class WitnessRegisterResponse {
    /**
     * Creates a new witness register response.
     */
    public WitnessRegisterResponse() {
        // Default constructor
    }

    private String registrationId;
    private int returnCode;

        MsrpcShareInfo1(final srvsvc.ShareInfo1 info1) {
            this.netName = info1.netname;
            this.type = info1.type;
            this.remark = info1.remark;
        }
    }

    /**
     * Creates a new request to enumerate shares on a server.
     *
     * @param server the server name to enumerate shares from
     */
    public MsrpcShareEnum(final String server) {

import java.util.concurrent.Callable;
import java.util.concurrent.RunnableFuture;
import org.jspecify.annotations.Nullable;

/**
 * Abstract {@link ListeningExecutorService} implementation that creates {@link ListenableFuture}
 * instances for each {@link Runnable} and {@link Callable} submitted to it. These tasks are run
 * with the abstract {@link #execute execute(Runnable)} method.
 *

    /** Map of path prefixes to SMB authentication configurations. */
    private final Map<String, SmbAuthentication> authMap = new HashMap<>();

    /**
     * Creates a new SmbAuthenticationHolder instance.
     */
    public SmbAuthenticationHolder() {
        super();
    }

    /**
     * Adds an SMB authentication configuration to the holder.
     *

 *
 * @since 3.9.9
 * @deprecated since 4.0.0, use {@code maven-api-impl} jar instead
 */
@Deprecated(since = "4.0.0")
public final class RequestTraceHelper {

    /**
     * Method that creates some informational string based on passed in {@link RequestTrace}. The contents of request
     * trace can literally be anything, but this class tries to cover "most common" cases that are happening in Maven.
     */

 *
 * @since 4.0.0
 */
@Experimental
public class ModelBuilderException extends MavenException {

    private final ModelBuilderResult result;

    /**
     * Creates a new exception from the specified interim result and its associated problems.
     *
     * @param result The interim result, may be {@code null}.
     */
    public ModelBuilderException(ModelBuilderResult result) {

// Match - returns TargetIDSet matching object name and event name in rules map.
func (rulesMap RulesMap) Match(eventName Name, objectName string) TargetIDSet {
	return rulesMap[eventName].Match(objectName)
}

// NewRulesMap - creates new rules map with given values.
func NewRulesMap(eventNames []Name, pattern string, targetID TargetID) RulesMap {
	// If pattern is empty, add '*' wildcard to match all.
	if pattern == "" {
		pattern = "*"
	}

        // Set MID to 0
        transaction.setMid(0);

        // Create cancel request
        CommonServerMessageBlockRequest cancelRequest = transaction.createCancel();

        // Verify it still creates a valid cancel request
        assertNotNull(cancelRequest);
        assertTrue(cancelRequest instanceof SmbComNtCancel);
        assertEquals(0, cancelRequest.getMid());
    }

    @Test

    private byte[] tmp = new byte[1];

    SmbFile file;

    private boolean largeReadX;

    private final boolean unsharedFile;

    private boolean smb2;

    /**
     * Creates an input stream for reading from the specified SMB URL
     *
     * @param url the SMB URL to read from
     * @param tc
     *            context to use
     * @throws SmbException if an SMB error occurs

)

// AlignedBytePool is a pool of fixed size aligned blocks
type AlignedBytePool struct {
	size int
	p    bpool.Pool[*[]byte]
}

// NewAlignedBytePool creates a new pool with the specified size.
func NewAlignedBytePool(sz int) *AlignedBytePool {
	return &AlignedBytePool{size: sz, p: bpool.Pool[*[]byte]{New: func() *[]byte {
		b := disk.AlignedBlock(sz)
		return &b
	}}}
}