assertEquals(jcifs.SID.SID_TYPE_DOM_GRP, s.getType());
    }


    @Test
    public void resolveWellKnownUsers () throws IOException {
        SID domsid = new SID(getRequiredProperty(TestProperties.TEST_DOMAIN_SID));
        int rids[] = new int[] {
            500, 501
        };
        for ( int rid : rids ) {
            SID sid = new SID(domsid, rid);

        }
        if (logger.isDebugEnabled()) {
            logger.debug("Ignored SID: {} {}", type, sid);
        }
        return null;
    }

    public String getAccountId(final jcifs.smb1.smb1.SID sid) {
        final int type = sid.getType();
        if (logger.isDebugEnabled()) {
            try {
                logger.debug("Processing SID: {} {} {}", type, sid, sid.toDisplayString());

import jcifs.smb1.Config;
import jcifs.smb1.util.Hexdump;

class Trans2FindNext2 extends SmbComTransaction {

    private int sid, informationLevel, resumeKey, flags;
    private String filename;

    Trans2FindNext2( int sid, int resumeKey, String filename ) {
        this.sid = sid;
        this.resumeKey = resumeKey;
        this.filename = filename;
        command = SMB_COM_TRANSACTION2;

            if (responseData.getUrl().startsWith("smb:")) {
                final SID[] allowedSids = (SID[]) metaDataMap.get(SmbClient.SMB_ALLOWED_SID_ENTRIES);
                if (allowedSids != null) {
                    for (final SID sid : allowedSids) {
                        final String accountId = sambaHelper.getAccountId(sid);
                        if (accountId != null) {

    val spock = "org.spockframework:spock-core"
    val spockJUnit4 = "org.spockframework:spock-junit4"
    val sshdCore = "org.apache.sshd:sshd-core"
    val sshdOsgi = "org.apache.sshd:sshd-osgi"
    val sshdScp = "org.apache.sshd:sshd-scp"
    val sshdSftp = "org.apache.sshd:sshd-sftp"
    val testcontainersSpock = "org.testcontainers:spock"
    val typesafeConfig = "com.typesafe:config"
    val xerces = "xerces:xercesImpl"

            urlFilterService.delete(sid);
        } catch (final Exception e) {
            logger.warn("Failed to delete UrlFilter for {}", sid, e);
        }

        try {
            // clear queue
            urlQueueService.clearCache();
            urlQueueService.delete(sid);
        } catch (final Exception e) {
            logger.warn("Failed to delete UrlQueue for {}", sid, e);
        }

        try {

import jcifs.internal.util.SMBUtil;
import jcifs.smb.SID;


/**
 * Internal use only
 * 
 * @internal
 */
public class SecurityDescriptor implements SecurityInfo {

    /**
     * Descriptor type
     */
    private int type;

    /**
     * ACEs
     */
    private ACE[] aces;
    private SID ownerUserSid, ownerGroupSid;


    /**
     * 
     */

@SuppressWarnings ( "javadoc" )
public class MsrpcSamrOpenDomain extends samr.SamrOpenDomain {

    public MsrpcSamrOpenDomain ( SamrPolicyHandle handle, int access, rpc.sid_t sid, SamrDomainHandle domainHandle ) {
        super(handle, access, sid, domainHandle);
        this.ptype = 0;
        this.flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

    private int sid, informationLevel, resumeKey, tflags;
    private String filename;
    private long maxItems;


    /**
     * 
     * @param config
     * @param sid
     * @param resumeKey
     * @param filename
     * @param batchCount
     * @param batchSize
     */

 * "The .NET Developer's Guide to Windows Security" (which is also
 * available online).
 * <p>
 * Direct ACEs are evaluated first in order. The SID of the user performing
 * the operation and the desired access bits are compared to the SID
 * and access mask of each ACE. If the SID matches, the allow/deny flags
 * and access mask are considered. If the ACE is a "deny"
 * ACE and <i>any</i> of the desired access bits match bits in the access