return null;
        }).when(cache).resolveSids0(any(), any(), any());

        // Resolve first two entries
        cache.resolveSids(ctx, null, arr, 0, 2);

        // Verify resolveSids0 called exactly once with the two SIDs needing resolution
        ArgumentCaptor<SID[]> captor = ArgumentCaptor.forClass(SID[].class);
        verify(cache, times(1)).resolveSids0(isNull(), same(ctx), captor.capture());

            out.acctName = ucstr.toString();
            out.type = resp.sid_type;
            out.origin_server = null;
            out.origin_ctx = null;
        }
    }

    void resolveSids0(final String authorityServerName, final CIFSContext tc, final jcifs.SID[] sids) throws CIFSException {
        synchronized (this.sidCache) {

            sids[si].acctName = new UnicodeString(rpc.names.names[si].name, false).toString();
            sids[si].origin_server = null;
            sids[si].origin_auth = null;
        }
    }

    static void resolveSids0(final String authorityServerName, final NtlmPasswordAuthentication auth, final SID[] sids) throws IOException {
        DcerpcHandle handle = null;
        LsaPolicyHandle policyHandle = null;

     */
    public boolean isResolveSids() {
        return resolveSids;
    }

    /**
     * Sets whether SIDs (Security Identifiers) should be resolved.
     * @param resolveSids true to resolve SIDs, false otherwise
     */
    public void setResolveSids(final boolean resolveSids) {
        this.resolveSids = resolveSids;
    }

    /**
     * Returns the character set used for SMB operations.

    }

    // Test resolveSids with array
    @Test
    void testResolveSids_Success() throws CIFSException {
        doNothing().when(sidResolver).resolveSids(any(CIFSContext.class), anyString(), any(SID[].class));

        assertDoesNotThrow(() -> sidResolver.resolveSids(mockContext, testServerName, testSids));

        verify(sidResolver, times(1)).resolveSids(mockContext, testServerName, testSids);
    }

     */
    public boolean isResolveSids() {
        return resolveSids;
    }

    /**
     * Sets whether SIDs (Security Identifiers) should be resolved.
     *
     * @param resolveSids true to resolve SIDs, false otherwise
     */
    public void setResolveSids(final boolean resolveSids) {
        this.resolveSids = resolveSids;
    }

    /**

            // Act
            sid.resolve("server.example", mockCtx);

            // Assert: resolver.resolveSids called with this SID
            ArgumentCaptor<jcifs.SID[]> captor = ArgumentCaptor.forClass(jcifs.SID[].class);
            verify(mockResolver, times(1)).resolveSids(same(mockCtx), eq("server.example"), captor.capture());
            assertSame(sid, captor.getValue()[0]);
        }

        @Test

     *
     * @param resolveSids
     *            Attempt to resolve the SIDs within each ACE form
     *            their numeric representation to their corresponding account names.
     * @return array of ACEs
     * @throws IOException if an I/O error occurs
     */
    ACE[] getSecurity(boolean resolveSids) throws IOException;

    /**

        String server = "myserver";
        sid.resolve(server, mockContext);

        ArgumentCaptor<jcifs.SID[]> sidArrayCaptor = ArgumentCaptor.forClass(jcifs.SID[].class);
        verify(mockResolver).resolveSids(eq(mockContext), eq(server), sidArrayCaptor.capture());
        assertEquals(1, sidArrayCaptor.getValue().length);
        assertEquals(sid, sidArrayCaptor.getValue()[0]);
    }

    /**

     */
    public void resolve(final String authorityServerName, final CIFSContext tc) throws IOException {
        final SID[] sids = new SID[1];
        sids[0] = this;
        tc.getSIDResolver().resolveSids(tc, authorityServerName, sids);
    }

    void resolveWeak() {
        if (this.origin_server != null) {
            try {
                resolve(this.origin_server, this.origin_ctx);